dlib C++ Library - matrix_blas_bindings.h

// Copyright (C) 2008 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_MATRIx_BLAS_BINDINGS_
#define DLIB_MATRIx_BLAS_BINDINGS_
#ifndef DLIB_USE_BLAS
#error "DLIB_USE_BLAS should be defined if you want to use the BLAS bindings"
#endif
#include "matrix_assign.h"
#include "matrix_conj_trans.h"
#include "cblas_constants.h"
#include <stdint.h>
//#include <iostream>
//using namespace std;
namespace dlib
{
 namespace blas_bindings 
 {
#ifdef DLIB_TEST_BLAS_BINDINGS
 int& counter_gemm();
 int& counter_gemv();
 int& counter_ger();
 int& counter_dot();
 int& counter_axpy();
 int& counter_scal();
 #define DLIB_TEST_BLAS_BINDING_GEMM ++counter_gemm();
 #define DLIB_TEST_BLAS_BINDING_GEMV ++counter_gemv();
 #define DLIB_TEST_BLAS_BINDING_GER ++counter_ger();
 #define DLIB_TEST_BLAS_BINDING_DOT ++counter_dot();
 #define DLIB_TEST_BLAS_BINDING_AXPY ++counter_axpy();
 #define DLIB_TEST_BLAS_BINDING_SCAL ++counter_scal();
#else
 #define DLIB_TEST_BLAS_BINDING_GEMM 
 #define DLIB_TEST_BLAS_BINDING_GEMV 
 #define DLIB_TEST_BLAS_BINDING_GER 
 #define DLIB_TEST_BLAS_BINDING_DOT 
 #define DLIB_TEST_BLAS_BINDING_AXPY
 #define DLIB_TEST_BLAS_BINDING_SCAL
#endif
#ifdef DLIB_DEFINE_CBLAS_API
 extern "C"
 {
 // Here we declare the prototypes for the CBLAS calls used by the BLAS bindings below
 void cblas_saxpy(const CBLAS_INT_TYPE N, const float alpha, const float *X,
 const CBLAS_INT_TYPE incX, float *Y, const CBLAS_INT_TYPE incY);
 void cblas_daxpy(const CBLAS_INT_TYPE N, const double alpha, const double *X,
 const CBLAS_INT_TYPE incX, double *Y, const CBLAS_INT_TYPE incY);
 void cblas_caxpy(const CBLAS_INT_TYPE N, const void *alpha, const void *X,
 const CBLAS_INT_TYPE incX, void *Y, const CBLAS_INT_TYPE incY);
 void cblas_zaxpy(const CBLAS_INT_TYPE N, const void *alpha, const void *X,
 const CBLAS_INT_TYPE incX, void *Y, const CBLAS_INT_TYPE incY);
 void cblas_sscal(const CBLAS_INT_TYPE N, const float alpha, float *X, const CBLAS_INT_TYPE incX);
 void cblas_dscal(const CBLAS_INT_TYPE N, const double alpha, double *X, const CBLAS_INT_TYPE incX);
 void cblas_cscal(const CBLAS_INT_TYPE N, const void *alpha, void *X, const CBLAS_INT_TYPE incX);
 void cblas_zscal(const CBLAS_INT_TYPE N, const void *alpha, void *X, const CBLAS_INT_TYPE incX);
 void cblas_sgemm(const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA,
 const CBLAS_TRANSPOSE TransB, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const CBLAS_INT_TYPE K, const float alpha, const float *A,
 const CBLAS_INT_TYPE lda, const float *B, const CBLAS_INT_TYPE ldb,
 const float beta, float *C, const CBLAS_INT_TYPE ldc);
 void cblas_dgemm(const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA,
 const CBLAS_TRANSPOSE TransB, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const CBLAS_INT_TYPE K, const double alpha, const double *A,
 const CBLAS_INT_TYPE lda, const double *B, const CBLAS_INT_TYPE ldb,
 const double beta, double *C, const CBLAS_INT_TYPE ldc);
 void cblas_cgemm(const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA,
 const CBLAS_TRANSPOSE TransB, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const CBLAS_INT_TYPE K, const void *alpha, const void *A,
 const CBLAS_INT_TYPE lda, const void *B, const CBLAS_INT_TYPE ldb,
 const void *beta, void *C, const CBLAS_INT_TYPE ldc);
 void cblas_zgemm(const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA,
 const CBLAS_TRANSPOSE TransB, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const CBLAS_INT_TYPE K, const void *alpha, const void *A,
 const CBLAS_INT_TYPE lda, const void *B, const CBLAS_INT_TYPE ldb,
 const void *beta, void *C, const CBLAS_INT_TYPE ldc);
 void cblas_sgemv(const CBLAS_ORDER order,
 const CBLAS_TRANSPOSE TransA, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const float alpha, const float *A, const CBLAS_INT_TYPE lda,
 const float *X, const CBLAS_INT_TYPE incX, const float beta,
 float *Y, const CBLAS_INT_TYPE incY);
 void cblas_dgemv(const CBLAS_ORDER order,
 const CBLAS_TRANSPOSE TransA, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const double alpha, const double *A, const CBLAS_INT_TYPE lda,
 const double *X, const CBLAS_INT_TYPE incX, const double beta,
 double *Y, const CBLAS_INT_TYPE incY);
 void cblas_cgemv(const CBLAS_ORDER order,
 const CBLAS_TRANSPOSE TransA, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const void *alpha, const void *A, const CBLAS_INT_TYPE lda,
 const void *X, const CBLAS_INT_TYPE incX, const void *beta,
 void *Y, const CBLAS_INT_TYPE incY);
 void cblas_zgemv(const CBLAS_ORDER order,
 const CBLAS_TRANSPOSE TransA, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const void *alpha, const void *A, const CBLAS_INT_TYPE lda,
 const void *X, const CBLAS_INT_TYPE incX, const void *beta,
 void *Y, const CBLAS_INT_TYPE incY);
 void cblas_sger(const CBLAS_ORDER order, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const float alpha, const float *X, const CBLAS_INT_TYPE incX,
 const float *Y, const CBLAS_INT_TYPE incY, float *A, const CBLAS_INT_TYPE lda);
 void cblas_dger(const CBLAS_ORDER order, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const double alpha, const double *X, const CBLAS_INT_TYPE incX,
 const double *Y, const CBLAS_INT_TYPE incY, double *A, const CBLAS_INT_TYPE lda);
 void cblas_cgerc(const CBLAS_ORDER order, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const void *alpha, const void *X, const CBLAS_INT_TYPE incX,
 const void *Y, const CBLAS_INT_TYPE incY, void *A, const CBLAS_INT_TYPE lda);
 void cblas_zgerc(const CBLAS_ORDER order, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const void *alpha, const void *X, const CBLAS_INT_TYPE incX,
 const void *Y, const CBLAS_INT_TYPE incY, void *A, const CBLAS_INT_TYPE lda);
 float cblas_sdot(const CBLAS_INT_TYPE N, const float *X, const CBLAS_INT_TYPE incX,
 const float *Y, const CBLAS_INT_TYPE incY);
 double cblas_ddot(const CBLAS_INT_TYPE N, const double *X, const CBLAS_INT_TYPE incX,
 const double *Y, const CBLAS_INT_TYPE incY);
 void cblas_cdotu_sub(const CBLAS_INT_TYPE N, const void *X, const CBLAS_INT_TYPE incX,
 const void *Y, const CBLAS_INT_TYPE incY, void *dotu);
 void cblas_zdotu_sub(const CBLAS_INT_TYPE N, const void *X, const CBLAS_INT_TYPE incX,
 const void *Y, const CBLAS_INT_TYPE incY, void *dotu);
 void cblas_cdotc_sub(const CBLAS_INT_TYPE N, const void *X, const CBLAS_INT_TYPE incX,
 const void *Y, const CBLAS_INT_TYPE incY, void *dotc);
 void cblas_zdotc_sub(const CBLAS_INT_TYPE N, const void *X, const CBLAS_INT_TYPE incX,
 const void *Y, const CBLAS_INT_TYPE incY, void *dotc);
 void cblas_cgeru(const CBLAS_ORDER order, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const void *alpha, const void *X, const CBLAS_INT_TYPE incX,
 const void *Y, const CBLAS_INT_TYPE incY, void *A, const CBLAS_INT_TYPE lda);
 void cblas_zgeru(const CBLAS_ORDER order, const CBLAS_INT_TYPE M, const CBLAS_INT_TYPE N,
 const void *alpha, const void *X, const CBLAS_INT_TYPE incX,
 const void *Y, const CBLAS_INT_TYPE incY, void *A, const CBLAS_INT_TYPE lda);
 }
#endif // if DLIB_DEFINE_CBLAS_API
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 inline void cblas_axpy(const int N, const float alpha, const float *X,
 const int incX, float *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_AXPY;
 cblas_saxpy(N, alpha, X, incX, Y, incY);
 }
 inline void cblas_axpy(const int N, const double alpha, const double *X,
 const int incX, double *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_AXPY;
 cblas_daxpy(N, alpha, X, incX, Y, incY);
 }
 inline void cblas_axpy(const int N, const std::complex<float>& alpha, const std::complex<float> *X,
 const int incX, std::complex<float> *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_AXPY;
 cblas_caxpy(N, (float*)&alpha, (float*)X, incX, (float*)Y, incY);
 }
 inline void cblas_axpy(const int N, const std::complex<double>& alpha, const std::complex<double> *X,
 const int incX, std::complex<double> *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_AXPY;
 cblas_zaxpy(N, (double*)&alpha, (double*)X, incX, (double*)Y, incY);
 }
 // ----------------------------------------------------------------------------------------
 inline void cblas_scal(const int N, const float alpha, float *X)
 {
 DLIB_TEST_BLAS_BINDING_SCAL;
 cblas_sscal(N, alpha, X, 1);
 }
 inline void cblas_scal(const int N, const double alpha, double *X)
 {
 DLIB_TEST_BLAS_BINDING_SCAL;
 cblas_dscal(N, alpha, X, 1);
 }
 inline void cblas_scal(const int N, const std::complex<float>& alpha, std::complex<float> *X)
 {
 DLIB_TEST_BLAS_BINDING_SCAL;
 cblas_cscal(N, (float*)&alpha, (float*)X, 1);
 }
 inline void cblas_scal(const int N, const std::complex<double>& alpha, std::complex<double> *X)
 {
 DLIB_TEST_BLAS_BINDING_SCAL;
 cblas_zscal(N, (double*)&alpha, (double*)X, 1);
 }
 // ----------------------------------------------------------------------------------------
 inline void cblas_gemm( const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA,
 const CBLAS_TRANSPOSE TransB, const int M, const int N,
 const int K, const float alpha, const float *A,
 const int lda, const float *B, const int ldb,
 const float beta, float *C, const int ldc)
 {
 DLIB_TEST_BLAS_BINDING_GEMM;
 cblas_sgemm( Order, TransA, TransB, M, N,
 K, alpha, A, lda, B, ldb, beta, C, ldc);
 }
 inline void cblas_gemm(const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA,
 const 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)
 {
 DLIB_TEST_BLAS_BINDING_GEMM;
 cblas_dgemm( Order, TransA, TransB, M, N,
 K, alpha, A, lda, B, ldb, beta, C, ldc);
 }
 inline void cblas_gemm(const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA,
 const CBLAS_TRANSPOSE TransB, const int M, const int N,
 const int K, const std::complex<float>& alpha, const std::complex<float> *A,
 const int lda, const std::complex<float> *B, const int ldb,
 const std::complex<float>& beta, std::complex<float> *C, const int ldc)
 {
 DLIB_TEST_BLAS_BINDING_GEMM;
 cblas_cgemm( Order, TransA, TransB, M, N,
 K, (float*)&alpha, (float*)A, lda, (float*)B, ldb, (float*)&beta, (float*)C, ldc);
 }
 inline void cblas_gemm(const CBLAS_ORDER Order, const CBLAS_TRANSPOSE TransA,
 const CBLAS_TRANSPOSE TransB, const int M, const int N,
 const int K, const std::complex<double>& alpha, const std::complex<double> *A,
 const int lda, const std::complex<double> *B, const int ldb,
 const std::complex<double>& beta, std::complex<double> *C, const int ldc)
 {
 DLIB_TEST_BLAS_BINDING_GEMM;
 cblas_zgemm( Order, TransA, TransB, M, N,
 K, (double*)&alpha, (double*)A, lda, (double*)B, ldb, (double*)&beta, (double*)C, ldc);
 }
 // ----------------------------------------------------------------------------------------
 inline void cblas_gemv(const CBLAS_ORDER order,
 const CBLAS_TRANSPOSE TransA, const int M, const int N,
 const float alpha, const float *A, const int lda,
 const float *X, const int incX, const float beta,
 float *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_GEMV;
 cblas_sgemv(order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 }
 inline void cblas_gemv(const CBLAS_ORDER order,
 const 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)
 {
 DLIB_TEST_BLAS_BINDING_GEMV;
 cblas_dgemv(order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 }
 inline void cblas_gemv(const CBLAS_ORDER order,
 const CBLAS_TRANSPOSE TransA, const int M, const int N,
 const std::complex<float>& alpha, const std::complex<float> *A, const int lda,
 const std::complex<float> *X, const int incX, const std::complex<float>& beta,
 std::complex<float> *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_GEMV;
 cblas_cgemv(order, TransA, M, N, (float*)&alpha, (float*)A, lda, (float*)X, incX, (float*)&beta, (float*)Y, incY);
 }
 inline void cblas_gemv(const CBLAS_ORDER order,
 const CBLAS_TRANSPOSE TransA, const int M, const int N,
 const std::complex<double>& alpha, const std::complex<double> *A, const int lda,
 const std::complex<double> *X, const int incX, const std::complex<double>& beta,
 std::complex<double> *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_GEMV;
 cblas_zgemv(order, TransA, M, N, (double*)&alpha, (double*)A, lda, (double*)X, incX, (double*)&beta, (double*)Y, incY);
 }
 // ----------------------------------------------------------------------------------------
 inline void cblas_ger(const CBLAS_ORDER order, const int M, const int N,
 const std::complex<float>& alpha, const std::complex<float> *X, const int incX,
 const std::complex<float> *Y, const int incY, std::complex<float> *A, const int lda)
 {
 DLIB_TEST_BLAS_BINDING_GER;
 cblas_cgeru (order, M, N, (float*)&alpha, (float*)X, incX, (float*)Y, incY, (float*)A, lda);
 }
 inline void cblas_ger(const CBLAS_ORDER order, const int M, const int N,
 const std::complex<double>& alpha, const std::complex<double> *X, const int incX,
 const std::complex<double> *Y, const int incY, std::complex<double> *A, const int lda)
 {
 DLIB_TEST_BLAS_BINDING_GER;
 cblas_zgeru (order, M, N, (double*)&alpha, (double*)X, incX, (double*)Y, incY, (double*)A, lda);
 }
 inline void cblas_ger(const CBLAS_ORDER order, const int M, const int N,
 const float alpha, const float *X, const int incX,
 const float *Y, const int incY, float *A, const int lda)
 {
 DLIB_TEST_BLAS_BINDING_GER;
 cblas_sger (order, M, N, alpha, (float*)X, incX, (float*)Y, incY, (float*)A, lda);
 }
 inline void cblas_ger(const 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)
 {
 DLIB_TEST_BLAS_BINDING_GER;
 cblas_dger (order, M, N, alpha, (double*)X, incX, (double*)Y, incY, (double*)A, lda);
 }
 // ----------------------------------------------------------------------------------------
 inline void cblas_gerc(const CBLAS_ORDER order, const int M, const int N,
 const std::complex<float>& alpha, const std::complex<float> *X, const int incX,
 const std::complex<float> *Y, const int incY, std::complex<float> *A, const int lda)
 {
 DLIB_TEST_BLAS_BINDING_GER;
 cblas_cgerc (order, M, N, (float*)&alpha, (float*)X, incX, (float*)Y, incY, (float*)A, lda);
 }
 inline void cblas_gerc(const CBLAS_ORDER order, const int M, const int N,
 const std::complex<double>& alpha, const std::complex<double> *X, const int incX,
 const std::complex<double> *Y, const int incY, std::complex<double> *A, const int lda)
 {
 DLIB_TEST_BLAS_BINDING_GER;
 cblas_zgerc (order, M, N, (double*)&alpha, (double*)X, incX, (double*)Y, incY, (double*)A, lda);
 }
 // ----------------------------------------------------------------------------------------
 inline float cblas_dot(const int N, const float *X, const int incX,
 const float *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_DOT;
 return cblas_sdot(N, X, incX, Y, incY);
 }
 inline double cblas_dot(const int N, const double *X, const int incX,
 const double *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_DOT;
 return cblas_ddot(N, X, incX, Y, incY);
 }
 inline std::complex<float> cblas_dot(const int N, const std::complex<float> *X, const int incX,
 const std::complex<float> *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_DOT;
 std::complex<float> result;
 cblas_cdotu_sub(N, (float*)X, incX, (float*)Y, incY, (float*)&result);
 return result;
 }
 inline std::complex<double> cblas_dot(const int N, const std::complex<double> *X, const int incX,
 const std::complex<double> *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_DOT;
 std::complex<double> result;
 cblas_zdotu_sub(N, (double*)X, incX, (double*)Y, incY, (double*)&result);
 return result;
 }
 // ----------------------------------------------------------------------------------------
 inline std::complex<float> cblas_dotc(const int N, const std::complex<float> *X, const int incX,
 const std::complex<float> *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_DOT;
 std::complex<float> result;
 cblas_cdotc_sub(N, (float*)X, incX, (float*)Y, incY, (float*)&result);
 return result;
 }
 inline std::complex<double> cblas_dotc(const int N, const std::complex<double> *X, const int incX,
 const std::complex<double> *Y, const int incY)
 {
 DLIB_TEST_BLAS_BINDING_DOT;
 std::complex<double> result;
 cblas_zdotc_sub(N, (double*)X, incX, (double*)Y, incY, (double*)&result);
 return result;
 }
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // Helpers for determining the data pointer, LDA, and incX arguments to BLAS functions.
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const matrix<T,NR,NC,MM,row_major_layout>& m) { return m.nc(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const matrix<T,NR,NC,MM,column_major_layout>& m) { return m.nr(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const matrix_op<op_subm<matrix<T,NR,NC,MM,row_major_layout> > >& m) { return m.op.m.nc(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const matrix_op<op_subm<matrix<T,NR,NC,MM,column_major_layout> > >& m) { return m.op.m.nr(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const assignable_sub_matrix<T,NR,NC,MM,row_major_layout>& m) { return m.m.nc(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const assignable_sub_matrix<T,NR,NC,MM,column_major_layout>& m) { return m.m.nr(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const assignable_col_matrix<T,NR,NC,MM,row_major_layout>& m) { return m.m.nc(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const assignable_col_matrix<T,NR,NC,MM,column_major_layout>& m) { return m.m.nr(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const assignable_row_matrix<T,NR,NC,MM,row_major_layout>& m) { return m.m.nc(); }
 template <typename T, long NR, long NC, typename MM>
 int get_ld (const assignable_row_matrix<T,NR,NC,MM,column_major_layout>& m) { return m.m.nr(); }
 template <typename T>
 int get_ld (const assignable_ptr_matrix<T>& m) { return m.nc(); }
 template <typename T, typename MM>
 int get_ld (const matrix_op<op_array2d_to_mat<array2d<T,MM> > >& m) { return m.nc(); }
 template <typename T, typename MM>
 int get_ld (const matrix_op<op_array_to_mat<array<T,MM> > >& m) { return m.nc(); }
 template < typename value_type, typename alloc >
 int get_ld (const matrix_op<op_std_vect_to_mat<std::vector<value_type,alloc> > >& m) { return m.nc(); }
 template < typename value_type, typename alloc >
 int get_ld (const matrix_op<op_std_vect_to_mat<std_vector_c<value_type,alloc> > >& m) { return m.nc(); }
 template <typename T>
 int get_ld (const matrix_op<op_pointer_to_col_vect<T> >& m) { return m.nc(); }
 template <typename T>
 int get_ld (const matrix_op<op_pointer_to_mat<T> >& m) { return m.op.stride; }
 // --------
 // get_inc() returns the offset from one element to another. If an object has a
 // non-uniform offset between elements then returns 0 (e.g. a subm() view could
 // have a non-uniform offset between elements).
 template <typename T, typename MM>
 int get_inc (const matrix_op<op_array2d_to_mat<array2d<T,MM> > >& ) { return 1; }
 template <typename T, typename MM>
 int get_inc (const matrix_op<op_array_to_mat<array<T,MM> > >& ) { return 1; }
 template < typename value_type, typename alloc >
 int get_inc (const matrix_op<op_std_vect_to_mat<std::vector<value_type,alloc> > >& ) { return 1; }
 template < typename value_type, typename alloc >
 int get_inc (const matrix_op<op_std_vect_to_mat<std_vector_c<value_type,alloc> > >& ) { return 1; }
 template <typename T>
 int get_inc (const matrix_op<op_pointer_to_col_vect<T> >& ) { return 1; }
 template <typename T>
 int get_inc (const matrix_op<op_pointer_to_mat<T> >& m) { return m.op.stride==m.op.cols ? 1 : 0; }
 template <typename T, long NR, long NC, typename MM, typename L>
 int get_inc (const matrix<T,NR,NC,MM,L>& ) { return 1; }
 template <typename T, long NR, long NC, typename MM>
 int get_inc (const matrix_op<op_subm<matrix<T,NR,NC,MM,row_major_layout> > >& m) 
 { 
 // if the sub-view doesn't cover all the columns then it can't have a uniform
 // layout.
 if (m.nc() < m.op.m.nc())
 return 0;
 else
 return 1;
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc (const matrix_op<op_subm<matrix<T,NR,NC,MM,column_major_layout> > >& m) 
 { 
 if (m.nr() < m.op.m.nr())
 return 0;
 else
 return 1;
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc (const assignable_sub_matrix<T,NR,NC,MM,row_major_layout>& m) 
 { 
 if (m.nc() < m.m.nc())
 return 0;
 else
 return 1;
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc (const assignable_sub_matrix<T,NR,NC,MM,column_major_layout>& m) 
 {
 if (m.nr() < m.m.nr())
 return 0;
 else
 return 1;
 }
 template <typename T>
 int get_inc (const assignable_ptr_matrix<T>& ) { return 1; }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const matrix_op<op_colm<matrix<T,NR,NC,MM,row_major_layout> > >& m)
 {
 return m.op.m.nc();
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const matrix_op<op_rowm<matrix<T,NR,NC,MM,row_major_layout> > >& )
 {
 return 1;
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const matrix_op<op_colm2<matrix<T,NR,NC,MM,row_major_layout> > >& m)
 {
 return m.op.m.nc();
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const matrix_op<op_rowm2<matrix<T,NR,NC,MM,row_major_layout> > >& )
 {
 return 1;
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const matrix_op<op_colm<matrix<T,NR,NC,MM,column_major_layout> > >& )
 {
 return 1;
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const matrix_op<op_rowm<matrix<T,NR,NC,MM,column_major_layout> > >& m)
 {
 return m.op.m.nr();
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const matrix_op<op_colm2<matrix<T,NR,NC,MM,column_major_layout> > >& )
 {
 return 1;
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const matrix_op<op_rowm2<matrix<T,NR,NC,MM,column_major_layout> > >& m)
 {
 return m.op.m.nr();
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const assignable_row_matrix<T,NR,NC,MM,row_major_layout>& )
 {
 return 1;
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const assignable_row_matrix<T,NR,NC,MM,column_major_layout>& m)
 {
 return m.m.nr();
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const assignable_col_matrix<T,NR,NC,MM,row_major_layout>& m)
 {
 return m.m.nc();
 }
 template <typename T, long NR, long NC, typename MM>
 int get_inc(const assignable_col_matrix<T,NR,NC,MM,column_major_layout>& )
 {
 return 1;
 }
 // --------
 template <typename T, long NR, long NC, typename MM, typename L>
 const T* get_ptr (const matrix<T,NR,NC,MM,L>& m) { return &m(0,0); }
 template <typename T, long NR, long NC, typename MM, typename L>
 T* get_ptr (matrix<T,NR,NC,MM,L>& m) { return &m(0,0); }
 template <typename T, long NR, long NC, typename MM, typename L>
 const T* get_ptr (const matrix_op<op_subm<matrix<T,NR,NC,MM,L> > >& m) { return &m.op.m(m.op.r_,m.op.c_); }
 template <typename T, long NR, long NC, typename MM, typename L>
 const T* get_ptr (const matrix_op<op_colm<matrix<T,NR,NC,MM,L> > >& m) { return &m.op.m(0,m.op.col); }
 template <typename T, long NR, long NC, typename MM, typename L>
 const T* get_ptr (const matrix_op<op_rowm<matrix<T,NR,NC,MM,L> > >& m) { return &m.op.m(m.op.row,0); }
 template <typename T, long NR, long NC, typename MM, typename L>
 const T* get_ptr (const matrix_op<op_colm2<matrix<T,NR,NC,MM,L> > >& m) { return &m.op.m(0,m.op.col); }
 template <typename T, long NR, long NC, typename MM, typename L>
 const T* get_ptr (const matrix_op<op_rowm2<matrix<T,NR,NC,MM,L> > >& m) { return &m.op.m(m.op.row,0); }
 template <typename T, long NR, long NC, typename MM, typename L>
 T* get_ptr (assignable_col_matrix<T,NR,NC,MM,L>& m) { return &m(0,0); }
 template <typename T, long NR, long NC, typename MM, typename L>
 T* get_ptr (assignable_row_matrix<T,NR,NC,MM,L>& m) { return &m(0,0); }
 template <typename T, long NR, long NC, typename MM, typename L>
 T* get_ptr (assignable_sub_matrix<T,NR,NC,MM,L>& m) { return &m(0,0); }
 template <typename T>
 T* get_ptr (assignable_ptr_matrix<T>& m) { return m.ptr; }
 template <typename T, typename MM>
 const T* get_ptr (const matrix_op<op_array2d_to_mat<array2d<T,MM> > >& m) { return &m.op.array[0][0]; }
 template <typename T, typename MM>
 const T* get_ptr (const matrix_op<op_array_to_mat<array<T,MM> > >& m) { return &m.op.vect[0]; }
 template < typename T, typename alloc >
 const T* get_ptr (const matrix_op<op_std_vect_to_mat<std::vector<T,alloc> > >& m) { return &m.op.vect[0]; }
 template < typename T, typename alloc >
 const T* get_ptr (const matrix_op<op_std_vect_to_mat<std_vector_c<T,alloc> > >& m) { return &m.op.vect[0]; }
 template <typename T>
 const T* get_ptr (const matrix_op<op_pointer_to_col_vect<T> >& m) { return m.op.ptr; }
 template <typename T>
 const T* get_ptr (const matrix_op<op_pointer_to_mat<T> >& m) { return m.op.ptr; }
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // Here we declare some matrix objects for use in the DLIB_ADD_BLAS_BINDING macro. These
 // extern declarations don't actually correspond to any real matrix objects. They are
 // simply here so we can build matrix expressions with the DLIB_ADD_BLAS_BINDING marco.
 // Note that the fact that these are double matrices isn't important, it is just a placeholder in this case. 
 extern matrix<double> m; // general matrix 
 extern matrix<double,1,0> rv; // general row vector
 extern matrix<double,0,1> cv; // general column vector
 extern const double s;
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // AXPY/SCAL overloads
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 DLIB_ADD_BLAS_BINDING(m)
 {
 const int N = static_cast<int>(src.size());
 if (transpose == false && N != 0)
 {
 if (add_to)
 {
 if (get_inc(src) && get_inc(dest))
 cblas_axpy(N, alpha, get_ptr(src), get_inc(src), get_ptr(dest), get_inc(dest));
 else
 matrix_assign_default(dest, src, alpha, add_to);
 }
 else
 {
 if (get_ptr(src) == get_ptr(dest))
 cblas_scal(N, alpha, get_ptr(dest));
 else
 matrix_assign_default(dest, src, alpha, add_to);
 }
 }
 else
 {
 matrix_assign_default(dest, trans(src), alpha, add_to);
 }
 } DLIB_END_BLAS_BINDING
 DLIB_ADD_BLAS_BINDING(rv)
 {
 const int N = static_cast<int>(src.size());
 if (transpose == false && N != 0)
 {
 if (add_to)
 {
 if (get_inc(src) && get_inc(dest))
 cblas_axpy(N, alpha, get_ptr(src), get_inc(src), get_ptr(dest), get_inc(dest));
 else
 matrix_assign_default(dest, src, alpha, add_to);
 }
 else
 {
 if (get_ptr(src) == get_ptr(dest))
 cblas_scal(N, alpha, get_ptr(dest));
 else
 matrix_assign_default(dest, src, alpha, add_to);
 }
 }
 else
 {
 matrix_assign_default(dest, trans(src), alpha, add_to);
 }
 } DLIB_END_BLAS_BINDING
 DLIB_ADD_BLAS_BINDING(cv)
 {
 const int N = static_cast<int>(src.size());
 if (transpose == false && N != 0)
 {
 if (add_to)
 {
 if (get_inc(src) && get_inc(dest))
 cblas_axpy(N, alpha, get_ptr(src), get_inc(src), get_ptr(dest), get_inc(dest));
 else
 matrix_assign_default(dest, src, alpha, add_to);
 }
 else
 {
 if (get_ptr(src) == get_ptr(dest))
 cblas_scal(N, alpha, get_ptr(dest));
 else
 matrix_assign_default(dest, src, alpha, add_to);
 }
 }
 else
 {
 matrix_assign_default(dest, trans(src), alpha, add_to);
 }
 } DLIB_END_BLAS_BINDING
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // GEMM overloads
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 DLIB_ADD_BLAS_BINDING(m*m)
 {
 //cout << "BLAS GEMM: m*m" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs);
 const int lda = get_ld(src.lhs);
 const T* B = get_ptr(src.rhs);
 const int ldb = get_ld(src.rhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, CblasNoTrans, CblasNoTrans, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 cblas_gemm(Order, CblasTrans, CblasTrans, N, M, K, alpha, B, ldb, A, lda, beta, C, ldc);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(m)*m)
 {
 //cout << "BLAS GEMM: trans(m)*m" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasTrans;
 const CBLAS_TRANSPOSE TransB = CblasNoTrans;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* B = get_ptr(src.rhs);
 const int ldb = get_ld(src.rhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 cblas_gemm(Order, TransA, TransB, N, M, K, alpha, B, ldb, A, lda, beta, C, ldc);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(m*trans(m))
 {
 //cout << "BLAS GEMM: m*trans(m)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasNoTrans;
 const CBLAS_TRANSPOSE TransB = CblasTrans;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs);
 const int lda = get_ld(src.lhs);
 const T* B = get_ptr(src.rhs.op.m);
 const int ldb = get_ld(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 cblas_gemm(Order, TransA, TransB, N, M, K, alpha, B, ldb, A, lda, beta, C, ldc);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(m)*trans(m))
 {
 //cout << "BLAS GEMM: trans(m)*trans(m)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* B = get_ptr(src.rhs.op.m);
 const int ldb = get_ld(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, CblasTrans, CblasTrans, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 cblas_gemm(Order, CblasNoTrans, CblasNoTrans, N, M, K, alpha, B, ldb, A, lda, beta, C, ldc);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 // --------------------------------------
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(conj(m))*m)
 {
 //cout << "BLAS GEMM: trans(conj(m))*m" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasConjTrans;
 const CBLAS_TRANSPOSE TransB = CblasNoTrans;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* B = get_ptr(src.rhs);
 const int ldb = get_ld(src.rhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 matrix_assign_default(dest, trans(src), alpha, add_to);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(conj(m))*trans(m))
 {
 //cout << "BLAS GEMM: trans(conj(m))*trans(m)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasConjTrans;
 const CBLAS_TRANSPOSE TransB = CblasTrans;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* B = get_ptr(src.rhs.op.m);
 const int ldb = get_ld(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 matrix_assign_default(dest, trans(src), alpha, add_to);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(m*trans(conj(m)))
 {
 //cout << "BLAS GEMM: m*trans(conj(m))" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasNoTrans;
 const CBLAS_TRANSPOSE TransB = CblasConjTrans;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs);
 const int lda = get_ld(src.lhs);
 const T* B = get_ptr(src.rhs.op.m);
 const int ldb = get_ld(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 matrix_assign_default(dest, trans(src), alpha, add_to);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(m)*trans(conj(m)))
 {
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasTrans;
 const CBLAS_TRANSPOSE TransB = CblasConjTrans;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* B = get_ptr(src.rhs.op.m);
 const int ldb = get_ld(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 matrix_assign_default(dest, trans(src), alpha, add_to);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(conj(m))*trans(conj(m)))
 {
 //cout << "BLAS GEMM: trans(conj(m))*trans(conj(m))" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasConjTrans;
 const CBLAS_TRANSPOSE TransB = CblasConjTrans;
 const int M = static_cast<int>(src.nr());
 const int N = static_cast<int>(src.nc());
 const int K = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* B = get_ptr(src.rhs.op.m);
 const int ldb = get_ld(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* C = get_ptr(dest);
 const int ldc = get_ld(dest);
 if (transpose == false)
 cblas_gemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
 else
 matrix_assign_default(dest, trans(src), alpha, add_to);
 } DLIB_END_BLAS_BINDING
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // GEMV overloads
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 DLIB_ADD_BLAS_BINDING(m*cv)
 {
 //cout << "BLAS GEMV: m*cv" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasNoTrans;
 const int M = static_cast<int>(src.lhs.nr());
 const int N = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs);
 const int lda = get_ld(src.lhs);
 const T* X = get_ptr(src.rhs);
 const int incX = get_inc(src.rhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(rv*m)
 {
 // Note that rv*m is the same as trans(m)*trans(rv)
 //cout << "BLAS GEMV: rv*m" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasTrans;
 const int M = static_cast<int>(src.rhs.nr());
 const int N = static_cast<int>(src.rhs.nc());
 const T* A = get_ptr(src.rhs);
 const int lda = get_ld(src.rhs);
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(cv)*m)
 {
 // Note that trans(cv)*m is the same as trans(m)*cv
 //cout << "BLAS GEMV: trans(cv)*m" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasTrans;
 const int M = static_cast<int>(src.rhs.nr());
 const int N = static_cast<int>(src.rhs.nc());
 const T* A = get_ptr(src.rhs);
 const int lda = get_ld(src.rhs);
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(m*trans(rv))
 {
 //cout << "BLAS GEMV: m*trans(rv)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasNoTrans;
 const int M = static_cast<int>(src.lhs.nr());
 const int N = static_cast<int>(src.lhs.nc());
 const T* A = get_ptr(src.lhs);
 const int lda = get_ld(src.lhs);
 const T* X = get_ptr(src.rhs.op.m);
 const int incX = get_inc(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 // --------------------------------------
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(m)*cv)
 {
 //cout << "BLAS GEMV: trans(m)*cv" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasTrans;
 const int M = static_cast<int>(src.lhs.op.m.nr());
 const int N = static_cast<int>(src.lhs.op.m.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* X = get_ptr(src.rhs);
 const int incX = get_inc(src.rhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(rv*trans(m))
 {
 // Note that rv*trans(m) is the same as m*trans(rv)
 //cout << "BLAS GEMV: rv*trans(m)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasNoTrans;
 const int M = static_cast<int>(src.rhs.op.m.nr());
 const int N = static_cast<int>(src.rhs.op.m.nc());
 const T* A = get_ptr(src.rhs.op.m);
 const int lda = get_ld(src.rhs.op.m);
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(cv)*trans(m))
 {
 // Note that trans(cv)*trans(m) is the same as m*cv
 //cout << "BLAS GEMV: trans(cv)*trans(m)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasNoTrans;
 const int M = static_cast<int>(src.rhs.op.m.nr());
 const int N = static_cast<int>(src.rhs.op.m.nc());
 const T* A = get_ptr(src.rhs.op.m);
 const int lda = get_ld(src.rhs.op.m);
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(m)*trans(rv))
 {
 //cout << "BLAS GEMV: trans(m)*trans(rv)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasTrans;
 const int M = static_cast<int>(src.lhs.op.m.nr());
 const int N = static_cast<int>(src.lhs.op.m.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* X = get_ptr(src.rhs.op.m);
 const int incX = get_inc(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 // --------------------------------------
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(cv)*conj(m))
 {
 // Note that trans(cv)*conj(m) == conj(trans(m))*cv
 //cout << "BLAS GEMV: trans(cv)*conj(m)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasConjTrans;
 const int M = static_cast<int>(src.rhs.op.m.nr());
 const int N = static_cast<int>(src.rhs.op.m.nc());
 const T* A = get_ptr(src.rhs.op.m);
 const int lda = get_ld(src.rhs.op.m);
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(rv*conj(m))
 {
 // Note that rv*conj(m) == conj(trans(m))*cv
 //cout << "BLAS GEMV: rv*conj(m)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasConjTrans;
 const int M = static_cast<int>(src.rhs.op.m.nr());
 const int N = static_cast<int>(src.rhs.op.m.nc());
 const T* A = get_ptr(src.rhs.op.m);
 const int lda = get_ld(src.rhs.op.m);
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(conj(m))*cv)
 {
 //cout << "BLAS GEMV: trans(conj(m))*cv" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasConjTrans;
 const int M = static_cast<int>(src.lhs.op.m.nr());
 const int N = static_cast<int>(src.lhs.op.m.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* X = get_ptr(src.rhs);
 const int incX = get_inc(src.rhs);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(conj(m))*trans(rv))
 {
 //cout << "BLAS GEMV: trans(conj(m))*trans(rv)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const CBLAS_TRANSPOSE TransA = CblasConjTrans;
 const int M = static_cast<int>(src.lhs.op.m.nr());
 const int N = static_cast<int>(src.lhs.op.m.nc());
 const T* A = get_ptr(src.lhs.op.m);
 const int lda = get_ld(src.lhs.op.m);
 const T* X = get_ptr(src.rhs.op.m);
 const int incX = get_inc(src.rhs.op.m);
 const T beta = static_cast<T>(add_to?1:0);
 T* Y = get_ptr(dest);
 const int incY = get_inc(dest);
 cblas_gemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY);
 } DLIB_END_BLAS_BINDING
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // GER overloads
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 DLIB_ADD_BLAS_BINDING(cv*rv)
 {
 //cout << "BLAS GER: cv*rv" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(dest.nr());
 const int N = static_cast<int>(dest.nc());
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T* Y = get_ptr(src.rhs);
 const int incY = get_inc(src.rhs);
 if (add_to == false)
 zero_matrix(dest);
 T* A = get_ptr(dest);
 const int lda = get_ld(dest);
 if (transpose == false)
 cblas_ger(Order, M, N, alpha, X, incX, Y, incY, A, lda);
 else
 cblas_ger(Order, M, N, alpha, Y, incY, X, incX, A, lda);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(rv)*rv)
 {
 //cout << "BLAS GER: trans(rv)*rv" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(dest.nr());
 const int N = static_cast<int>(dest.nc());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs);
 const int incY = get_inc(src.rhs);
 if (add_to == false)
 zero_matrix(dest);
 T* A = get_ptr(dest);
 const int lda = get_ld(dest);
 if (transpose == false)
 cblas_ger(Order, M, N, alpha, X, incX, Y, incY, A, lda);
 else
 cblas_ger(Order, M, N, alpha, Y, incY, X, incX, A, lda);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(cv*trans(cv))
 {
 //cout << "BLAS GER: cv*trans(cv)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(dest.nr());
 const int N = static_cast<int>(dest.nc());
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (add_to == false)
 zero_matrix(dest);
 T* A = get_ptr(dest);
 const int lda = get_ld(dest);
 if (transpose == false)
 cblas_ger(Order, M, N, alpha, X, incX, Y, incY, A, lda);
 else
 cblas_ger(Order, M, N, alpha, Y, incY, X, incX, A, lda);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(rv)*trans(cv))
 {
 //cout << "BLAS GER: trans(rv)*trans(cv)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(dest.nr());
 const int N = static_cast<int>(dest.nc());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (add_to == false)
 zero_matrix(dest);
 T* A = get_ptr(dest);
 const int lda = get_ld(dest);
 if (transpose == false)
 cblas_ger(Order, M, N, alpha, X, incX, Y, incY, A, lda);
 else
 cblas_ger(Order, M, N, alpha, Y, incY, X, incX, A, lda);
 } DLIB_END_BLAS_BINDING
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // GERC overloads
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 /*
 DLIB_ADD_BLAS_BINDING(cv*conj(rv))
 {
 //cout << "BLAS GERC: cv*conj(rv)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(dest.nr());
 const int N = static_cast<int>(dest.nc());
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (add_to == false)
 zero_matrix(dest);
 T* A = get_ptr(dest);
 const int lda = get_ld(dest);
 if (transpose == false)
 cblas_gerc(Order, M, N, alpha, X, incX, Y, incY, A, lda);
 else
 cblas_gerc(Order, M, N, alpha, Y, incY, X, incX, A, lda);
 } DLIB_END_BLAS_BINDING
 */
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(cv*conj(trans(cv)))
 {
 //cout << "BLAS GERC: cv*conj(trans(cv))" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(dest.nr());
 const int N = static_cast<int>(dest.nc());
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (transpose == false)
 {
 T* A = get_ptr(dest);
 const int lda = get_ld(dest);
 if (add_to == false)
 zero_matrix(dest);
 cblas_gerc(Order, M, N, alpha, X, incX, Y, incY, A, lda);
 }
 else
 {
 matrix_assign_default(dest,trans(src),alpha,add_to);
 //cblas_gerc(Order, M, N, alpha, Y, incY, X, incX, A, lda);
 }
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(rv)*conj(trans(cv)))
 {
 //cout << "BLAS GERC: trans(rv)*conj(trans(cv))" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(dest.nr());
 const int N = static_cast<int>(dest.nc());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (transpose == false)
 {
 if (add_to == false)
 zero_matrix(dest);
 T* A = get_ptr(dest);
 const int lda = get_ld(dest);
 cblas_gerc(Order, M, N, alpha, X, incX, Y, incY, A, lda);
 }
 else
 {
 matrix_assign_default(dest,trans(src),alpha,add_to);
 //cblas_gerc(Order, M, N, alpha, Y, incY, X, incX, A, lda);
 }
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 /*
 DLIB_ADD_BLAS_BINDING(trans(rv)*conj(rv))
 {
 //cout << "BLAS GERC: trans(rv)*conj(rv)" << endl;
 const bool is_row_major_order = is_same_type<typename dest_exp::layout_type,row_major_layout>::value; 
 const CBLAS_ORDER Order = is_row_major_order ? CblasRowMajor : CblasColMajor;
 const int M = static_cast<int>(dest.nr());
 const int N = static_cast<int>(dest.nc());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (add_to == false)
 zero_matrix(dest);
 T* A = get_ptr(dest);
 const int lda = get_ld(dest);
 if (transpose == false)
 cblas_gerc(Order, M, N, alpha, X, incX, Y, incY, A, lda);
 else
 cblas_gerc(Order, M, N, alpha, Y, incY, X, incX, A, lda);
 } DLIB_END_BLAS_BINDING
 */
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // DOT overloads
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 DLIB_ADD_BLAS_BINDING(rv*cv)
 {
 //cout << "BLAS DOT: rv*cv" << endl;
 const int N = static_cast<int>(src.lhs.size());
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T* Y = get_ptr(src.rhs);
 const int incY = get_inc(src.rhs);
 if (add_to == false)
 dest(0) = alpha*cblas_dot(N, X, incX, Y, incY);
 else
 dest(0) += alpha*cblas_dot(N, X, incX, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(cv)*cv)
 {
 //cout << "BLAS DOT: trans(cv)*cv" << endl;
 const int N = static_cast<int>(src.lhs.size());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs);
 const int incY = get_inc(src.rhs);
 if (add_to == false)
 dest(0) = alpha*cblas_dot(N, X, incX, Y, incY);
 else
 dest(0) += alpha*cblas_dot(N, X, incX, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(rv*trans(rv))
 {
 //cout << "BLAS DOT: rv*trans(rv)" << endl;
 const int N = static_cast<int>(src.lhs.size());
 const T* X = get_ptr(src.lhs);
 const int incX = get_inc(src.lhs);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (add_to == false)
 dest(0) = alpha*cblas_dot(N, X, incX, Y, incY);
 else
 dest(0) += alpha*cblas_dot(N, X, incX, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(cv)*trans(rv))
 {
 //cout << "BLAS DOT: trans(cv)*trans(rv)" << endl;
 const int N = static_cast<int>(src.lhs.op.m.size());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (add_to == false)
 dest(0) = alpha*cblas_dot(N, X, incX, Y, incY);
 else
 dest(0) += alpha*cblas_dot(N, X, incX, Y, incY);
 } DLIB_END_BLAS_BINDING
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 // DOTC overloads
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 DLIB_ADD_BLAS_BINDING(conj(rv)*cv)
 {
 //cout << "BLAS DOTC: conj(rv)*cv" << endl;
 const int N = static_cast<int>(src.lhs.op.m.size());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs);
 const int incY = get_inc(src.rhs);
 if (add_to == false)
 dest(0) = alpha*cblas_dotc(N, X, incX, Y, incY);
 else
 dest(0) += alpha*cblas_dotc(N, X, incX, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(conj(trans(cv))*cv)
 {
 //cout << "BLAS DOTC: conj(trans(cv))*cv" << endl;
 const int N = static_cast<int>(src.lhs.op.m.size());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs);
 const int incY = get_inc(src.rhs);
 if (add_to == false)
 dest(0) = alpha*cblas_dotc(N, X, incX, Y, incY);
 else
 dest(0) += alpha*cblas_dotc(N, X, incX, Y, incY);
 } DLIB_END_BLAS_BINDING
 // --------------------------------------
 DLIB_ADD_BLAS_BINDING(trans(conj(cv))*trans(rv))
 {
 //cout << "BLAS DOTC: trans(conj(cv))*trans(rv)" << endl;
 const int N = static_cast<int>(src.lhs.op.m.size());
 const T* X = get_ptr(src.lhs.op.m);
 const int incX = get_inc(src.lhs.op.m);
 const T* Y = get_ptr(src.rhs.op.m);
 const int incY = get_inc(src.rhs.op.m);
 if (add_to == false)
 dest(0) = alpha*cblas_dotc(N, X, incX, Y, incY);
 else
 dest(0) += alpha*cblas_dotc(N, X, incX, Y, incY);
 } DLIB_END_BLAS_BINDING
 }
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_MATRIx_BLAS_BINDINGS_