vBLAS.h

Go to the documentation of this file.

 
#ifndef __VBLAS__
#define __VBLAS__
 
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = power
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#if PRAGMA_ENUM_ALWAYSINT
#if defined(__fourbyteints__) && !__fourbyteints__
#define __VBLAS__RESTORE_TWOBYTEINTS
#pragma fourbyteints on
#endif
#pragma enumsalwaysint on
#elif PRAGMA_ENUM_OPTIONS
#pragma option enum =int
#elif PRAGMA_ENUM_PACK
#if __option(pack_enums)
#define __VBLAS__RESTORE_PACKED_ENUMS
#pragma options(!pack_enums)
#endif
#endif
 
   enum CBLAS_ORDER
   {
      CblasRowMajor = 101,
      CblasColMajor = 102
   };
   typedef enum CBLAS_ORDER CBLAS_ORDER;
 
   enum CBLAS_TRANSPOSE
   {
      CblasNoTrans = 111,
      CblasTrans = 112,
      CblasConjTrans = 113
   };
   typedef enum CBLAS_TRANSPOSE CBLAS_TRANSPOSE;
 
   enum CBLAS_UPLO
   {
      CblasUpper = 121,
      CblasLower = 122
   };
   typedef enum CBLAS_UPLO CBLAS_UPLO;
 
   enum CBLAS_DIAG
   {
      CblasNonUnit = 131,
      CblasUnit = 132
   };
   typedef enum CBLAS_DIAG CBLAS_DIAG;
 
   enum CBLAS_SIDE
   {
      CblasLeft = 141,
      CblasRight = 142
   };
   typedef enum CBLAS_SIDE CBLAS_SIDE;
 
#define IsAlignedCount(n) ((n > 0) && ((n & 3L) == 0))
#define IsAlignedAddr(a) (((long)a & 15L) == 0)
 
   float
   cblas_sdot(int N, const float *X, int incX, const float *Y, int incY);
 
   float
   cblas_snrm2(int N, const float *X, int incX);
 
   float
   cblas_sasum(int N, const float *X, int incX);
 
   int
   cblas_isamax(int N, const float *X, int incX);
 
   void
   cblas_sswap(int N, float *X, int incX, float *Y, int incY);
 
   void
   cblas_scopy(int N, const float *X, int incX, float *Y, int incY);
 
   void
   cblas_saxpy(int N, float alpha, const float *X, int incX, float *Y, int incY);
 
   void
   cblas_srot(int N, float *X, int incX, float *Y, int incY, float c, float s);
 
   void
   cblas_sscal(int N, float alpha, float *X, int incX);
 
   void
   cblas_sgemv(CBLAS_ORDER order, CBLAS_TRANSPOSE transA, int M, int N,
               float alpha, const float *A, int lda, const float *X, int incX,
               float beta, float *Y, int incY);
 
   void
   cblas_sgemm(CBLAS_ORDER order, CBLAS_TRANSPOSE transA, CBLAS_TRANSPOSE transB,
               int M, int N, int K, float alpha, const float *A, int lda,
               const float *B, int ldb, float beta, float *C, int ldc);
 
#ifdef __VEC__
   typedef vector float ConstVectorFloat;
   void
   vMultVecMat_4x4(ConstVectorFloat X[1], ConstVectorFloat A[4][1],
                   vector float Y[1]);
 
   void
   vMultMatVec_4x4(ConstVectorFloat A[4][1], ConstVectorFloat X[1],
                   vector float Y[1]);
 
   void
   vMultMatMat_4x4(ConstVectorFloat A[4][1], ConstVectorFloat B[4][1],
                   vector float C[4][1]);
 
   void
   vMultVecMat_8x8(ConstVectorFloat X[2], ConstVectorFloat A[8][2],
                   vector float Y[2]);
 
   void
   vMultMatVec_8x8(ConstVectorFloat A[8][2], ConstVectorFloat X[2],
                   vector float Y[2]);
 
   void
   vMultMatMat_8x8(ConstVectorFloat A[8][2], ConstVectorFloat B[8][2],
                   vector float C[8][2]);
 
   void
   vMultVecMat_16x16(ConstVectorFloat X[4], ConstVectorFloat A[16][4],
                     vector float Y[4]);
 
   void
   vMultMatVec_16x16(ConstVectorFloat A[16][4], ConstVectorFloat X[4],
                     vector float Y[4]);
 
   void
   vMultMatMat_16x16(ConstVectorFloat A[16][4], ConstVectorFloat B[16][4],
                     vector float C[16][4]);
 
   void
   vMultVecMat_32x32(ConstVectorFloat X[8], ConstVectorFloat A[32][8],
                     vector float Y[8]);
 
   void
   vMultMatVec_32x32(ConstVectorFloat A[32][8], ConstVectorFloat X[8],
                     vector float Y[8]);
 
   void
   vMultMatMat_32x32(ConstVectorFloat A[32][8], ConstVectorFloat B[32][8],
                     vector float C[32][8]);
 
#endif /* defined(__VEC__) */
 
   typedef CALLBACK_API_C(void, BLASParamErrorProc)(const char *funcName,
                                                    const char *paramName,
                                                    const int *paramPos,
                                                    const int *paramValue);
   void
   SetBLASParamErrorProc(BLASParamErrorProc ErrorProc);
 
   /* ==========================================================================================================================*/
 
#if PRAGMA_ENUM_ALWAYSINT
#pragma enumsalwaysint reset
#ifdef __VBLAS__RESTORE_TWOBYTEINTS
#pragma fourbyteints off
#endif
#elif PRAGMA_ENUM_OPTIONS
#pragma option enum =reset
#elif defined(__VBLAS__RESTORE_PACKED_ENUMS)
#pragma options(pack_enums)
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __VBLAS__ */