Added a copy of CBLAS so we can use it when linking against a BLAS that

doesn't have it.

dlib/external/cblas/CMakeLists.txt

+#
+# This is a CMake makefile.  You can find the cmake utility and
+# information about it at http://www.cmake.org
+#
+
+
+cmake_minimum_required(VERSION 2.8.4)
+project(cblas)
+
+
+enable_language (Fortran)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE True)
+add_definitions(-DADD_ -DF77_INT=ptrdiff_t)
+
+add_library(cblas STATIC 
+   cblas_caxpy.c
+   #cblas_ccopy.c
+   cblas_cdotc_sub.c
+   cblas_cdotu_sub.c
+   #cblas_cgbmv.c
+   cblas_cgemm.c
+   cblas_cgemv.c
+   cblas_cgerc.c
+   cblas_cgeru.c
+   #cblas_chbmv.c
+   #cblas_chemm.c
+   #cblas_chemv.c
+   #cblas_cher2.c
+   #cblas_cher2k.c
+   #cblas_cher.c
+   #cblas_cherk.c
+   #cblas_chpmv.c
+   #cblas_chpr2.c
+   #cblas_chpr.c
+   cblas_cscal.c
+   #cblas_csscal.c
+   #cblas_cswap.c
+   #cblas_csymm.c
+   #cblas_csyr2k.c
+   #cblas_csyrk.c
+   #cblas_ctbmv.c
+   #cblas_ctbsv.c
+   #cblas_ctpmv.c
+   #cblas_ctpsv.c
+   #cblas_ctrmm.c
+   #cblas_ctrmv.c
+   cblas_ctrsm.c
+   #cblas_ctrsv.c
+   #cblas_dasum.c
+   cblas_daxpy.c
+   #cblas_dcopy.c
+   cblas_ddot.c
+   #cblas_dgbmv.c
+   cblas_dgemm.c
+   cblas_dgemv.c
+   cblas_dger.c
+   #cblas_dnrm2.c
+   #cblas_drot.c
+   #cblas_drotg.c
+   #cblas_drotm.c
+   #cblas_drotmg.c
+   #cblas_dsbmv.c
+   cblas_dscal.c
+   #cblas_dsdot.c
+   #cblas_dspmv.c
+   #cblas_dspr2.c
+   #cblas_dspr.c
+   #cblas_dswap.c
+   #cblas_dsymm.c
+   #cblas_dsymv.c
+   #cblas_dsyr2.c
+   #cblas_dsyr2k.c
+   #cblas_dsyr.c
+   #cblas_dsyrk.c
+   #cblas_dtbmv.c
+   #cblas_dtbsv.c
+   #cblas_dtpmv.c
+   #cblas_dtpsv.c
+   #cblas_dtrmm.c
+   #cblas_dtrmv.c
+   cblas_dtrsm.c
+   #cblas_dtrsv.c
+   #cblas_dzasum.c
+   #cblas_dznrm2.c
+   #cblas_icamax.c
+   #cblas_idamax.c
+   #cblas_isamax.c
+   #cblas_izamax.c
+   #cblas_sasum.c
+   cblas_saxpy.c
+   #cblas_scasum.c
+   #cblas_scnrm2.c
+   #cblas_scopy.c
+   cblas_sdot.c
+   #cblas_sdsdot.c
+   #cblas_sgbmv.c
+   cblas_sgemm.c
+   cblas_sgemv.c
+   cblas_sger.c
+   #cblas_snrm2.c
+   #cblas_srot.c
+   #cblas_srotg.c
+   #cblas_srotm.c
+   #cblas_srotmg.c
+   #cblas_ssbmv.c
+   cblas_sscal.c
+   #cblas_sspmv.c
+   #cblas_sspr2.c
+   #cblas_sspr.c
+   #cblas_sswap.c
+   #cblas_ssymm.c
+   #cblas_ssymv.c
+   #cblas_ssyr2.c
+   #cblas_ssyr2k.c
+   #cblas_ssyr.c
+   #cblas_ssyrk.c
+   #cblas_stbmv.c
+   #cblas_stbsv.c
+   #cblas_stpmv.c
+   #cblas_stpsv.c
+   #cblas_strmm.c
+   #cblas_strmv.c
+   cblas_strsm.c
+   #cblas_strsv.c
+   cblas_xerbla.c
+   cblas_zaxpy.c
+   #cblas_zcopy.c
+   cblas_zdotc_sub.c
+   cblas_zdotu_sub.c
+   #cblas_zdscal.c
+   #cblas_zgbmv.c
+   cblas_zgemm.c
+   cblas_zgemv.c
+   cblas_zgerc.c
+   cblas_zgeru.c
+   #cblas_zhbmv.c
+   #cblas_zhemm.c
+   #cblas_zhemv.c
+   #cblas_zher2.c
+   #cblas_zher2k.c
+   #cblas_zher.c
+   #cblas_zherk.c
+   #cblas_zhpmv.c
+   #cblas_zhpr2.c
+   #cblas_zhpr.c
+   cblas_zscal.c
+   #cblas_zswap.c
+   #cblas_zsymm.c
+   #cblas_zsyr2k.c
+   #cblas_zsyrk.c
+   #cblas_ztbmv.c
+   #cblas_ztbsv.c
+   #cblas_ztpmv.c
+   #cblas_ztpsv.c
+   #cblas_ztrmm.c
+   #cblas_ztrmv.c
+   cblas_ztrsm.c
+   #cblas_ztrsv.c
+
+   cdotcsub.f
+   cdotusub.f
+   dasumsub.f
+   ddotsub.f
+   dnrm2sub.f
+   dsdotsub.f
+   dzasumsub.f
+   dznrm2sub.f
+   icamaxsub.f
+   idamaxsub.f
+   isamaxsub.f
+   izamaxsub.f
+   sasumsub.f
+   scasumsub.f
+   scnrm2sub.f
+   sdotsub.f
+   sdsdotsub.f
+   snrm2sub.f
+   zdotcsub.f
+   zdotusub.f
+      )
+

dlib/external/cblas/README

