utlCoreMKL.h

Go to the documentation of this file.

#ifndef __utlCoreMKL_h
#define __utlCoreMKL_h

#include <cmath>

#ifdef UTL_USE_MKL
#include "utlMKL.h"
#endif

namespace utl
{

// interfaces to a few functions from the intel Vector Mathematical Library
template <typename T> void vAdd( int n,  T* vecIn,  T* vecIn2, T* vecOut);
template <typename T> void vSub( int n,  T* vecIn,  T* vecIn2, T* vecOut);
template <typename T> void vMul( int n,  T* vecIn,  T* vecIn2, T* vecOut);
template <typename T> void vDiv( int n,  T* vecIn,  T* vecIn2, T* vecOut);
template <typename T> void vSqr( int n,  T* vecIn, T* vecOut);
template <typename T> void vAbs( int n,  T* vecIn, T* vecOut);
template <typename T> void vExp( int n,  T* vecIn, T* vecOut);
template <typename T> void vInv( int n,  T* vecIn, T* vecOut);
template <typename T> void vSqrt( int n,  T* vecIn, T* vecOut);
template <typename T> void vInvSqrt( int n,  T* vecIn, T* vecOut);
template <typename T> void vCos( int n,  T* vecIn, T* vecOut);
template <typename T> void vSin( int n,  T* vecIn, T* vecOut);


#ifdef UTL_USE_MKL 

template <> inline void 
vSqr<double>( int n,  double* vecIn, double* vecOut) 
{
   vdSqr(n,vecIn,vecOut);
}
template <> inline void 
vSqr<float>( int n,  float* vecIn, float* vecOut) 
{
   vsSqr(n,vecIn,vecOut);
}
template <> inline void 
vSqrt<double>( int n,  double* vecIn, double* vecOut) 
{
   vdSqrt(n,vecIn,vecOut);
}
template <> inline void 
vSqrt<float>( int n,  float* vecIn, float* vecOut) 
{
   vsSqrt(n,vecIn,vecOut);
}
template <> inline void 
vSqrt<std::complex<double> >( int n,  std::complex<double>* vecIn, std::complex<double>* vecOut) 
{
   vzSqrt(n,vecIn,vecOut);
}
template <> inline void 
vSqrt<std::complex<float> >( int n,  std::complex<float>* vecIn, std::complex<float>* vecOut) 
{
   vcSqrt(n,vecIn,vecOut);
}
template <> inline void 
vInvSqrt<double>( int n,  double* vecIn, double* vecOut) 
{
   vdInvSqrt(n,vecIn,vecOut);
}
template <> inline void 
vInvSqrt<float>( int n,  float* vecIn, float* vecOut) 
{
   vsInvSqrt(n,vecIn,vecOut);
}

template <> inline void 
vSub<double>( int n,  double* vecIn, double* vecIn2, double* vecOut) 
{
   vdSub(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vSub<float>( int n,  float* vecIn, float* vecIn2, float* vecOut) 
{
   vsSub(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vSub<std::complex<double> >( int n,  std::complex<double>* vecIn, std::complex<double>* vecIn2, std::complex<double>* vecOut) 
{
   vzSub(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vSub<std::complex<float> >( int n,  std::complex<float>* vecIn, std::complex<float>* vecIn2, std::complex<float>* vecOut) 
{
   vcSub(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vDiv<double>( int n,  double* vecIn, double* vecIn2, double* vecOut) 
{
   vdDiv(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vDiv<float>( int n,  float* vecIn, float* vecIn2, float* vecOut) 
{
   vsDiv(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vDiv<std::complex<double> >( int n,  std::complex<double>* vecIn, std::complex<double>* vecIn2, std::complex<double>* vecOut) 
{
   vzDiv(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vDiv<std::complex<float> >( int n,  std::complex<float>* vecIn, std::complex<float>* vecIn2, std::complex<float>* vecOut) 
{
   vcDiv(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vExp<double>( int n,  double* vecIn, double* vecOut) 
{
   vdExp(n,vecIn,vecOut);
}
template <> inline void 
vExp<float>( int n,  float* vecIn, float* vecOut) 
{
   vsExp(n,vecIn,vecOut);
}
template <> inline void 
vCos<double>( int n,  double* vecIn, double* vecOut) 
{
   vdCos(n,vecIn,vecOut);
}
template <> inline void 
vCos<float>( int n,  float* vecIn, float* vecOut) 
{
   vsCos(n,vecIn,vecOut);
}
template <> inline void 
vSin<double>( int n,  double* vecIn, double* vecOut) 
{
   vdSin(n,vecIn,vecOut);
}
template <> inline void 
vSin<float>( int n,  float* vecIn, float* vecOut) 
{
   vsSin(n,vecIn,vecOut);
}
template <> inline void 
vInv<double>( int n,  double* vecIn, double* vecOut) 
{
   vdInv(n,vecIn,vecOut);
}
template <> inline void 
vInv<float>( int n,  float* vecIn, float* vecOut) 
{
   vsInv(n,vecIn,vecOut);
}
template <> inline void 
vAdd<double>( int n,  double* vecIn, double* vecIn2, double* vecOut) 
{
   vdAdd(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vAdd<float>( int n,  float* vecIn, float* vecIn2, float* vecOut) 
{
   vsAdd(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vMul<double>( int n,  double* vecIn, double* vecIn2, double* vecOut) 
{
   vdMul(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vMul<float>( int n,  float* vecIn, float* vecIn2, float* vecOut) 
{
   vsMul(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vMul<std::complex<double> >( int n,  std::complex<double>* vecIn, std::complex<double>* vecIn2, std::complex<double>* vecOut) 
{
   vzMul(n,vecIn,vecIn2,vecOut);
}
template <> inline void 
vMul<std::complex<float> >( int n,  std::complex<float>* vecIn, std::complex<float>* vecIn2, std::complex<float>* vecOut) 
{
   vcMul(n,vecIn,vecIn2,vecOut);
}

template <> inline void 
vAbs( int n,  double* vecIn, double* vecOut) 
{
   vdAbs(n,vecIn,vecOut);
}
template <> inline void 
vAbs( int n,  float* vecIn, float* vecOut) 
{
   vsAbs(n,vecIn,vecOut);
}
inline void 
vAbs( int n,  std::complex<double>* vecIn, double* vecOut) 
{
   vzAbs(n,vecIn,vecOut);
}
inline void 
vAbs( int n,  std::complex<float>* vecIn, float* vecOut) 
{
   vcAbs(n,vecIn,vecOut);
}

#else

template <typename T> inline void 
vSqr( int n,  T* vecIn, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=vecIn[i]*vecIn[i];
}
template <typename T> inline void 
vSqrt( int n,  T* vecIn, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=std::sqrt(vecIn[i]);
}
template <typename T> inline void 
vInvSqrt( int n,  T* vecIn, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=T(1.0)/std::sqrt(vecIn[i]);
}

template <typename T> inline void 
vSub( int n,  T* vecIn1, T* vecIn2, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=vecIn1[i]-vecIn2[i];
}
template <typename T> inline void 
vInv( int n,  T* vecIn, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=1.0/vecIn[i];
}
template <typename T> inline void 
vExp( int n,  T* vecIn, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=std::exp(vecIn[i]);
}
template <typename T> inline void 
vAdd( int n,  T* vecIn1, T* vecIn2, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=vecIn1[i]+vecIn2[i];
}
template <typename T> inline void 
vMul( int n,  T* vecIn1, T* vecIn2, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=vecIn1[i]*vecIn2[i];
}
template <typename T> inline void 
vDiv( int n,  T* vecIn1, T* vecIn2, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=vecIn1[i]/vecIn2[i];
}
template <typename T> inline void 
vAbs( int n,  T* vecIn, T* vecOut) 
{
   for (int i = 0; i<n; ++i) 
     vecOut[i]=std::abs(vecIn[i]);
}

#endif

}

#endif