+This folder contains a copy of CBLAS (from http://www.netlib.org/blas/) which
+has been setup so you can compile it with CMake.  It also only compiles the
+part of CBLAS needed by dlib.
+
+Most BLAS libraries come with CBLAS, however, some don't.  In particular, if
+you are using the BLAS that comes with MATLAB then you will need this CBLAS
+code linked into your own to get dlib working with MATLAB's built in BLAS.

dlib/external/cblas/cblas_caxpy.c

+/*
+ * cblas_caxpy.c
+ *
+ * The program is a C interface to caxpy.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_caxpy( const int N, const void *alpha, const void *X,
+                       const int incX, void *Y, const int incY)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_caxpy( &F77_N, alpha, X, &F77_incX, Y, &F77_incY);
+} 

dlib/external/cblas/cblas_ccopy.c

+/*
+ * cblas_ccopy.c
+ *
+ * The program is a C interface to ccopy.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ccopy( const int N, const void *X,
+                      const int incX, void *Y, const int incY)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_ccopy( &F77_N, X, &F77_incX, Y, &F77_incY);
+}

dlib/external/cblas/cblas_cdotc_sub.c

+/*
+ * cblas_cdotc_sub.c
+ *
+ * The program is a C interface to cdotc.
+ * It calls the fortran wrapper before calling cdotc.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cdotc_sub( const int N, const void *X, const int incX,
+                    const void *Y, const int incY,void *dotc)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_cdotc_sub( &F77_N, X, &F77_incX, Y, &F77_incY, dotc);
+}

dlib/external/cblas/cblas_cdotu_sub.c

+/*
+ * cblas_cdotu_sub.f
+ *
+ * The program is a C interface to cdotu.
+ * It calls the forteran wrapper before calling cdotu.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cdotu_sub( const int N, const void *X,
+                     const int incX, const void *Y, const int incY,void *dotu)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_cdotu_sub( &F77_N, X, &F77_incX, Y, &F77_incY, dotu);
+}

dlib/external/cblas/cblas_cgbmv.c

+/*
+ * cblas_cgbmv.c
+ * The program is a C interface of cgbmv
+ * 
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cgbmv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
+                 const int KL, const int KU,
+                 const void *alpha, const void  *A, const int lda,
+                 const void  *X, const int incX, const void *beta,
+                 void  *Y, const int incY)
+{
+   char TA;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA;
+#else
+   #define F77_TA &TA   
+#endif
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+   F77_INT F77_KL=KL,F77_KU=KU;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_KL KL
+   #define F77_KU KU
+   #define F77_incX incx
+   #define F77_incY incY
+#endif
+   int n=0, i=0, incx=incX;
+   const float *xx= (float *)X, *alp= (float *)alpha, *bet = (float *)beta;
+   float ALPHA[2],BETA[2];
+   int tincY, tincx;
+   float *x=(float *)X, *y=(float *)Y, *st=0, *tx=0;
+
+   if (order == CblasColMajor)
+   {
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cgbmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+      #endif
+      F77_cgbmv(F77_TA, &F77_M, &F77_N, &F77_KL, &F77_KU, alpha,  
+                     A, &F77_lda, X, &F77_incX, beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans)
+      {
+         ALPHA[0]= *alp;
+         ALPHA[1]= -alp[1];
+         BETA[0]= *bet;
+         BETA[1]= -bet[1];
+         TA = 'N';
+         if (M > 0)
+         {
+            n = M << 1;
+            x = malloc(n*sizeof(float));
+            tx = x;
+
+            if( incX > 0 ) {
+               i = incX << 1 ;
+               tincx = 2;
+               st= x+n;
+            } else {
+               i = incX *(-2);
+               tincx = -2;
+               st = x-2;
+               x +=(n-2);
+            }
+            do
+            {
+               *x = *xx;
+               x[1] = -xx[1];
+               x += tincx ;
+               xx += i;
+            }
+            while (x != st);
+            x=tx;
+
+            #ifdef F77_INT
+               F77_incX = 1;
+            #else
+               incx = 1;
+            #endif
+
+            if( incY > 0 )
+              tincY = incY;
+            else
+              tincY = -incY;
+
+            y++;
+ 
+            if (N > 0)
+            {
+               i = tincY << 1;
+               n = i * N ;
+               st = y + n;
+               do {
+                  *y = -(*y);
+                  y += i;
+               } while(y != st);
+               y -= n;
+            }
+         }
+         else x = (float *) X;
+
+ 
+      }
+      else 
+      {
+         cblas_xerbla(2, "cblas_cgbmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+      #endif
+      if (TransA == CblasConjTrans)
+         F77_cgbmv(F77_TA, &F77_N, &F77_M, &F77_KU, &F77_KL, ALPHA, 
+                        A ,&F77_lda, x,&F77_incX, BETA, Y, &F77_incY);
+      else
+         F77_cgbmv(F77_TA, &F77_N, &F77_M, &F77_KU, &F77_KL, alpha, 
+                        A ,&F77_lda, x,&F77_incX, beta, Y, &F77_incY);
+      if (TransA == CblasConjTrans)
+      {
+         if (x != X) free(x);
+         if (N > 0)
+         {
+            do
+            {
+               *y = -(*y);
+               y += i;
+            }
+            while (y != st);
+         }
+      }
+   }
+   else cblas_xerbla(1, "cblas_cgbmv", "Illegal Order setting, %d\n", order);
+}

dlib/external/cblas/cblas_cgemm.c

+/*
+ *
+ * cblas_cgemm.c
+ * This program is a C interface to cgemm.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,
+                 const enum CBLAS_TRANSPOSE TransB, const int M, const int N,
+                 const int K, const void *alpha, const void  *A,
+                 const int lda, const void  *B, const int ldb,
+                 const void *beta, void  *C, const int ldc)
+{
+   char TA, TB;   
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_TB;
+#else
+   #define F77_TA &TA  
+   #define F77_TB &TB  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_K=K, F77_lda=lda, F77_ldb=ldb;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_ldb ldb
+   #define F77_ldc ldc
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+      if(TransA == CblasTrans) TA='T';
+      else if ( TransA == CblasConjTrans ) TA='C';
+      else if ( TransA == CblasNoTrans )   TA='N';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cgemm", "Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+
+      if(TransB == CblasTrans) TB='T';
+      else if ( TransB == CblasConjTrans ) TB='C';
+      else if ( TransB == CblasNoTrans )   TB='N';
+      else 
+      {
+         cblas_xerbla(3, "cblas_cgemm", "Illegal TransB setting, %d\n", TransB);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+         F77_TB = C2F_CHAR(&TB);
+      #endif
+
+      F77_cgemm(F77_TA, F77_TB, &F77_M, &F77_N, &F77_K, alpha, A,
+                     &F77_lda, B, &F77_ldb, beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      if(TransA == CblasTrans) TB='T';
+      else if ( TransA == CblasConjTrans ) TB='C';
+      else if ( TransA == CblasNoTrans )   TB='N';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cgemm", "Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      if(TransB == CblasTrans) TA='T';
+      else if ( TransB == CblasConjTrans ) TA='C';
+      else if ( TransB == CblasNoTrans )   TA='N';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cgemm", "Illegal TransB setting, %d\n", TransB);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+         F77_TB = C2F_CHAR(&TB);
+      #endif
+
+      F77_cgemm(F77_TA, F77_TB, &F77_N, &F77_M, &F77_K, alpha, B,
+                  &F77_ldb, A, &F77_lda, beta, C, &F77_ldc);
+   } 
+   else cblas_xerbla(1, "cblas_cgemm", "Illegal Order setting, %d\n", Order);
+   return;
+}

dlib/external/cblas/cblas_cgemv.c

+/*
+ * cblas_cgemv.c
+ * The program is a C interface of cgemv
+ * 
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cgemv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
+                 const void *alpha, const void  *A, const int lda,
+                 const void  *X, const int incX, const void *beta,
+                 void  *Y, const int incY)
+{
+   char TA;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA;
+#else
+   #define F77_TA &TA   
+#endif
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_incX incx
+   #define F77_incY incY
+#endif
+
+   int n=0, i=0, incx=incX;
+   const float *xx= (const float *)X;
+   float ALPHA[2],BETA[2];
+   int tincY, tincx;
+   float *x=(float *)X, *y=(float *)Y, *st=0, *tx=0;
+   const float *stx = x;
+
+
+   if (order == CblasColMajor)
+   {
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cgemv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+      #endif
+      F77_cgemv(F77_TA, &F77_M, &F77_N, alpha, A, &F77_lda, X, &F77_incX, 
+                beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+         
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans)
+      {
+         ALPHA[0]=    *( (const float *)  alpha    );
+         ALPHA[1]= -( *( (const float *)  alpha+1) );
+         BETA[0]=     *( (const float *)  beta     );
+         BETA[1]= -(  *( (const float *)  beta+1 ) );
+         TA = 'N';
+         if (M > 0)
+         {
+            n = M << 1;
+            x = malloc(n*sizeof(float));
+            tx = x;
+            if( incX > 0 ) {
+               i = incX << 1 ;
+               tincx = 2;
+               st= x+n;
+            } else { 
+               i = incX *(-2);
+               tincx = -2;
+               st = x-2; 
+               x +=(n-2); 
+            }
+
+            do
+            {
+               *x = *xx;
+               x[1] = -xx[1];
+               x += tincx ;
+               xx += i;
+            }
+            while (x != st);
+            x=tx;
+
+            F77_incX = 1;
+
+            if(incY > 0)
+               tincY = incY; 
+            else
+               tincY = -incY; 
+
+            y++;
+
+            if (N > 0)
+            {
+               i = tincY << 1;
+               n = i * N ;
+               st = y + n;
+               do {
+                  *y = -(*y);
+                  y += i;
+               } while(y != st); 
+               y -= n;
+            }
+            stx = x;
+         }
+         else stx = (const float *)X;
+      }
+      else 
+      {
+         cblas_xerbla(2, "cblas_cgemv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+      #endif
+      if (TransA == CblasConjTrans)
+         F77_cgemv(F77_TA, &F77_N, &F77_M, ALPHA, A, &F77_lda, stx,
+                &F77_incX, BETA, Y, &F77_incY);
+      else
+         F77_cgemv(F77_TA, &F77_N, &F77_M, alpha, A, &F77_lda, x,
+                &F77_incX, beta, Y, &F77_incY);
+
+      if (TransA == CblasConjTrans)
+      {
+         if (x != (const float *)X) free(x);
+         if (N > 0)
+         {
+            do
+            {
+               *y = -(*y);
+               y += i;
+            }
+            while (y != st);
+         }
+      }
+   }
+   else cblas_xerbla(1, "cblas_cgemv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_cgerc.c

+/*
+ * cblas_cgerc.c
+ * The program is a C interface to cgerc.
+ * 
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cgerc(const enum CBLAS_ORDER order, const int M, const int N,
+                 const void *alpha, const void *X, const int incX,
+                 const void *Y, const int incY, void *A, const int lda)
+{
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incy
+   #define F77_lda lda   
+#endif
+
+   int n, i, tincy, incy=incY;
+   float *y=(float *)Y, *yy=(float *)Y, *ty, *st;
+
+
+   if (order == CblasColMajor)
+   {
+      F77_cgerc( &F77_M, &F77_N, alpha, X, &F77_incX, Y, &F77_incY, A, 
+                      &F77_lda);
+   }  else if (order == CblasRowMajor)   
+   {
+      if (N > 0)
+      {
+         n = N << 1;
+         y = malloc(n*sizeof(float));
+
+         ty = y;
+         if( incY > 0 ) {
+            i = incY << 1;
+            tincy = 2;
+            st= y+n;
+         } else { 
+            i = incY *(-2);
+            tincy = -2;
+            st = y-2; 
+            y +=(n-2); 
+         }
+         do
+         {
+            *y = *yy;
+            y[1] = -yy[1];
+            y += tincy ;
+            yy += i;
+         }
+         while (y != st);
+         y = ty;
+
+         #ifdef F77_INT
+            F77_incY = 1;
+         #else
+            incy = 1;
+         #endif
+      }
+      else y = (float *) Y;
+
+      F77_cgeru( &F77_N, &F77_M, alpha, y, &F77_incY, X, &F77_incX, A, 
+                      &F77_lda);
+      if(Y!=y)
+         free(y);
+
+   } else cblas_xerbla(1, "cblas_cgerc", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_cgeru.c

+/*
+ * cblas_cgeru.c
+ * The program is a C interface to cgeru.
+ * 
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cgeru(const enum CBLAS_ORDER order, const int M, const int N,
+                 const void *alpha, const void *X, const int incX,
+                 const void *Y, const int incY, void *A, const int lda)
+{
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+   #define F77_lda lda
+#endif
+
+
+
+   if (order == CblasColMajor)
+   {
+      F77_cgeru( &F77_M, &F77_N, alpha, X, &F77_incX, Y, &F77_incY, A,
+                      &F77_lda);
+   }
+   else if (order == CblasRowMajor)
+   {
+      F77_cgeru( &F77_N, &F77_M, alpha, Y, &F77_incY, X, &F77_incX, A, 
+                      &F77_lda);
+   }
+   else cblas_xerbla(1, "cblas_cgeru","Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_chbmv.c

+/*
+ * cblas_chbmv.c
+ * The program is a C interface to chbmv
+ * 
+ * Keita Teranishi  5/18/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+#include <stdio.h>
+#include <stdlib.h>
+void cblas_chbmv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_UPLO Uplo,const int N,const int K,
+                 const void *alpha, const void  *A, const int lda,
+                 const void  *X, const int incX, const void *beta,
+                 void  *Y, const int incY)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_K=K, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_incX incx
+   #define F77_incY incY
+#endif
+   int n, i=0, incx=incX;
+   const float *xx= (float *)X, *alp= (float *)alpha, *bet = (float *)beta;
+   float ALPHA[2],BETA[2];
+   int tincY, tincx;
+   float *x=(float *)X, *y=(float *)Y, *st=0, *tx;
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chbmv","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_chbmv(F77_UL, &F77_N, &F77_K, alpha, A, &F77_lda, X,  
+                     &F77_incX, beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      ALPHA[0]= *alp;
+      ALPHA[1]= -alp[1];
+      BETA[0]= *bet;
+      BETA[1]= -bet[1];
+
+      if (N > 0)
+      {
+         n = N << 1;
+         x = malloc(n*sizeof(float));
+ 
+         tx = x;
+         if( incX > 0 ) {
+           i = incX << 1 ;
+           tincx = 2;
+           st= x+n;
+         } else {
+           i = incX *(-2);
+           tincx = -2;
+           st = x-2;
+           x +=(n-2);
+         }
+
+         do
+         {
+           *x = *xx;
+           x[1] = -xx[1];
+           x += tincx ;
+           xx += i;
+         }
+         while (x != st);
+         x=tx;
+
+
+         #ifdef F77_INT
+            F77_incX = 1;
+         #else
+            incx = 1;
+         #endif
+ 
+         if(incY > 0)
+           tincY = incY;
+         else
+           tincY = -incY;
+         y++;
+
+         i = tincY << 1;
+         n = i * N ;
+         st = y + n;
+         do {
+            *y = -(*y);
+            y += i;
+         } while(y != st);
+         y -= n;
+      }  else
+         x = (float *) X; 
+
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chbmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_chbmv(F77_UL, &F77_N, &F77_K, ALPHA, 
+                     A ,&F77_lda, x,&F77_incX, BETA, Y, &F77_incY);
+   }
+   else 
+   {
+      cblas_xerbla(1, "cblas_chbmv","Illegal Order setting, %d\n", order);
+      return;
+   }
+   if ( order == CblasRowMajor )
+   {
+      if(X!=x)
+         free(x);
+      if (N > 0)
+      {
+         do
+         {
+            *y = -(*y);
+            y += i;
+         }
+         while (y != st);
+      }
+   }
+   return;
+}

dlib/external/cblas/cblas_chemm.c

+/*
+ *
+ * cblas_chemm.c
+ * This program is a C interface to chemm.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_chemm(const enum CBLAS_ORDER Order, const  enum CBLAS_SIDE Side,
+                 const enum CBLAS_UPLO Uplo, const int M, const int N,
+                 const void *alpha, const void *A, const int lda,
+                 const void *B, const int ldb, const void *beta,
+                 void *C, const int ldc)
+{
+   char SD, UL;   
+#ifdef F77_CHAR
+   F77_CHAR F77_SD, F77_UL;
+#else
+   #define F77_SD &SD  
+   #define F77_UL &UL  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_ldb=ldb;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_ldb ldb
+   #define F77_ldc ldc
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+      if( Side == CblasRight) SD='R';
+      else if ( Side == CblasLeft ) SD='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chemm", "Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(3, "cblas_chemm", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_SD = C2F_CHAR(&SD);
+      #endif
+
+      F77_chemm(F77_SD, F77_UL, &F77_M, &F77_N, alpha, A, &F77_lda, 
+                     B, &F77_ldb, beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      if( Side == CblasRight) SD='L';
+      else if ( Side == CblasLeft ) SD='R';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chemm", "Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(3, "cblas_chemm", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_SD = C2F_CHAR(&SD);
+      #endif
+
+      F77_chemm(F77_SD, F77_UL, &F77_N, &F77_M, alpha, A,
+                 &F77_lda, B, &F77_ldb, beta, C, &F77_ldc);
+   } 
+   else  cblas_xerbla(1, "cblas_chemm", "Illegal Order setting, %d\n", Order);
+   return;
+}

dlib/external/cblas/cblas_chemv.c

+/*
+ * cblas_chemv.c
+ * The program is a C interface to chemv
+ * 
+ * Keita Teranishi  5/18/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_chemv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_UPLO Uplo, const int N,
+                 const void *alpha, const void *A, const int lda,
+                 const void *X, const int incX, const void *beta,
+                 void  *Y, const int incY)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_incX incx
+   #define F77_incY incY
+#endif
+   int n=0, i=0, incx=incX;
+   const float *xx= (float *)X, *alp= (float *)alpha, *bet = (float *)beta;
+   float ALPHA[2],BETA[2];
+   int tincY, tincx;
+   float *x=(float *)X, *y=(float *)Y, *st=0, *tx;
+
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chemv","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_chemv(F77_UL, &F77_N, alpha, A, &F77_lda, X, &F77_incX, 
+                beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      ALPHA[0]= *alp;
+      ALPHA[1]= -alp[1];
+      BETA[0]= *bet;
+      BETA[1]= -bet[1];
+
+      if (N > 0)
+      {
+         n = N << 1;
+         x = malloc(n*sizeof(float));
+ 
+         tx = x;
+         if( incX > 0 ) {
+           i = incX << 1 ;
+           tincx = 2;
+           st= x+n;
+         } else {
+           i = incX *(-2);
+           tincx = -2;
+           st = x-2;
+           x +=(n-2);
+         }
+
+         do
+         {
+           *x = *xx;
+           x[1] = -xx[1];
+           x += tincx ;
+           xx += i;
+         }
+         while (x != st);
+         x=tx;
+
+
+         #ifdef F77_INT
+            F77_incX = 1;
+         #else
+            incx = 1;
+         #endif
+ 
+         if(incY > 0)
+           tincY = incY;
+         else
+           tincY = -incY;
+         y++;
+
+         i = tincY << 1;
+         n = i * N ;
+         st = y + n;
+         do {
+            *y = -(*y);
+            y += i;
+         } while(y != st);
+         y -= n;
+      }  else
+         x = (float *) X;
+
+          
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chemv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_chemv(F77_UL, &F77_N, ALPHA, A, &F77_lda, x, &F77_incX, 
+                BETA, Y, &F77_incY);
+   }
+   else 
+   {
+      cblas_xerbla(1, "cblas_chemv","Illegal Order setting, %d\n", order);
+      return;
+   }
+   if ( order == CblasRowMajor )
+   {
+      if ( X != x )
+         free(x);
+      if (N > 0)
+      {
+         do
+         {
+            *y = -(*y);
+            y += i;
+         }
+         while (y != st);
+     }
+   }
+   return;
+}

dlib/external/cblas/cblas_cher.c

+/*
+ * cblas_cher.c
+ * The program is a C interface to cher.
+ * 
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                const int N, const float alpha, const void *X, const int incX
+                ,void *A, const int lda)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_lda=lda, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_incX incx
+#endif
+   int n, i, tincx, incx=incX;
+   float *x=(float *)X, *xx=(float *)X, *tx, *st;
+
+ 
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cher","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+
+      F77_cher(F77_UL, &F77_N, &alpha, X, &F77_incX, A, &F77_lda);
+
+   }  else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cher","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      if (N > 0)
+      {
+         n = N << 1;
+         x = malloc(n*sizeof(float));
+         tx = x;
+         if( incX > 0 ) {
+            i = incX << 1 ;
+            tincx = 2;
+            st= x+n;
+         } else { 
+            i = incX *(-2);
+            tincx = -2;
+            st = x-2; 
+            x +=(n-2); 
+         }
+         do
+         {
+            *x = *xx;
+            x[1] = -xx[1];
+            x += tincx ;
+            xx += i;
+         }
+         while (x != st);
+         x=tx;
+
+         #ifdef F77_INT
+           F77_incX = 1;
+         #else
+           incx = 1;
+         #endif
+      }
+      else x = (float *) X;
+      F77_cher(F77_UL, &F77_N, &alpha, x, &F77_incX, A, &F77_lda);
+   } else 
+   {
+      cblas_xerbla(1, "cblas_cher","Illegal Order setting, %d\n", order);
+      return;
+   }
+   if(X!=x) 
+      free(x);
+   
+   return;
+}

dlib/external/cblas/cblas_cher2.c

+/*
+ * cblas_cher2.c
+ * The program is a C interface to cher2.
+ * 
+ * Keita Teranishi  3/23/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                 const int N, const void *alpha, const void *X, const int incX,
+                 const void *Y, const int incY, void *A, const int lda)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_incX incx
+   #define F77_incY incy
+#endif
+   int n, i, j, tincx, tincy, incx=incX, incy=incY;
+   float *x=(float *)X, *xx=(float *)X, *y=(float *)Y, 
+         *yy=(float *)Y, *tx, *ty, *stx, *sty;
+
+ 
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cher2","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+
+      F77_cher2(F77_UL, &F77_N, alpha, X, &F77_incX, 
+                                            Y, &F77_incY, A, &F77_lda);
+
+   }  else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cher2","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      if (N > 0)
+      {
+         n = N << 1;
+         x = malloc(n*sizeof(float));
+         y = malloc(n*sizeof(float));         
+         tx = x;
+         ty = y;
+         if( incX > 0 ) {
+            i = incX << 1 ;
+            tincx = 2;
+            stx= x+n;
+         } else { 
+            i = incX *(-2);
+            tincx = -2;
+            stx = x-2; 
+            x +=(n-2); 
+         }
+         
+         if( incY > 0 ) {
+            j = incY << 1;
+            tincy = 2;
+            sty= y+n;
+         } else { 
+            j = incY *(-2);
+            tincy = -2;
+            sty = y-2; 
+            y +=(n-2); 
+         }
+
+         do
+         {
+            *x = *xx;
+            x[1] = -xx[1];
+            x += tincx ;
+            xx += i;
+         }
+         while (x != stx);
+
+         do
+         {
+            *y = *yy;
+            y[1] = -yy[1];
+            y += tincy ;
+            yy += j;
+         }
+         while (y != sty);
+
+         x=tx;
+         y=ty;
+
+         #ifdef F77_INT
+            F77_incX = 1;
+            F77_incY = 1;
+         #else
+            incx = 1;
+            incy = 1;
+         #endif
+      }  else 
+      {
+         x = (float *) X;
+         y = (float *) Y;
+      }
+      F77_cher2(F77_UL, &F77_N, alpha, y, &F77_incY, x, 
+                                      &F77_incX, A, &F77_lda);
+   } else 
+   {
+      cblas_xerbla(1, "cblas_cher2","Illegal Order setting, %d\n", order);
+      return;
+   }
+   if(X!=x)
+      free(x);
+   if(Y!=y)
+      free(y);
+
+   return;
+}

dlib/external/cblas/cblas_cher2k.c

+/*
+ *
+ * cblas_cher2k.c
+ * This program is a C interface to cher2k.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
+                  const enum CBLAS_TRANSPOSE Trans, const int N, const int K,
+                  const void *alpha, const void *A, const int lda,
+                  const void *B, const int ldb, const float beta,
+                  void *C, const int ldc)
+{
+   char UL, TR;   
+#ifdef F77_CHAR
+   F77_CHAR F77_TR, F77_UL;
+#else
+   #define F77_TR &TR  
+   #define F77_UL &UL  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_K=K, F77_lda=lda, F77_ldb=ldb;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_ldb ldb
+   #define F77_ldc ldc
+#endif
+
+   float ALPHA[2]; 
+   const float *alp=(float *)alpha;
+
+
+   if( Order == CblasColMajor )
+   {
+
+      if( Uplo == CblasUpper) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cher2k", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if( Trans == CblasTrans) TR ='T';
+      else if ( Trans == CblasConjTrans ) TR='C';
+      else if ( Trans == CblasNoTrans )   TR='N';
+      else 
+      {
+         cblas_xerbla(3, "cblas_cher2k", "Illegal Trans setting, %d\n", Trans);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TR = C2F_CHAR(&TR);
+      #endif
+
+      F77_cher2k(F77_UL, F77_TR, &F77_N, &F77_K, alpha, A, &F77_lda, B, &F77_ldb, &beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      
+      if( Uplo == CblasUpper) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cher2k", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if( Trans == CblasTrans) TR ='N';
+      else if ( Trans == CblasConjTrans ) TR='N';
+      else if ( Trans == CblasNoTrans )   TR='C';
+      else 
+      {
+         cblas_xerbla(3, "cblas_cher2k", "Illegal Trans setting, %d\n", Trans);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TR = C2F_CHAR(&TR);
+      #endif
+
+      ALPHA[0]= *alp;
+      ALPHA[1]= -alp[1];
+      F77_cher2k(F77_UL,F77_TR, &F77_N, &F77_K, ALPHA, A, &F77_lda, B, &F77_ldb, &beta, C, &F77_ldc);
+   } 
+   else  cblas_xerbla(1, "cblas_cher2k", "Illegal Order setting, %d\n", Order);
+   return;
+}

dlib/external/cblas/cblas_cherk.c

+/*
+ *
+ * cblas_cherk.c
+ * This program is a C interface to cherk.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
+                 const enum CBLAS_TRANSPOSE Trans, const int N, const int K,
+                 const float alpha, const void *A, const int lda,
+                 const float beta, void *C, const int ldc)
+{
+   char UL, TR;   
+#ifdef F77_CHAR
+   F77_CHAR F77_TR, F77_UL;
+#else
+   #define F77_TR &TR  
+   #define F77_UL &UL  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_K=K, F77_lda=lda;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_ldc ldc
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+      if( Uplo == CblasUpper) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_cherk", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if( Trans == CblasTrans) TR ='T';
+      else if ( Trans == CblasConjTrans ) TR='C';
+      else if ( Trans == CblasNoTrans )   TR='N';
+      else 
+      {
+         cblas_xerbla(3, "cblas_cherk", "Illegal Trans setting, %d\n", Trans);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TR = C2F_CHAR(&TR);
+      #endif
+
+      F77_cherk(F77_UL, F77_TR, &F77_N, &F77_K, &alpha, A, &F77_lda,
+                     &beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      if( Uplo == CblasUpper) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(3, "cblas_cherk", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if( Trans == CblasTrans) TR ='N';
+      else if ( Trans == CblasConjTrans ) TR='N';
+      else if ( Trans == CblasNoTrans )   TR='C';
+      else 
+      {
+         cblas_xerbla(3, "cblas_cherk", "Illegal Trans setting, %d\n", Trans);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_SD = C2F_CHAR(&SD);
+      #endif
+
+      F77_cherk(F77_UL, F77_TR, &F77_N, &F77_K, &alpha, A, &F77_lda,
+                &beta, C, &F77_ldc);
+   } 
+   else  cblas_xerbla(1, "cblas_cherk", "Illegal Order setting, %d\n", Order);
+   return;
+}

dlib/external/cblas/cblas_chpmv.c

+/*
+ * cblas_chpmv.c
+ * The program is a C interface of chpmv
+ * 
+ * Keita Teranishi  5/18/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_chpmv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_UPLO Uplo,const int N,
+                 const void *alpha, const void  *AP,
+                 const void  *X, const int incX, const void *beta,
+                 void  *Y, const int incY)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_incX incx
+   #define F77_incY incY
+#endif
+   int n, i=0, incx=incX;
+   const float *xx= (float *)X, *alp= (float *)alpha, *bet = (float *)beta;
+   float ALPHA[2],BETA[2];
+   int tincY, tincx;
+   float *x=(float *)X, *y=(float *)Y, *st=0, *tx;
+
+   if (order == CblasColMajor)
+   { 
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chpmv","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_chpmv(F77_UL, &F77_N, alpha, AP, X,  
+                     &F77_incX, beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      ALPHA[0]= *alp;
+      ALPHA[1]= -alp[1];
+      BETA[0]= *bet;
+      BETA[1]= -bet[1];
+
+      if (N > 0)
+      {
+         n = N << 1;
+         x = malloc(n*sizeof(float));
+ 
+         tx = x;
+         if( incX > 0 ) {
+           i = incX << 1;
+           tincx = 2;
+           st= x+n;
+         } else {
+           i = incX *(-2);
+           tincx = -2;
+           st = x-2;
+           x +=(n-2);
+         }
+
+         do
+         {
+           *x = *xx;
+           x[1] = -xx[1];
+           x += tincx ;
+           xx += i;
+         }
+         while (x != st);
+         x=tx;
+
+
+         #ifdef F77_INT
+            F77_incX = 1;
+         #else
+            incx = 1;
+         #endif
+ 
+         if(incY > 0)
+           tincY = incY;
+         else
+           tincY = -incY;
+         y++;
+
+         i = tincY << 1;
+         n = i * N ;
+         st = y + n;
+         do {
+            *y = -(*y);
+            y += i;
+         } while(y != st);
+         y -= n;
+      }  else
+         x = (float *) X;
+
+
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chpmv","Illegal Uplo setting, %d\n", Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+
+      F77_chpmv(F77_UL, &F77_N, ALPHA, 
+                     AP, x, &F77_incX, BETA, Y, &F77_incY);
+   }
+   else 
+   {
+      cblas_xerbla(1, "cblas_chpmv","Illegal Order setting, %d\n", order);
+      return;
+   }
+   if ( order == CblasRowMajor ) 
+   {
+      if(X!=x)
+         free(x);
+      if (N > 0)
+      {
+         do
+         {
+            *y = -(*y);
+            y += i;
+         }
+         while (y != st);
+     }
+  }
+
+   return;
+}

dlib/external/cblas/cblas_chpr.c

+/*
+ * cblas_chpr.c
+ * The program is a C interface to chpr.
+ * 
+ * Keita Teranishi  3/23/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_chpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                const int N, const float alpha, const void *X,
+                const int incX, void *A)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_incX incx
+#endif
+   int n, i, tincx, incx=incX;
+   float *x=(float *)X, *xx=(float *)X, *tx, *st;
+
+ 
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chpr","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+
+      F77_chpr(F77_UL, &F77_N, &alpha, X, &F77_incX, A);
+
+   }  else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chpr","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      if (N > 0)
+      {
+         n = N << 1;
+         x = malloc(n*sizeof(float));
+         tx = x;
+         if( incX > 0 ) {
+            i = incX << 1;
+            tincx = 2;
+            st= x+n;
+         } else { 
+            i = incX *(-2);
+            tincx = -2;
+            st = x-2; 
+            x +=(n-2); 
+         }
+         do
+         {
+            *x = *xx;
+            x[1] = -xx[1];
+            x += tincx ;
+            xx += i;
+         }
+         while (x != st);
+         x=tx;
+         #ifdef F77_INT
+            F77_incX = 1;
+         #else
+            incx = 1;
+         #endif
+      }
+      else x = (float *) X;
+
+      F77_chpr(F77_UL, &F77_N, &alpha, x, &F77_incX, A);
+
+   } else 
+   {
+      cblas_xerbla(1, "cblas_chpr","Illegal Order setting, %d\n", order);
+      return;
+   }
+   if(X!=x)
+     free(x);
+   return;
+}

dlib/external/cblas/cblas_chpr2.c

+/*
+ * cblas_chpr2.c
+ * The program is a C interface to chpr2.
+ * 
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_chpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                      const int N,const void *alpha, const void *X, 
+                      const int incX,const void *Y, const int incY, void *Ap)
+
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N,  F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_incX incx
+   #define F77_incY incy
+#endif
+   int n, i, j, tincx, tincy, incx=incX, incy=incY;
+   float *x=(float *)X, *xx=(float *)X, *y=(float *)Y,
+         *yy=(float *)Y, *tx, *ty, *stx, *sty;
+
+ 
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chpr2","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+
+      F77_chpr2(F77_UL, &F77_N, alpha, X, &F77_incX, Y, &F77_incY, Ap);
+
+   }  else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_chpr2","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      if (N > 0)
+      {
+         n = N << 1;
+         x = malloc(n*sizeof(float));
+         y = malloc(n*sizeof(float));
+         tx = x;
+         ty = y;
+         if( incX > 0 ) {
+            i = incX << 1 ;
+            tincx = 2;
+            stx= x+n;
+         } else {
+            i = incX *(-2);
+            tincx = -2;
+            stx = x-2;
+            x +=(n-2);
+         }
+ 
+         if( incY > 0 ) {
+            j = incY << 1;
+            tincy = 2;
+            sty= y+n;
+         } else {
+            j = incY *(-2);
+            tincy = -2;
+            sty = y-2;
+            y +=(n-2);
+         }
+ 
+         do
+         {
+            *x = *xx;
+            x[1] = -xx[1];
+            x += tincx ;
+            xx += i;
+         }
+         while (x != stx);
+         do
+         {
+            *y = *yy;
+            y[1] = -yy[1];
+            y += tincy ;
+            yy += j;
+         }
+         while (y != sty);
+ 
+         x=tx;
+         y=ty;
+ 
+         #ifdef F77_INT
+            F77_incX = 1;
+            F77_incY = 1;
+         #else
+            incx = 1;
+            incy = 1;
+         #endif
+
+      }  else 
+      {
+         x = (float *) X;
+         y = (void  *) Y;
+      }
+      F77_chpr2(F77_UL, &F77_N, alpha, y, &F77_incY, x, &F77_incX, Ap);
+   } else 
+   {
+      cblas_xerbla(1, "cblas_chpr2","Illegal Order setting, %d\n", order);
+      return;
+   }
+   if(X!=x)
+      free(x);
+   if(Y!=y)
+      free(y);
+   return;
+}

dlib/external/cblas/cblas_cscal.c

+/*
+ * cblas_cscal.c
+ *
+ * The program is a C interface to cscal.f.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cscal( const int N, const void *alpha, void *X, 
+                       const int incX)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   F77_cscal( &F77_N, alpha, X, &F77_incX);
+}

dlib/external/cblas/cblas_csscal.c

+/*
+ * cblas_csscal.c
+ *
+ * The program is a C interface to csscal.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_csscal( const int N, const float alpha, void *X,
+                       const int incX)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   F77_csscal( &F77_N, &alpha, X, &F77_incX);
+}

dlib/external/cblas/cblas_cswap.c

+/*
+ * cblas_cswap.c
+ *
+ * The program is a C interface to cswap.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_cswap( const int N, void *X, const int incX, void *Y,
+                       const int incY)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_cswap( &F77_N, X, &F77_incX, Y, &F77_incY);
+}

dlib/external/cblas/cblas_csymm.c

+/*
+ *
+ * cblas_csymm.c
+ * This program is a C interface to csymm.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_csymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,
+                 const enum CBLAS_UPLO Uplo, const int M, const int N,
+                 const void *alpha, const void  *A, const int lda,
+                 const void  *B, const int ldb, const void *beta,
+                 void  *C, const int ldc)
+{
+   char SD, UL;   
+#ifdef F77_CHAR
+   F77_CHAR F77_SD, F77_UL;
+#else
+   #define F77_SD &SD  
+   #define F77_UL &UL  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_ldb=ldb;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_ldb ldb
+   #define F77_ldc ldc
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+      if( Side == CblasRight) SD='R';
+      else if ( Side == CblasLeft ) SD='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_csymm", "Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(3, "cblas_csymm", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_SD = C2F_CHAR(&SD);
+      #endif
+
+      F77_csymm(F77_SD, F77_UL, &F77_M, &F77_N, alpha, A, &F77_lda,
+                      B, &F77_ldb, beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      if( Side == CblasRight) SD='L';
+      else if ( Side == CblasLeft ) SD='R';
+      else 
+      {
+         cblas_xerbla(2, "cblas_csymm", "Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(3, "cblas_csymm", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_SD = C2F_CHAR(&SD);
+      #endif
+
+      F77_csymm(F77_SD, F77_UL, &F77_N, &F77_M, alpha, A, &F77_lda,
+                     B, &F77_ldb, beta, C, &F77_ldc);
+   } 
+   else cblas_xerbla(1, "cblas_csymm", "Illegal Order setting, %d\n", Order);
+   return;
+} 

dlib/external/cblas/cblas_csyr2k.c

+/*
+ *
+ * cblas_csyr2k.c
+ * This program is a C interface to csyr2k.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_csyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
+                  const enum CBLAS_TRANSPOSE Trans, const int N, const int K,
+                  const void *alpha, const void  *A, const int lda,
+                  const void  *B, const int ldb, const void *beta,
+                  void  *C, const int ldc)
+{
+   char UL, TR;   
+#ifdef F77_CHAR
+   F77_CHAR F77_TR, F77_UL;
+#else
+   #define F77_TR &TR  
+   #define F77_UL &UL  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_K=K, F77_lda=lda, F77_ldb=ldb;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_ldb ldb
+   #define F77_ldc ldc
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+
+      if( Uplo == CblasUpper) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_csyr2k", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if( Trans == CblasTrans) TR ='T';
+      else if ( Trans == CblasConjTrans ) TR='C';
+      else if ( Trans == CblasNoTrans )   TR='N';
+      else 
+      {
+         cblas_xerbla(3, "cblas_csyr2k", "Illegal Trans setting, %d\n", Trans);
+         return;
+      }
+
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TR = C2F_CHAR(&TR);
+      #endif
+
+      F77_csyr2k(F77_UL, F77_TR, &F77_N, &F77_K, alpha, A, &F77_lda,
+                      B, &F77_ldb, beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      if( Uplo == CblasUpper) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(3, "cblas_csyr2k", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if( Trans == CblasTrans) TR ='N';
+      else if ( Trans == CblasConjTrans ) TR='N';
+      else if ( Trans == CblasNoTrans )   TR='T';
+      else 
+      {
+         cblas_xerbla(3, "cblas_csyr2k", "Illegal Trans setting, %d\n", Trans);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TR = C2F_CHAR(&TR);
+      #endif
+
+      F77_csyr2k(F77_UL, F77_TR, &F77_N, &F77_K, alpha, A, &F77_lda, B, &F77_ldb, beta, C, &F77_ldc);
+   } 
+   else  cblas_xerbla(1, "cblas_csyr2k", "Illegal Order setting, %d\n", Order);
+   return;
+}

dlib/external/cblas/cblas_csyrk.c

+/*
+ *
+ * cblas_csyrk.c
+ * This program is a C interface to csyrk.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_csyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
+                 const enum CBLAS_TRANSPOSE Trans, const int N, const int K,
+                 const void *alpha, const void  *A, const int lda,
+                 const void *beta, void  *C, const int ldc)
+{
+   char UL, TR;   
+#ifdef F77_CHAR
+   F77_CHAR F77_TR, F77_UL;
+#else
+   #define F77_TR &TR  
+   #define F77_UL &UL  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_K=K, F77_lda=lda;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_ldc ldc
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+
+      if( Uplo == CblasUpper) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_csyrk", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if( Trans == CblasTrans) TR ='T';
+      else if ( Trans == CblasConjTrans ) TR='C';
+      else if ( Trans == CblasNoTrans )   TR='N';
+      else 
+      {
+         cblas_xerbla(3, "cblas_csyrk", "Illegal Trans setting, %d\n", Trans);
+         return;
+      }
+
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TR = C2F_CHAR(&TR);
+      #endif
+
+      F77_csyrk(F77_UL, F77_TR, &F77_N, &F77_K, alpha, A, &F77_lda,
+                beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      if( Uplo == CblasUpper) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(3, "cblas_csyrk", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if( Trans == CblasTrans) TR ='N';
+      else if ( Trans == CblasConjTrans ) TR='N';
+      else if ( Trans == CblasNoTrans )   TR='T';
+      else 
+      {
+         cblas_xerbla(3, "cblas_csyrk", "Illegal Trans setting, %d\n", Trans);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TR = C2F_CHAR(&TR);
+      #endif
+
+      F77_csyrk(F77_UL, F77_TR, &F77_N, &F77_K, alpha, A, &F77_lda,
+                     beta, C, &F77_ldc);
+   } 
+   else cblas_xerbla(1, "cblas_csyrk", "Illegal Order setting, %d\n", Order);
+   return;
+}
+

dlib/external/cblas/cblas_ctbmv.c

+/*
+ * cblas_ctbmv.c
+ * The program is a C interface to ctbmv.
+ * 
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ctbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                 const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
+                 const int N, const int K, const void  *A, const int lda,
+                 void  *X, const int incX)
+{
+   char TA;
+   char UL;
+   char DI;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_UL, F77_DI;
+#else
+   #define F77_TA &TA
+   #define F77_UL &UL
+   #define F77_DI &DI   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_lda=lda, F77_K=K, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_incX incX
+#endif
+   int n, i=0, tincX; 
+   float *st=0, *x=(float *)X;
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctbmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctbmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctbmv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+      F77_ctbmv( F77_UL, F77_TA, F77_DI, &F77_N, &F77_K, A, &F77_lda, X,
+                      &F77_incX);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctbmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans)
+      {
+         TA = 'N';
+         if ( N > 0)
+         {
+            if(incX > 0)
+               tincX = incX;
+            else
+               tincX = -incX;
+            i = tincX << 1;
+            n = i * N;
+            x++;
+            st = x + n;
+            do
+            {
+               *x = -(*x);
+               x+= i;
+            }
+            while (x != st);
+            x -= n;
+         }
+      }
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctbmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctbmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+
+      F77_ctbmv( F77_UL, F77_TA, F77_DI, &F77_N, &F77_K, A, &F77_lda, X,
+                      &F77_incX);
+
+      if (TransA == CblasConjTrans)
+      {
+         if (N > 0)
+         {
+            do
+            {
+               *x = -(*x);
+               x += i;
+            }
+            while (x != st);
+         }
+      }
+   }
+   else cblas_xerbla(1, "cblas_ctbmv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_ctbsv.c

+/*
+ * cblas_ctbsv.c
+ * The program is a C interface to ctbsv.
+ * 
+ * Keita Teranishi  3/23/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ctbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                 const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
+                 const int N, const int K, const void  *A, const int lda,
+                 void  *X, const int incX)
+{
+   char TA;
+   char UL;
+   char DI;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_UL, F77_DI;
+#else
+   #define F77_TA &TA
+   #define F77_UL &UL
+   #define F77_DI &DI   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_lda=lda, F77_K=K, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_incX incX
+#endif
+   int n, i=0, tincX; 
+   float *st=0,*x=(float *)X;
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctbsv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctbsv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctbsv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+      F77_ctbsv( F77_UL, F77_TA, F77_DI, &F77_N, &F77_K, A, &F77_lda, X,
+                      &F77_incX);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctbsv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans)
+      {
+         TA = 'N';
+         if ( N > 0)
+         {
+            if ( incX > 0 )
+               tincX = incX;
+            else
+               tincX = -incX;
+ 
+            n = N*2*(tincX);
+  
+            x++;
+
+            st=x+n;
+
+            i = tincX << 1;
+            do
+            {
+               *x = -(*x);
+               x+=i;
+            }
+            while (x != st);
+            x -= n;
+         }
+      }
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctbsv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctbsv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+
+      F77_ctbsv( F77_UL, F77_TA, F77_DI, &F77_N, &F77_K, A, &F77_lda, X,
+                      &F77_incX);
+
+      if (TransA == CblasConjTrans)
+      {
+         if (N > 0)
+         {
+            do
+            {
+               *x = -(*x);
+               x+= i;
+            }
+            while (x != st);
+         }
+      }
+   }
+   else cblas_xerbla(1, "cblas_ctbsv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_ctpmv.c

+/*
+ * cblas_ctpmv.c
+ * The program is a C interface to ctpmv.
+ * 
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ctpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                 const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
+                 const int N, const void  *Ap, void  *X, const int incX)
+{
+   char TA;
+   char UL;
+   char DI;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_UL, F77_DI;
+#else
+   #define F77_TA &TA
+   #define F77_UL &UL
+   #define F77_DI &DI   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   int n, i=0, tincX; 
+   float *st=0,*x=(float *)X;
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctpmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctpmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctpmv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+      F77_ctpmv( F77_UL, F77_TA, F77_DI, &F77_N, Ap, X, &F77_incX);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctpmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans)
+      {
+         TA = 'N';
+         if ( N > 0)
+         {
+            if(incX > 0)
+               tincX = incX;
+            else
+               tincX = -incX;
+            i = tincX << 1;
+            n = i * N;
+            x++;
+            st = x + n;
+            do
+            {
+               *x = -(*x);
+               x += i;
+            }
+            while (x != st);
+            x -= n;
+         }
+      }
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctpmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctpmv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+
+      F77_ctpmv( F77_UL, F77_TA, F77_DI, &F77_N, Ap, X,&F77_incX);
+      if (TransA == CblasConjTrans)
+      {
+         if (N > 0)
+         {
+            do
+            {
+               *x = -(*x);
+               x += i;
+            }
+            while (x != st);
+         }
+      }
+   }
+   else cblas_xerbla(1, "cblas_ctpmv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_ctpsv.c

+/*
+ * cblas_ctpsv.c
+ * The program is a C interface to ctpsv.
+ * 
+ * Keita Teranishi  3/23/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ctpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                 const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
+                 const int N, const void  *Ap, void  *X, const int incX)
+{
+   char TA;
+   char UL;
+   char DI;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_UL, F77_DI;
+#else
+   #define F77_TA &TA
+   #define F77_UL &UL
+   #define F77_DI &DI   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   int n, i=0, tincX; 
+   float *st=0, *x=(float*)X;
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctpsv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctpsv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctpsv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+      F77_ctpsv( F77_UL, F77_TA, F77_DI, &F77_N, Ap, X, &F77_incX);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctpsv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans)
+      {
+         TA = 'N';
+         if ( N > 0)
+         {
+            if ( incX > 0 )
+               tincX = incX;
+            else
+               tincX = -incX;
+ 
+            n = N*2*(tincX);
+ 
+            x++;
+
+            st=x+n;
+
+            i = tincX << 1;
+            do
+            {
+               *x = -(*x);
+               x+=i;
+            }
+            while (x != st);
+            x -= n;
+         }
+      }
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctpsv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctpsv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+
+      F77_ctpsv( F77_UL, F77_TA, F77_DI, &F77_N, Ap, X,&F77_incX);
+
+      if (TransA == CblasConjTrans)
+      {
+         if (N > 0)
+         {
+            do
+            {
+               *x = -(*x);
+               x += i;
+            }
+            while (x != st);
+         }
+      }
+   }
+   else cblas_xerbla(1, "cblas_ctpsv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_ctrmm.c

+/*
+ *
+ * cblas_ctrmm.c
+ * This program is a C interface to ctrmm.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ctrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,
+                 const enum CBLAS_UPLO Uplo, const  enum CBLAS_TRANSPOSE TransA,
+                 const enum CBLAS_DIAG Diag, const int M, const int N,
+                 const void *alpha, const void  *A, const int lda,
+                 void  *B, const int ldb)
+{
+   char UL, TA, SD, DI;   
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_UL, F77_SD, F77_DI;
+#else
+   #define F77_TA &TA  
+   #define F77_UL &UL  
+   #define F77_SD &SD
+   #define F77_DI &DI
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_ldb=ldb;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_ldb ldb
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+      if( Side == CblasRight ) SD='R';
+      else if ( Side == CblasLeft ) SD='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctrmm", "Illegal Side setting, %d\n", Side);
+         return;
+      }
+      if( Uplo == CblasUpper ) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctrmm", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if( TransA == CblasTrans ) TA ='T';
+      else if ( TransA == CblasConjTrans ) TA='C';
+      else if ( TransA == CblasNoTrans )   TA='N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctrmm", "Illegal Trans setting, %d\n", TransA);
+         return;
+      }
+
+      if( Diag == CblasUnit ) DI='U';
+      else if ( Diag == CblasNonUnit ) DI='N';
+      else cblas_xerbla(5, "cblas_ctrmm", 
+                       "Illegal Diag setting, %d\n", Diag);
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_SD = C2F_CHAR(&SD);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+
+      F77_ctrmm(F77_SD, F77_UL, F77_TA, F77_DI, &F77_M, &F77_N, alpha, A, &F77_lda, B, &F77_ldb);
+   } else if (Order == CblasRowMajor)
+   {
+      if( Side == CblasRight ) SD='L';
+      else if ( Side == CblasLeft ) SD='R';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctrmm", "Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper ) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctrmm", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if( TransA == CblasTrans ) TA ='T';
+      else if ( TransA == CblasConjTrans ) TA='C';
+      else if ( TransA == CblasNoTrans )   TA='N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctrmm", "Illegal Trans setting, %d\n", TransA);
+         return;
+      }
+
+      if( Diag == CblasUnit ) DI='U';
+      else if ( Diag == CblasNonUnit ) DI='N';
+      else 
+      {
+         cblas_xerbla(5, "cblas_ctrmm", "Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_SD = C2F_CHAR(&SD);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+
+      F77_ctrmm(F77_SD, F77_UL, F77_TA, F77_DI, &F77_N, &F77_M, alpha, A, &F77_lda, B, &F77_ldb);
+   } 
+   else  cblas_xerbla(1, "cblas_ctrmm", "Illegal Order setting, %d\n", Order);
+   return;
+}

dlib/external/cblas/cblas_ctrmv.c

+/*
+ * cblas_ctrmv.c
+ * The program is a C interface to ctrmv.
+ * 
+ * Keita Teranishi  3/23/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ctrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                 const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
+                 const int N, const void  *A, const int lda,
+                 void  *X, const int incX)
+
+{
+   char TA;
+   char UL;
+   char DI;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_UL, F77_DI;
+#else
+   #define F77_TA &TA
+   #define F77_UL &UL
+   #define F77_DI &DI   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_lda=lda, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_incX incX
+#endif
+   int n, i=0, tincX; 
+   float *st=0,*x=(float *)X;
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctrmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctrmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctrmv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+      F77_ctrmv( F77_UL, F77_TA, F77_DI, &F77_N, A, &F77_lda, X,
+                      &F77_incX);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctrmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans)
+      {
+         TA = 'N';
+         if ( N > 0)
+         {
+            if(incX > 0)
+               tincX = incX;
+            else
+               tincX = -incX;
+            i = tincX << 1;
+            n = i * N;
+            st = x + n;
+            do
+            {
+               x[1] = -x[1];
+               x+= i;
+            }
+            while (x != st);
+            x -= n;
+         }
+      }
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctrmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctrmv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+         F77_ctrmv( F77_UL, F77_TA, F77_DI, &F77_N, A, &F77_lda, X,
+                      &F77_incX);
+      if (TransA == CblasConjTrans)
+      {
+         if (N > 0)
+         {
+            do
+            {
+               x[1] = -x[1];
+               x += i;
+            }
+            while (x != st);
+         }
+      }
+   }
+   else cblas_xerbla(1, "cblas_ctrmv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_ctrsm.c

+/*
+ *
+ * cblas_ctrsm.c
+ * This program is a C interface to ctrsm.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ctrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,
+                 const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA,
+                 const enum CBLAS_DIAG Diag, const int M, const int N,
+                 const void *alpha, const void  *A, const int lda,
+                 void  *B, const int ldb)
+{
+   char UL, TA, SD, DI;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_UL, F77_SD, F77_DI;
+#else
+   #define F77_TA &TA
+   #define F77_UL &UL
+   #define F77_SD &SD
+   #define F77_DI &DI
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_ldb=ldb;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_ldb ldb
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+
+      if( Side == CblasRight) SD='R';
+      else if ( Side == CblasLeft ) SD='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctrsm", "Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctrsm", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if( TransA == CblasTrans) TA ='T';
+      else if ( TransA == CblasConjTrans ) TA='C';
+      else if ( TransA == CblasNoTrans )   TA='N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctrsm", "Illegal Trans setting, %d\n", TransA);
+         return;
+      }
+
+      if( Diag == CblasUnit ) DI='U';
+      else if ( Diag == CblasNonUnit ) DI='N';
+      else 
+      {
+         cblas_xerbla(5, "cblas_ctrsm", "Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_SD = C2F_CHAR(&SD);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+
+      F77_ctrsm(F77_SD, F77_UL, F77_TA, F77_DI, &F77_M, &F77_N, alpha, A,
+                &F77_lda, B, &F77_ldb);
+   } else if (Order == CblasRowMajor)
+   {
+
+      if( Side == CblasRight) SD='L';
+      else if ( Side == CblasLeft ) SD='R';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctrsm", "Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctrsm", "Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if( TransA == CblasTrans) TA ='T';
+      else if ( TransA == CblasConjTrans ) TA='C';
+      else if ( TransA == CblasNoTrans )   TA='N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctrsm", "Illegal Trans setting, %d\n", TransA);
+         return;
+      }
+
+      if( Diag == CblasUnit ) DI='U';
+      else if ( Diag == CblasNonUnit ) DI='N';
+      else 
+      {
+         cblas_xerbla(5, "cblas_ctrsm", "Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_SD = C2F_CHAR(&SD);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+
+
+      F77_ctrsm(F77_SD, F77_UL, F77_TA, F77_DI, &F77_N, &F77_M, alpha, A,
+                &F77_lda, B, &F77_ldb);
+   } 
+   else cblas_xerbla(1, "cblas_ctrsm", "Illegal Order setting, %d\n", Order);
+   return;
+}

dlib/external/cblas/cblas_ctrsv.c

+/*
+ * cblas_ctrsv.c
+ * The program is a C interface to ctrsv.
+ * 
+ * Keita Teranishi  3/23/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_ctrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                 const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
+                 const int N, const void  *A, const int lda, void  *X,
+                 const int incX)
+{
+   char TA;
+   char UL;
+   char DI;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_UL, F77_DI;
+#else
+   #define F77_TA &TA
+   #define F77_UL &UL
+   #define F77_DI &DI   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_lda=lda, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_incX incX
+#endif
+   int n, i=0, tincX; 
+   float *st=0,*x=(float *)X;
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctrsv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctrsv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctrsv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+      F77_ctrsv( F77_UL, F77_TA, F77_DI, &F77_N, A, &F77_lda, X,
+                      &F77_incX);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_ctrsv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans)
+      {
+         TA = 'N';
+         if ( N > 0)
+         {
+            if ( incX > 0 )
+               tincX = incX;
+            else
+               tincX = -incX;
+ 
+            n = N*2*(tincX);
+            x++;
+            st=x+n; 
+            i = tincX << 1;
+            do
+            {
+               *x = -(*x);
+               x+=i;
+            }
+            while (x != st);
+            x -= n;
+         }
+      }
+      else 
+      {
+         cblas_xerbla(3, "cblas_ctrsv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+
+      if (Diag == CblasUnit) DI = 'U';
+      else if (Diag == CblasNonUnit) DI = 'N';
+      else 
+      {
+         cblas_xerbla(4, "cblas_ctrsv","Illegal Diag setting, %d\n", Diag);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_TA = C2F_CHAR(&TA);
+         F77_DI = C2F_CHAR(&DI);
+      #endif
+      F77_ctrsv( F77_UL, F77_TA, F77_DI, &F77_N, A, &F77_lda, X,
+                      &F77_incX);
+      if (TransA == CblasConjTrans)
+      {
+         if (N > 0)
+         {
+            do
+            {
+               *x = -(*x);
+               x += i;
+            }
+            while (x != st);
+         }
+      }
+   }
+   else cblas_xerbla(1, "cblas_ctrsv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_dasum.c

+/*
+ * cblas_dasum.c
+ *
+ * The program is a C interface to dasum.
+ * It calls the fortran wrapper before calling dasum.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+double cblas_dasum( const int N, const double *X, const int incX) 
+{
+   double asum;
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   F77_dasum_sub( &F77_N, X, &F77_incX, &asum);
+   return asum;
+}

dlib/external/cblas/cblas_daxpy.c

+/*
+ * cblas_daxpy.c
+ *
+ * The program is a C interface to daxpy.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_daxpy( const int N, const double alpha, const double *X,
+                       const int incX, double *Y, const int incY)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_daxpy( &F77_N, &alpha, X, &F77_incX, Y, &F77_incY);
+} 

dlib/external/cblas/cblas_dcopy.c

+/*
+ * cblas_dcopy.c
+ *
+ * The program is a C interface to dcopy.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dcopy( const int N, const double *X,
+                      const int incX, double *Y, const int incY)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_dcopy( &F77_N, X, &F77_incX, Y, &F77_incY);
+}

dlib/external/cblas/cblas_ddot.c

+/*
+ * cblas_ddot.c
+ *
+ * The program is a C interface to ddot.
+ * It calls the fortran wrapper before calling ddot.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+double cblas_ddot( const int N, const double *X,
+                      const int incX, const double *Y, const int incY)
+{
+   double dot;
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_ddot_sub( &F77_N, X, &F77_incX, Y, &F77_incY, &dot);
+   return dot;
+}   

dlib/external/cblas/cblas_dgbmv.c

+/*
+ *
+ * cblas_dgbmv.c
+ * This program is a C interface to dgbmv.
+ * Written by Keita Teranishi
+ * 4/6/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dgbmv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
+                 const int KL, const int KU,
+                 const double alpha, const double  *A, const int lda,
+                 const double  *X, const int incX, const double beta,
+                 double  *Y, const int incY)
+{
+   char TA;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA;
+#else
+   #define F77_TA &TA   
+#endif
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+   F77_INT F77_KL=KL,F77_KU=KU;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_KL KL
+   #define F77_KU KU
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+
+   if (order == CblasColMajor)
+   {
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dgbmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+      #endif
+      F77_dgbmv(F77_TA, &F77_M, &F77_N, &F77_KL, &F77_KU, &alpha,  
+                     A, &F77_lda, X, &F77_incX, &beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans) TA = 'N';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dgbmv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+      #endif
+      F77_dgbmv(F77_TA, &F77_N, &F77_M, &F77_KU, &F77_KL, &alpha, 
+                     A ,&F77_lda, X,&F77_incX, &beta, Y, &F77_incY);
+   }
+   else cblas_xerbla(1, "cblas_dgbmv", "Illegal Order setting, %d\n", order);
+}

dlib/external/cblas/cblas_dgemm.c

+/*
+ *
+ * cblas_dgemm.c
+ * This program is a C interface to dgemm.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,
+                 const enum CBLAS_TRANSPOSE TransB, const int M, const int N,
+                 const int K, const double alpha, const double  *A,
+                 const int lda, const double  *B, const int ldb,
+                 const double beta, double  *C, const int ldc)
+{
+   char TA, TB;   
+#ifdef F77_CHAR
+   F77_CHAR F77_TA, F77_TB;
+#else
+   #define F77_TA &TA  
+   #define F77_TB &TB  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_K=K, F77_lda=lda, F77_ldb=ldb;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_ldb ldb
+   #define F77_ldc ldc
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+      if(TransA == CblasTrans) TA='T';
+      else if ( TransA == CblasConjTrans ) TA='C';
+      else if ( TransA == CblasNoTrans )   TA='N';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dgemm","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+
+      if(TransB == CblasTrans) TB='T';
+      else if ( TransB == CblasConjTrans ) TB='C';
+      else if ( TransB == CblasNoTrans )   TB='N';
+      else 
+      {
+         cblas_xerbla(3, "cblas_dgemm","Illegal TransB setting, %d\n", TransB);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+         F77_TB = C2F_CHAR(&TB);
+      #endif
+
+      F77_dgemm(F77_TA, F77_TB, &F77_M, &F77_N, &F77_K, &alpha, A,
+       &F77_lda, B, &F77_ldb, &beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      if(TransA == CblasTrans) TB='T';
+      else if ( TransA == CblasConjTrans ) TB='C';
+      else if ( TransA == CblasNoTrans )   TB='N';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dgemm","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      if(TransB == CblasTrans) TA='T';
+      else if ( TransB == CblasConjTrans ) TA='C';
+      else if ( TransB == CblasNoTrans )   TA='N';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dgemm","Illegal TransB setting, %d\n", TransB);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+         F77_TB = C2F_CHAR(&TB);
+      #endif
+
+      F77_dgemm(F77_TA, F77_TB, &F77_N, &F77_M, &F77_K, &alpha, B,
+                  &F77_ldb, A, &F77_lda, &beta, C, &F77_ldc);
+   } 
+   else  cblas_xerbla(1, "cblas_dgemm", "Illegal Order setting, %d\n", Order);
+   return;
+}

dlib/external/cblas/cblas_dgemv.c

+/*
+ *
+ * cblas_dgemv.c
+ * This program is a C interface to dgemv.
+ * Written by Keita Teranishi
+ * 4/6/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dgemv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
+                 const double alpha, const double  *A, const int lda,
+                 const double  *X, const int incX, const double beta,
+                 double  *Y, const int incY)
+{
+   char TA;
+#ifdef F77_CHAR
+   F77_CHAR F77_TA;
+#else
+   #define F77_TA &TA   
+#endif
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+
+   if (order == CblasColMajor)
+   {
+      if (TransA == CblasNoTrans) TA = 'N';
+      else if (TransA == CblasTrans) TA = 'T';
+      else if (TransA == CblasConjTrans) TA = 'C';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dgemv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+      #endif
+      F77_dgemv(F77_TA, &F77_M, &F77_N, &alpha, A, &F77_lda, X, &F77_incX, 
+                &beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (TransA == CblasNoTrans) TA = 'T';
+      else if (TransA == CblasTrans) TA = 'N';
+      else if (TransA == CblasConjTrans) TA = 'N';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dgemv","Illegal TransA setting, %d\n", TransA);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_TA = C2F_CHAR(&TA);
+      #endif
+      F77_dgemv(F77_TA, &F77_N, &F77_M, &alpha, A, &F77_lda, X,
+                &F77_incX, &beta, Y, &F77_incY);
+   }
+   else cblas_xerbla(1, "cblas_dgemv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_dger.c

+/*
+ *
+ * cblas_dger.c
+ * This program is a C interface to dger.
+ * Written by Keita Teranishi
+ * 4/6/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dger(const enum CBLAS_ORDER order, const int M, const int N,
+                const double alpha, const double  *X, const int incX,
+                const double  *Y, const int incY, double  *A, const int lda)
+{
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+   #define F77_lda lda
+#endif
+
+
+   if (order == CblasColMajor)
+   {
+      F77_dger( &F77_M, &F77_N, &alpha, X, &F77_incX, Y, &F77_incY, A, 
+                      &F77_lda);
+   }
+   else if (order == CblasRowMajor)
+   {
+      F77_dger( &F77_N, &F77_M ,&alpha, Y, &F77_incY, X, &F77_incX, A, 
+                      &F77_lda);
+
+   }
+   else cblas_xerbla(1, "cblas_dger", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_dnrm2.c

+/*
+ * cblas_dnrm2.c
+ *
+ * The program is a C interface to dnrm2.
+ * It calls the fortranwrapper before calling dnrm2.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+double cblas_dnrm2( const int N, const double *X, const int incX) 
+{
+   double nrm2;
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   F77_dnrm2_sub( &F77_N, X, &F77_incX, &nrm2);
+   return nrm2;
+}

dlib/external/cblas/cblas_drot.c

+/*
+ * cblas_drot.c
+ *
+ * The program is a C interface to drot.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_drot(const int N, double *X, const int incX,
+   double *Y, const int incY, const double c, const double s)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N 
+   #define F77_incX incX 
+   #define F77_incY incY 
+#endif
+   F77_drot(&F77_N, X, &F77_incX, Y, &F77_incY, &c, &s);
+   return;
+}

dlib/external/cblas/cblas_drotg.c

+/*
+ * cblas_drotg.c
+ *
+ * The program is a C interface to drotg.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_drotg(  double *a, double *b, double *c, double *s)
+{
+   F77_drotg(a,b,c,s);    
+}

dlib/external/cblas/cblas_drotm.c

+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_drotm( const int N, double *X, const int incX, double *Y, 
+                       const int incY, const double *P)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_drotm( &F77_N, X, &F77_incX, Y, &F77_incY, P);
+}   

dlib/external/cblas/cblas_drotmg.c

+/*
+ * cblas_drotmg.c
+ *
+ * The program is a C interface to drotmg.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_drotmg( double *d1, double *d2, double *b1, 
+                        const double b2, double *p)
+{
+   F77_drotmg(d1,d2,b1,&b2,p);
+}

dlib/external/cblas/cblas_dsbmv.c

+/*
+ *
+ * cblas_dsbmv.c
+ * This program is a C interface to dsbmv.
+ * Written by Keita Teranishi
+ * 4/6/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dsbmv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_UPLO Uplo, const int N, const int K,
+                 const double alpha, const double  *A, const int lda,
+                 const double  *X, const int incX, const double beta,
+                 double  *Y, const int incY)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_K=K, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_K K
+   #define F77_lda lda
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dsbmv","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_dsbmv(F77_UL, &F77_N, &F77_K, &alpha, A, &F77_lda, X,  
+                     &F77_incX, &beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dsbmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_dsbmv(F77_UL, &F77_N, &F77_K, &alpha, 
+                     A ,&F77_lda, X,&F77_incX, &beta, Y, &F77_incY);
+   }
+   else cblas_xerbla(1, "cblas_dsbmv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_dscal.c

+/*
+ * cblas_dscal.c
+ *
+ * The program is a C interface to dscal.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dscal( const int N, const double alpha, double *X, 
+                       const int incX)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   F77_dscal( &F77_N, &alpha, X, &F77_incX);
+}

dlib/external/cblas/cblas_dsdot.c

+/*
+ * cblas_dsdot.c
+ *
+ * The program is a C interface to dsdot.
+ * It calls fthe fortran wrapper before calling dsdot.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+double  cblas_dsdot( const int N, const float *X,
+                      const int incX, const float *Y, const int incY)
+{
+   double dot;
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_dsdot_sub( &F77_N, X, &F77_incX, Y, &F77_incY, &dot);
+   return dot;
+}   

dlib/external/cblas/cblas_dspmv.c

+/*
+ *
+ * cblas_dspmv.c
+ * This program is a C interface to dspmv.
+ * Written by Keita Teranishi
+ * 4/6/1998
+ *
+ */
+ 
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dspmv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_UPLO Uplo, const int N,
+                 const double alpha, const double  *AP,
+                 const double  *X, const int incX, const double beta,
+                 double  *Y, const int incY)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dspmv","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_dspmv(F77_UL, &F77_N, &alpha, AP, X,  
+                     &F77_incX, &beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dspmv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_dspmv(F77_UL, &F77_N, &alpha, 
+                     AP, X,&F77_incX, &beta, Y, &F77_incY);
+   }
+   else cblas_xerbla(1, "cblas_dspmv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_dspr.c

+/*
+ *
+ * cblas_dspr.c
+ * This program is a C interface to dspr.
+ * Written by Keita Teranishi
+ * 4/6/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                const int N, const double alpha, const double *X,
+                const int incX, double *Ap)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dspr","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+
+      F77_dspr(F77_UL, &F77_N, &alpha, X, &F77_incX, Ap);
+
+   }  else if (order == CblasRowMajor) 
+   {
+      if (Uplo == CblasLower) UL = 'U';
+      else if (Uplo == CblasUpper) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dspr","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif  
+      F77_dspr(F77_UL, &F77_N, &alpha, X, &F77_incX, Ap); 
+   } else cblas_xerbla(1, "cblas_dspr", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_dspr2.c

+/*
+ * cblas_dspr2.c
+ * The program is a C interface to dspr2.
+ *
+ * Keita Teranishi  5/20/98
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                const int N, const double  alpha, const double  *X,
+                const int incX, const double  *Y, const int incY, double  *A)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dspr2","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+
+      F77_dspr2(F77_UL, &F77_N, &alpha, X, &F77_incX, Y, &F77_incY, A);
+
+   }  else if (order == CblasRowMajor) 
+   {
+      if (Uplo == CblasLower) UL = 'U';
+      else if (Uplo == CblasUpper) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dspr2","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif  
+      F77_dspr2(F77_UL, &F77_N, &alpha, X, &F77_incX, Y, &F77_incY,  A); 
+   } else cblas_xerbla(1, "cblas_dspr2", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_dswap.c

+/*
+ * cblas_dswap.c
+ *
+ * The program is a C interface to dswap.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dswap( const int N, double *X, const int incX, double *Y,
+                       const int incY)
+{
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_incY=incY;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+   F77_dswap( &F77_N, X, &F77_incX, Y, &F77_incY);
+}

dlib/external/cblas/cblas_dsymm.c

+/*
+ *
+ * cblas_dsymm.c
+ * This program is a C interface to dsymm.
+ * Written by Keita Teranishi
+ * 4/8/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,
+                 const enum CBLAS_UPLO Uplo, const int M, const int N,
+                 const double alpha, const double  *A, const int lda,
+                 const double  *B, const int ldb, const double beta,
+                 double  *C, const int ldc)
+{
+   char SD, UL;   
+#ifdef F77_CHAR
+   F77_CHAR F77_SD, F77_UL;
+#else
+   #define F77_SD &SD  
+   #define F77_UL &UL  
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_M=M, F77_N=N, F77_lda=lda, F77_ldb=ldb;
+   F77_INT F77_ldc=ldc;
+#else
+   #define F77_M M
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_ldb ldb
+   #define F77_ldc ldc
+#endif
+
+
+   if( Order == CblasColMajor )
+   {
+      if( Side == CblasRight) SD='R';
+      else if ( Side == CblasLeft ) SD='L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dsymm","Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper) UL='U';
+      else if ( Uplo == CblasLower ) UL='L';
+      else 
+      {
+         cblas_xerbla(3, "cblas_dsymm","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_SD = C2F_CHAR(&SD);
+      #endif
+
+      F77_dsymm(F77_SD, F77_UL, &F77_M, &F77_N, &alpha, A, &F77_lda,
+                      B, &F77_ldb, &beta, C, &F77_ldc);
+   } else if (Order == CblasRowMajor)
+   {
+      if( Side == CblasRight) SD='L';
+      else if ( Side == CblasLeft ) SD='R';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dsymm","Illegal Side setting, %d\n", Side);
+         return;
+      }
+
+      if( Uplo == CblasUpper) UL='L';
+      else if ( Uplo == CblasLower ) UL='U';
+      else 
+      {
+         cblas_xerbla(3, "cblas_dsymm","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+         F77_SD = C2F_CHAR(&SD);
+      #endif
+
+      F77_dsymm(F77_SD, F77_UL, &F77_N, &F77_M, &alpha, A, &F77_lda, B,
+                 &F77_ldb, &beta, C, &F77_ldc);
+   } 
+   else cblas_xerbla(1, "cblas_dsymm","Illegal Order setting, %d\n", Order); 
+   return;
+} 

dlib/external/cblas/cblas_dsymv.c

+/*
+ *
+ * cblas_dsymv.c
+ * This program is a C interface to dsymv.
+ * Written by Keita Teranishi
+ * 4/6/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dsymv(const enum CBLAS_ORDER order,
+                 const enum CBLAS_UPLO Uplo, const int N,
+                 const double alpha, const double  *A, const int lda,
+                 const double  *X, const int incX, const double beta,
+                 double  *Y, const int incY)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL   
+#endif
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_lda=lda, F77_incX=incX, F77_incY=incY;
+#else
+   #define F77_N N
+   #define F77_lda lda
+   #define F77_incX incX
+   #define F77_incY incY
+#endif
+
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'U';
+      else if (Uplo == CblasLower) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dsymv","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_dsymv(F77_UL, &F77_N, &alpha, A, &F77_lda, X,  
+                     &F77_incX, &beta, Y, &F77_incY);
+   }
+   else if (order == CblasRowMajor)
+   {
+      if (Uplo == CblasUpper) UL = 'L';
+      else if (Uplo == CblasLower) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dsymv","Illegal Uplo setting, %d\n", Uplo);
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+      F77_dsymv(F77_UL, &F77_N, &alpha, 
+                     A ,&F77_lda, X,&F77_incX, &beta, Y, &F77_incY);
+   }
+   else cblas_xerbla(1, "cblas_dsymv", "Illegal Order setting, %d\n", order);
+   return;
+}

dlib/external/cblas/cblas_dsyr.c

+/*
+ *
+ * cblas_dsyr.c
+ * This program is a C interface to dsyr.
+ * Written by Keita Teranishi
+ * 4/6/1998
+ *
+ */
+
+#include "cblas.h"
+#include "cblas_f77.h"
+void cblas_dsyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
+                const int N, const double  alpha, const double  *X,
+                const int incX, double  *A, const int lda)
+{
+   char UL;
+#ifdef F77_CHAR
+   F77_CHAR F77_UL;
+#else
+   #define F77_UL &UL
+#endif
+
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX, F77_lda=lda;
+#else
+   #define F77_N N
+   #define F77_incX incX
+   #define F77_lda  lda
+#endif
+   if (order == CblasColMajor)
+   {
+      if (Uplo == CblasLower) UL = 'L';
+      else if (Uplo == CblasUpper) UL = 'U';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dsyr","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif
+
+      F77_dsyr(F77_UL, &F77_N, &alpha, X, &F77_incX, A, &F77_lda);
+
+   }  else if (order == CblasRowMajor) 
+   {
+      if (Uplo == CblasLower) UL = 'U';
+      else if (Uplo == CblasUpper) UL = 'L';
+      else 
+      {
+         cblas_xerbla(2, "cblas_dsyr","Illegal Uplo setting, %d\n",Uplo );
+         return;
+      }
+      #ifdef F77_CHAR
+         F77_UL = C2F_CHAR(&UL);
+      #endif  
+      F77_dsyr(F77_UL, &F77_N, &alpha, X, &F77_incX, A, &F77_lda); 
+   } else cblas_xerbla(1, "cblas_dsyr", "Illegal Order setting, %d\n", order);
+   return;
+} 

dlib/external/cblas/cblas_dzasum.c

+/*
+ * cblas_dzasum.c
+ *
+ * The program is a C interface to dzasum.
+ * It calls the fortran wrapper before calling dzasum.
+ *
+ * Written by Keita Teranishi.  2/11/1998
+ *
+ */
+#include "cblas.h"
+#include "cblas_f77.h"
+double cblas_dzasum( const int N, const void *X, const int incX) 
+{
+   double asum;
+#ifdef F77_INT
+   F77_INT F77_N=N, F77_incX=incX;
+#else 
+   #define F77_N N
+   #define F77_incX incX
+#endif
+   F77_dzasum_sub( &F77_N, X, &F77_incX, &asum);
+   return asum;
+}