#? * CBLAS: Single Precision Functions
;;.AUTHOR Fu Jie Huang, Yann LeCun
;; This provides a complete interface to the CBLAS
;; library of low-level linear algebra functions.

(libload "cblas-config")
(libload "cblas-constants")

(de cblas-dummy () (cpheader "#include <gsl/gsl_cblas.h>") ())

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(if cblas-useintel
    (de cblas_sdsdot(    n  alpha  x  incx  y  incy )
      ((-int-) n)
      ((-float-) alpha) 
      ((-gptr- "const float *") x) 
      ((-int-) incx) 
      ((-gptr- "const float *") y) 
      ((-int-) incy) 
      (error "cblas_sdsdot is not available in the Intel MKL/CBLAS library")
      )
  (de cblas_sdsdot (    n  alpha  x  incx  y  incy )
    ((-int-) n)
    ((-float-) alpha) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "const float *") y) 
    ((-int-) incy) 
    (float  #{ cblas_sdsdot(  $n ,$alpha ,$x ,$incx ,$y ,$incy) #} )
    )
  )

(if cblas-useintel
  (de cblas_dsdot (    n  x  incx  y  incy )
    ((-int-) n) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "const float *") y) 
    ((-int-) incy) 
    (error "cblas_dsdot is not available in the Intel MKL/CBLAS library")
    )
  (de cblas_dsdot (    n  x  incx  y  incy )
    ((-int-) n) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "const float *") y) 
    ((-int-) incy) 
    (double #{ cblas_dsdot(  $n ,$x ,$incx ,$y ,$incy) #} )
    )
  )

(de cblas_sdot (    n  x  incx  y  incy )
    ((-int-) n) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "const float *") y) 
    ((-int-) incy) 
    (float  #{ cblas_sdot(  $n ,$x ,$incx ,$y ,$incy) #} )
)

(de cblas_ddot (    n  x  incx  y  incy )
    ((-int-) n) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-gptr- "const double *") y) 
    ((-int-) incy) 
    (double #{ cblas_ddot(  $n ,$x ,$incx ,$y ,$incy) #} )
)



(de cblas_cdotu_sub (    n  x  incx  y  incy  dotu )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") dotu) 
    #{ cblas_cdotu_sub(  $n ,$x ,$incx ,$y ,$incy ,$dotu) #} 
    ()
)

(de cblas_cdotc_sub (    n  x  incx  y  incy  dotc )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") dotc) 
    #{ cblas_cdotc_sub(  $n ,$x ,$incx ,$y ,$incy ,$dotc) #} 
    ()
)


(de cblas_zdotu_sub (    n  x  incx  y  incy  dotu )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") dotu) 
    #{ cblas_zdotu_sub(  $n ,$x ,$incx ,$y ,$incy ,$dotu) #} 
    ()
)

(de cblas_zdotc_sub (    n  x  incx  y  incy  dotc )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") dotc) 
    #{ cblas_zdotc_sub(  $n ,$x ,$incx ,$y ,$incy ,$dotc) #} 
    ()
)




(de cblas_snrm2 (    n  x  incx )
    ((-int-) n) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    (float  #{ cblas_snrm2(  $n ,$x ,$incx) #} )
)

(de cblas_sasum (    n  x  incx )
    ((-int-) n) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    (float  #{ cblas_sasum(  $n ,$x ,$incx) #} )
)


(de cblas_dnrm2 (    n  x  incx )
    ((-int-) n) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    (double #{ cblas_dnrm2(  $n ,$x ,$incx) #} )
)

(de cblas_dasum (    n  x  incx )
    ((-int-) n) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    (double #{ cblas_dasum(  $n ,$x ,$incx) #} )
)


(de cblas_scnrm2 (    n  x  incx )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    (float  #{ cblas_scnrm2(  $n ,$x ,$incx) #} )
)

(de cblas_scasum (    n   x  incx )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    (float  #{ cblas_scasum(  $n ,$x ,$incx) #} )
)


(de cblas_dznrm2 (    n   x  incx )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    (double #{ cblas_dznrm2(  $n ,$x ,$incx) #} )
)

(de cblas_dzasum (    n   x  incx )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    (double #{ cblas_dzasum(  $n ,$x ,$incx) #} )
)




(de cblas_isamax (    n   x  incx )
    ((-int-) n) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    (int #{ cblas_isamax(  $n ,$x ,$incx) #} )        ;; cblas_IndEx (size_t) -> int
)

(de cblas_idamax (    n   x  incx )
    ((-int-) n) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    (int #{ cblas_idamax(  $n ,$x ,$incx) #} )        ;; cblas_IndEx (size_t) -> int
)

(de cblas_icamax (    n   x  incx )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    (int #{ cblas_icamax(  $n ,$x ,$incx) #} )        ;; cblas_IndEx (size_t) -> int
)

(de cblas_izamax (    n   x  incx )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    (int #{ cblas_izamax(  $n ,$x ,$incx) #} )        ;; cblas_IndEx (size_t) -> int
)





(de cblas_sswap (    n   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    #{ cblas_sswap(  $n ,$x ,$incx ,$y ,$incy) #} 
    ()
)

(de cblas_scopy (    n   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    #{ cblas_scopy(  $n ,$x ,$incx ,$y ,$incy) #} 
    ()
)

(de cblas_saxpy (    n  alpha   x  incx   y  incy )
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    #{ cblas_saxpy(  $n ,$alpha ,$x ,$incx ,$y ,$incy) #} 
    ()
)


(de cblas_dswap (    n   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    #{ cblas_dswap(  $n ,$x ,$incx ,$y ,$incy) #} 
    ()
)

(de cblas_dcopy (    n   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    #{ cblas_dcopy(  $n ,$x ,$incx ,$y ,$incy) #} 
    ()
)

(de cblas_daxpy (    n  alpha   x  incx   y  incy )
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    #{ cblas_daxpy(  $n ,$alpha ,$x ,$incx ,$y ,$incy) #} 
    ()
)


(de cblas_cswap (    n   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_cswap(  $n ,$x ,$incx ,$y ,$incy) #} 
    ()
)

(de cblas_ccopy (    n   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_ccopy(  $n ,$x ,$incx ,$y ,$incy) #} 
    ()
)

(de cblas_caxpy (    n   alpha   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_caxpy(  $n ,$alpha ,$x ,$incx ,$y ,$incy) #} 
    ()
)


(de cblas_zswap (    n   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_zswap(  $n ,$x ,$incx ,$y ,$incy) #} 
    ()
)

(de cblas_zcopy (    n   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_zcopy(  $n ,$x ,$incx ,$y ,$incy) #} 
    ()
)

(de cblas_zaxpy (    n   alpha   x  incx   y  incy )
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_zaxpy(  $n ,$alpha ,$x ,$incx ,$y ,$incy) #} 
    ()
)




(de cblas_srotg (     a   b   c   s )
    ((-gptr- "float *") a) 
    ((-gptr- "float *") b) 
    ((-gptr- "float *") c) 
    ((-gptr- "float *") s) 
    #{ cblas_srotg(  $a ,$b ,$c ,$s) #} 
    ()
)

(if (not cblas-useintel)
    ;; gsl version 
    (de cblas_srotmg (     d1   d2   b1  b2   p )
      ((-gptr- "float *") d1) 
      ((-gptr- "float *") d2) 
      ((-gptr- "float *") b1) 
      ((-float-) b2) 
      ((-gptr- "float *") p) 
      #{ cblas_srotmg(  $d1 ,$d2 ,$b1 ,$b2 ,$p) #} 
      ())
  ;; else, use intel MKL version
  (de cblas_srotmg (     d1   d2   b1  b2   p )
    ((-gptr- "float *") d1) 
    ((-gptr- "float *") d2) 
    ((-gptr- "float *") b1) 
    ((-float-) b2) 
    ((-gptr- "float *") p) 
    #{ cblas_srotmg(  $d1 ,$d2 ,$b1 ,&($b2) ,$p) #} 
    ())
  (de cblas_srotmg_intel (     d1   d2   b1  b2   p )
    ((-gptr- "float *") d1) 
    ((-gptr- "float *") d2) 
    ((-gptr- "float *") b1) 
    ((-gptr- "float *") b2) 
    ((-gptr- "float *") p) 
    #{ cblas_srotmg(  $d1 ,$d2 ,$b1 ,$b2 ,$p) #} 
    ())
  )


(de cblas_srot (    n   x  incx   y  incy  c  s )
    ((-int-) n) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    ((-float-) c) 
    ((-float-) s) 
    #{ cblas_srot(  $n ,$x ,$incx ,$y ,$incy ,$c ,$s) #} 
    ()
)

(de cblas_srotm (    n   x  incx   y  incy   p )
    ((-int-) n) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    ((-gptr- "const float *") p) 
    #{ cblas_srotm(  $n ,$x ,$incx ,$y ,$incy ,$p) #} 
    ()
)


(de cblas_drotg (     a   b   c   s )
    ((-gptr- "double *") a) 
    ((-gptr- "double *") b) 
    ((-gptr- "double *") c) 
    ((-gptr- "double *") s) 
    #{ cblas_drotg(  $a ,$b ,$c ,$s) #} 
    ()
)

(if (not cblas-useintel)
    ;; gsl version
    (de cblas_drotmg (     d1   d2   b1  b2   p )
      ((-gptr- "double *") d1) 
      ((-gptr- "double *") d2) 
      ((-gptr- "double *") b1) 
      ((-double-) b2) 
      ((-gptr- "double *") p) 
      #{ cblas_drotmg(  $d1 ,$d2 ,$b1 ,$b2 ,$p) #} 
      ())
  ;; intel MKL version
  (de cblas_drotmg (     d1   d2   b1  b2   p )
    ((-gptr- "double *") d1) 
    ((-gptr- "double *") d2) 
    ((-gptr- "double *") b1) 
    ((-double-) b2) 
    ((-gptr- "double *") p) 
    #{ cblas_drotmg(  $d1 ,$d2 ,$b1 ,&($b2) ,$p) #} 
    ())
  (de cblas_drotmg_intel (     d1   d2   b1  b2   p )
    ((-gptr- "double *") d1) 
    ((-gptr- "double *") d2) 
    ((-gptr- "double *") b1) 
    ((-gptr- "double *") b2) 
    ((-gptr- "double *") p) 
    #{ cblas_drotmg(  $d1 ,$d2 ,$b1 ,$b2 ,$p) #} 
    ())
  )

(de cblas_drot (    n   x  incx   y  incy  c  s )
    ((-int-) n) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    ((-double-) c) 
    ((-double-) s) 
    #{ cblas_drot(  $n ,$x ,$incx ,$y ,$incy ,$c ,$s) #} 
    ()
)

(de cblas_drotm (    n   x  incx   y  incy   p )
    ((-int-) n) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    ((-gptr- "const double *") p) 
    #{ cblas_drotm(  $n ,$x ,$incx ,$y ,$incy ,$p) #} 
    ()
)




(de cblas_sscal (    n  alpha   x  incx )
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    #{ cblas_sscal(  $n ,$alpha ,$x ,$incx) #} 
    ()
)

(de cblas_dscal (    n  alpha   x  incx )
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    #{ cblas_dscal(  $n ,$alpha ,$x ,$incx) #} 
    ()
)

(de cblas_cscal (    n   alpha   x  incx )
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_cscal(  $n ,$alpha ,$x ,$incx) #} 
    ()
)

(de cblas_zscal (    n   alpha   x  incx )
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_zscal(  $n ,$alpha ,$x ,$incx) #} 
    ()
)

(de cblas_csscal (    n  alpha   x  incx )
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_csscal(  $n ,$alpha ,$x ,$incx) #} 
    ()
)

(de cblas_zdscal (    n  alpha   x  incx )
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_zdscal(  $n ,$alpha ,$x ,$incx) #} 
    ()
)





(de cblas_sgemv (    order  transa  m  n  alpha   a  lda   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-float-) beta) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    #{ cblas_sgemv(  $order ,$transa ,$m ,$n ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_sgbmv (    order  transa  m  n  kl  ku  alpha   a  lda   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-int-) kl) 
    ((-int-) ku) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-float-) beta) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    #{ cblas_sgbmv(  $order ,$transa ,$m ,$n ,$kl ,$ku ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_strmv (    order  uplo  transa  diag  n   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    #{ cblas_strmv(  $order ,$uplo ,$transa ,$diag ,$n ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_stbmv (    order  uplo  transa  diag  n  k   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    #{ cblas_stbmv(  $order ,$uplo ,$transa ,$diag ,$n ,$k ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_stpmv (    order  uplo  transa  diag  n   ap   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const float *") ap) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    #{ cblas_stpmv(  $order ,$uplo ,$transa ,$diag ,$n ,$ap ,$x ,$incx) #} 
    ()
)

(de cblas_strsv (    order  uplo  transa  diag  n   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    #{ cblas_strsv(  $order ,$uplo ,$transa ,$diag ,$n ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_stbsv (    order  uplo  transa  diag  n  k   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    #{ cblas_stbsv(  $order ,$uplo ,$transa ,$diag ,$n ,$k ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_stpsv (    order  uplo  transa  diag  n   ap   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const float *") ap) 
    ((-gptr- "float *") x) 
    ((-int-) incx) 
    #{ cblas_stpsv(  $order ,$uplo ,$transa ,$diag ,$n ,$ap ,$x ,$incx) #} 
    ()
)


(de cblas_dgemv (    order  transa  m  n  alpha   a  lda   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-double-) beta) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    #{ cblas_dgemv(  $order ,$transa ,$m ,$n ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_dgbmv (    order  transa  m  n  kl  ku  alpha   a  lda   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-int-) kl) 
    ((-int-) ku) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-double-) beta) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    #{ cblas_dgbmv(  $order ,$transa ,$m ,$n ,$kl ,$ku ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_dtrmv (    order  uplo  transa  diag  n   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    #{ cblas_dtrmv(  $order ,$uplo ,$transa ,$diag ,$n ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_dtbmv (    order  uplo  transa  diag  n  k   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    #{ cblas_dtbmv(  $order ,$uplo ,$transa ,$diag ,$n ,$k ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_dtpmv (    order  uplo  transa  diag  n   ap   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const double *") ap) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    #{ cblas_dtpmv(  $order ,$uplo ,$transa ,$diag ,$n ,$ap ,$x ,$incx) #} 
    ()
)

(de cblas_dtrsv (    order  uplo  transa  diag  n   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    #{ cblas_dtrsv(  $order ,$uplo ,$transa ,$diag ,$n ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_dtbsv (    order  uplo  transa  diag  n  k   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    #{ cblas_dtbsv(  $order ,$uplo ,$transa ,$diag ,$n ,$k ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_dtpsv (    order  uplo  transa  diag  n   ap   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const double *") ap) 
    ((-gptr- "double *") x) 
    ((-int-) incx) 
    #{ cblas_dtpsv(  $order ,$uplo ,$transa ,$diag ,$n ,$ap ,$x ,$incx) #} 
    ()
)


(de cblas_cgemv (    order  transa  m  n   alpha   a  lda   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_cgemv(  $order ,$transa ,$m ,$n ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_cgbmv (    order  transa  m  n  kl  ku   alpha   a  lda   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-int-) kl) 
    ((-int-) ku) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_cgbmv(  $order ,$transa ,$m ,$n ,$kl ,$ku ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_ctrmv (    order  uplo  transa  diag  n   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ctrmv(  $order ,$uplo ,$transa ,$diag ,$n ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_ctbmv (    order  uplo  transa  diag  n  k   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ctbmv(  $order ,$uplo ,$transa ,$diag ,$n ,$k ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_ctpmv (    order  uplo  transa  diag  n   ap   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const void *") ap) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ctpmv(  $order ,$uplo ,$transa ,$diag ,$n ,$ap ,$x ,$incx) #} 
    ()
)

(de cblas_ctrsv (    order  uplo  transa  diag  n   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ctrsv(  $order ,$uplo ,$transa ,$diag ,$n ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_ctbsv (    order  uplo  transa  diag  n  k   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ctbsv(  $order ,$uplo ,$transa ,$diag ,$n ,$k ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_ctpsv (    order  uplo  transa  diag  n   ap   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const void *") ap) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ctpsv(  $order ,$uplo ,$transa ,$diag ,$n ,$ap ,$x ,$incx) #} 
    ()
)


(de cblas_zgemv (    order  transa  m  n   alpha   a  lda   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_zgemv(  $order ,$transa ,$m ,$n ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_zgbmv (    order  transa  m  n  kl  ku   alpha   a  lda   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-int-) kl) 
    ((-int-) ku) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_zgbmv(  $order ,$transa ,$m ,$n ,$kl ,$ku ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_ztrmv (    order  uplo  transa  diag  n   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ztrmv(  $order ,$uplo ,$transa ,$diag ,$n ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_ztbmv (    order  uplo  transa  diag  n  k   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ztbmv(  $order ,$uplo ,$transa ,$diag ,$n ,$k ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_ztpmv (    order  uplo  transa  diag  n   ap   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const void *") ap) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ztpmv(  $order ,$uplo ,$transa ,$diag ,$n ,$ap ,$x ,$incx) #} 
    ()
)

(de cblas_ztrsv (    order  uplo  transa  diag  n   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ztrsv(  $order ,$uplo ,$transa ,$diag ,$n ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_ztbsv (    order  uplo  transa  diag  n  k   a  lda   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ztbsv(  $order ,$uplo ,$transa ,$diag ,$n ,$k ,$a ,$lda ,$x ,$incx) #} 
    ()
)

(de cblas_ztpsv (    order  uplo  transa  diag  n   ap   x  incx )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) n) 
    ((-gptr- "const void *") ap) 
    ((-gptr- "void *") x) 
    ((-int-) incx) 
    #{ cblas_ztpsv(  $order ,$uplo ,$transa ,$diag ,$n ,$ap ,$x ,$incx) #} 
    ()
)




(de cblas_ssymv (    order  uplo  n  alpha   a  lda   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-float-) beta) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    #{ cblas_ssymv(  $order ,$uplo ,$n ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_ssbmv (    order  uplo  n  k  alpha   a  lda   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-float-) beta) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    #{ cblas_ssbmv(  $order ,$uplo ,$n ,$k ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_sspmv (    order  uplo  n  alpha   ap   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") ap) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-float-) beta) 
    ((-gptr- "float *") y) 
    ((-int-) incy) 
    #{ cblas_sspmv(  $order ,$uplo ,$n ,$alpha ,$ap ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_sger (    order  m  n  alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "const float *") y) 
    ((-int-) incy) 
    ((-gptr- "float *") a) 
    ((-int-) lda) 
    #{ cblas_sger(  $order ,$m ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_ssyr (    order  uplo  n  alpha   x  incx   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "float *") a) 
    ((-int-) lda) 
    #{ cblas_ssyr(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$a ,$lda) #} 
    ()
)

(de cblas_sspr (    order  uplo  n  alpha   x  incx   ap )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "float *") ap) 
    #{ cblas_sspr(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$ap) #} 
    ()
)

(de cblas_ssyr2 (    order  uplo  n  alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "const float *") y) 
    ((-int-) incy) 
    ((-gptr- "float *") a) 
    ((-int-) lda) 
    #{ cblas_ssyr2(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_sspr2 (    order  uplo  n  alpha   x  incx   y  incy   a )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") x) 
    ((-int-) incx) 
    ((-gptr- "const float *") y) 
    ((-int-) incy) 
    ((-gptr- "float *") a) 
    #{ cblas_sspr2(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a) #} 
    ()
)


(de cblas_dsymv (    order  uplo  n  alpha   a  lda   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-double-) beta) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    #{ cblas_dsymv(  $order ,$uplo ,$n ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_dsbmv (    order  uplo  n  k  alpha   a  lda   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-double-) beta) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    #{ cblas_dsbmv(  $order ,$uplo ,$n ,$k ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_dspmv (    order  uplo  n  alpha   ap   x  incx  beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") ap) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-double-) beta) 
    ((-gptr- "double *") y) 
    ((-int-) incy) 
    #{ cblas_dspmv(  $order ,$uplo ,$n ,$alpha ,$ap ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_dger (    order  m  n  alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-gptr- "const double *") y) 
    ((-int-) incy) 
    ((-gptr- "double *") a) 
    ((-int-) lda) 
    #{ cblas_dger(  $order ,$m ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_dsyr (    order  uplo  n  alpha   x  incx   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-gptr- "double *") a) 
    ((-int-) lda) 
    #{ cblas_dsyr(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$a ,$lda) #} 
    ()
)

(de cblas_dspr (    order  uplo  n  alpha   x  incx   ap )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-gptr- "double *") ap) 
    #{ cblas_dspr(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$ap) #} 
    ()
)

(de cblas_dsyr2 (    order  uplo  n  alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-gptr- "const double *") y) 
    ((-int-) incy) 
    ((-gptr- "double *") a) 
    ((-int-) lda) 
    #{ cblas_dsyr2(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_dspr2 (    order  uplo  n  alpha   x  incx   y  incy   a )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") x) 
    ((-int-) incx) 
    ((-gptr- "const double *") y) 
    ((-int-) incy) 
    ((-gptr- "double *") a) 
    #{ cblas_dspr2(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a) #} 
    ()
)




(de cblas_chemv (    order  uplo  n   alpha   a  lda   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_chemv(  $order ,$uplo ,$n ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_chbmv (    order  uplo  n  k   alpha   a  lda   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_chbmv(  $order ,$uplo ,$n ,$k ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_chpmv (    order  uplo  n   alpha   ap   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") ap) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_chpmv(  $order ,$uplo ,$n ,$alpha ,$ap ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_cgeru (    order  m  n   alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") a) 
    ((-int-) lda) 
    #{ cblas_cgeru(  $order ,$m ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_cgerc (    order  m  n   alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") a) 
    ((-int-) lda) 
    #{ cblas_cgerc(  $order ,$m ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_cher (    order  uplo  n  alpha   x  incx   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") a) 
    ((-int-) lda) 
    #{ cblas_cher(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$a ,$lda) #} 
    ()
)

(de cblas_chpr (    order  uplo  n  alpha   x  incx   a )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") a) 
    #{ cblas_chpr(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$a) #} 
    ()
)

(de cblas_cher2 (    order  uplo  n   alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") a) 
    ((-int-) lda) 
    #{ cblas_cher2(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_chpr2 (    order  uplo  n   alpha   x  incx   y  incy   ap )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") ap) 
    #{ cblas_chpr2(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$ap) #} 
    ()
)


(de cblas_zhemv (    order  uplo  n   alpha   a  lda   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_zhemv(  $order ,$uplo ,$n ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_zhbmv (    order  uplo  n  k   alpha   a  lda   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_zhbmv(  $order ,$uplo ,$n ,$k ,$alpha ,$a ,$lda ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_zhpmv (    order  uplo  n   alpha   ap   x  incx   beta   y  incy )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") ap) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") y) 
    ((-int-) incy) 
    #{ cblas_zhpmv(  $order ,$uplo ,$n ,$alpha ,$ap ,$x ,$incx ,$beta ,$y ,$incy) #} 
    ()
)

(de cblas_zgeru (    order  m  n   alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") a) 
    ((-int-) lda) 
    #{ cblas_zgeru(  $order ,$m ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_zgerc (    order  m  n   alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") a) 
    ((-int-) lda) 
    #{ cblas_zgerc(  $order ,$m ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_zher (    order  uplo  n  alpha   x  incx   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") a) 
    ((-int-) lda) 
    #{ cblas_zher(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$a ,$lda) #} 
    ()
)

(de cblas_zhpr (    order  uplo  n  alpha   x  incx   a )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "void *") a) 
    #{ cblas_zhpr(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$a) #} 
    ()
)

(de cblas_zher2 (    order  uplo  n   alpha   x  incx   y  incy   a  lda )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") a) 
    ((-int-) lda) 
    #{ cblas_zher2(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$a ,$lda) #} 
    ()
)

(de cblas_zhpr2 (    order  uplo  n   alpha   x  incx   y  incy   ap )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") x) 
    ((-int-) incx) 
    ((-gptr- "const void *") y) 
    ((-int-) incy) 
    ((-gptr- "void *") ap) 
    #{ cblas_zhpr2(  $order ,$uplo ,$n ,$alpha ,$x ,$incx ,$y ,$incy ,$ap) #} 
    ()
)





(de cblas_sgemm (    order  transa  transb  m  n  k  alpha   a  lda   b  ldb  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) transb)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-int-) k) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "const float *") b) 
    ((-int-) ldb) 
    ((-float-) beta) 
    ((-gptr- "float *") c) 
    ((-int-) ldc) 
    #{ cblas_sgemm(  $order ,$transa ,$transb ,$m ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_ssymm (    order  side  uplo  m  n  alpha   a  lda   b  ldb  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "const float *") b) 
    ((-int-) ldb) 
    ((-float-) beta) 
    ((-gptr- "float *") c) 
    ((-int-) ldc) 
    #{ cblas_ssymm(  $order ,$side ,$uplo ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_ssyrk (    order  uplo  trans  n  k  alpha   a  lda  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-float-) beta) 
    ((-gptr- "float *") c) 
    ((-int-) ldc) 
    #{ cblas_ssyrk(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_ssyr2k (    order  uplo  trans  n  k  alpha   a  lda   b  ldb  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "const float *") b) 
    ((-int-) ldb) 
    ((-float-) beta) 
    ((-gptr- "float *") c) 
    ((-int-) ldc) 
    #{ cblas_ssyr2k(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_strmm (    order  side  uplo  transa  diag  m  n  alpha   a  lda   b  ldb )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "float *") b) 
    ((-int-) ldb) 
    #{ cblas_strmm(  $order ,$side ,$uplo ,$transa ,$diag ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb) #} 
    ()
)

(de cblas_strsm (    order  side  uplo  transa  diag  m  n  alpha   a  lda   b  ldb )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-float-) alpha) 
    ((-gptr- "const float *") a) 
    ((-int-) lda) 
    ((-gptr- "float *") b) 
    ((-int-) ldb) 
    #{ cblas_strsm(  $order ,$side ,$uplo ,$transa ,$diag ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb) #} 
    ()
)


(de cblas_dgemm (    order  transa  transb  m  n  k  alpha   a  lda   b  ldb  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) transb)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-int-) k) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "const double *") b) 
    ((-int-) ldb) 
    ((-double-) beta) 
    ((-gptr- "double *") c) 
    ((-int-) ldc) 
    #{ cblas_dgemm(  $order ,$transa ,$transb ,$m ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_dsymm (    order  side  uplo  m  n  alpha   a  lda   b  ldb  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "const double *") b) 
    ((-int-) ldb) 
    ((-double-) beta) 
    ((-gptr- "double *") c) 
    ((-int-) ldc) 
    #{ cblas_dsymm(  $order ,$side ,$uplo ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_dsyrk (    order  uplo  trans  n  k  alpha   a  lda  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-double-) beta) 
    ((-gptr- "double *") c) 
    ((-int-) ldc) 
    #{ cblas_dsyrk(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_dsyr2k (    order  uplo  trans  n  k  alpha   a  lda   b  ldb  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "const double *") b) 
    ((-int-) ldb) 
    ((-double-) beta) 
    ((-gptr- "double *") c) 
    ((-int-) ldc) 
    #{ cblas_dsyr2k(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_dtrmm (    order  side  uplo  transa  diag  m  n  alpha   a  lda   b  ldb )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "double *") b) 
    ((-int-) ldb) 
    #{ cblas_dtrmm(  $order ,$side ,$uplo ,$transa ,$diag ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb) #} 
    ()
)

(de cblas_dtrsm (    order  side  uplo  transa  diag  m  n  alpha   a  lda   b  ldb )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-double-) alpha) 
    ((-gptr- "const double *") a) 
    ((-int-) lda) 
    ((-gptr- "double *") b) 
    ((-int-) ldb) 
    #{ cblas_dtrsm(  $order ,$side ,$uplo ,$transa ,$diag ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb) #} 
    ()
)


(de cblas_cgemm (    order  transa  transb  m  n  k   alpha   a  lda   b  ldb   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) transb)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_cgemm(  $order ,$transa ,$transb ,$m ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_csymm (    order  side  uplo  m  n   alpha   a  lda   b  ldb   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_csymm(  $order ,$side ,$uplo ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_csyrk (    order  uplo  trans  n  k   alpha   a  lda   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_csyrk(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_csyr2k (    order  uplo  trans  n  k   alpha   a  lda   b  ldb   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_csyr2k(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_ctrmm (    order  side  uplo  transa  diag  m  n   alpha   a  lda   b  ldb )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") b) 
    ((-int-) ldb) 
    #{ cblas_ctrmm(  $order ,$side ,$uplo ,$transa ,$diag ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb) #} 
    ()
)

(de cblas_ctrsm (    order  side  uplo  transa  diag  m  n   alpha   a  lda   b  ldb )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") b) 
    ((-int-) ldb) 
    #{ cblas_ctrsm(  $order ,$side ,$uplo ,$transa ,$diag ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb) #} 
    ()
)


(de cblas_zgemm (    order  transa  transb  m  n  k   alpha   a  lda   b  ldb   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) transb)                          ;; enum cblas_tRansposE -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_zgemm(  $order ,$transa ,$transb ,$m ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_zsymm (    order  side  uplo  m  n   alpha   a  lda   b  ldb   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_zsymm(  $order ,$side ,$uplo ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_zsyrk (    order  uplo  trans  n  k   alpha   a  lda   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_zsyrk(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_zsyr2k (    order  uplo  trans  n  k   alpha   a  lda   b  ldb   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_zsyr2k(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_ztrmm (    order  side  uplo  transa  diag  m  n   alpha   a  lda   b  ldb )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") b) 
    ((-int-) ldb) 
    #{ cblas_ztrmm(  $order ,$side ,$uplo ,$transa ,$diag ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb) #} 
    ()
)

(de cblas_ztrsm (    order  side  uplo  transa  diag  m  n   alpha   a  lda   b  ldb )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) transa)                          ;; enum cblas_tRansposE -> int
    ((-int-) diag)                          ;; enum cblas_dIaG -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "void *") b) 
    ((-int-) ldb) 
    #{ cblas_ztrsm(  $order ,$side ,$uplo ,$transa ,$diag ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb) #} 
    ()
)




(de cblas_chemm (    order  side  uplo  m  n   alpha   a  lda   b  ldb   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_chemm(  $order ,$side ,$uplo ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_cherk (    order  uplo  trans  n  k  alpha   a  lda  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-float-) alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-float-) beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_cherk(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_cher2k (    order  uplo  trans  n  k   alpha   a  lda   b  ldb  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-float-) beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_cher2k(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)


(de cblas_zhemm (    order  side  uplo  m  n   alpha   a  lda   b  ldb   beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) side)                          ;; enum cblas_sIdE -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) m) 
    ((-int-) n) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-gptr- "const void *") beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_zhemm(  $order ,$side ,$uplo ,$m ,$n ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_zherk (    order  uplo  trans  n  k  alpha   a  lda  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-double-) alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-double-) beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_zherk(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$beta ,$c ,$ldc) #} 
    ()
)

(de cblas_zher2k (    order  uplo  trans  n  k   alpha   a  lda   b  ldb  beta   c  ldc )
    ((-int-) order)                          ;; enum cblas_oRdER -> int
    ((-int-) uplo)                          ;; enum cblas_uplo -> int
    ((-int-) trans)                          ;; enum cblas_tRansposE -> int
    ((-int-) n) 
    ((-int-) k) 
    ((-gptr- "const void *") alpha) 
    ((-gptr- "const void *") a) 
    ((-int-) lda) 
    ((-gptr- "const void *") b) 
    ((-int-) ldb) 
    ((-double-) beta) 
    ((-gptr- "void *") c) 
    ((-int-) ldc) 
    #{ cblas_zher2k(  $order ,$uplo ,$trans ,$n ,$k ,$alpha ,$a ,$lda ,$b ,$ldb ,$beta ,$c ,$ldc) #} 
    ()
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defvar cblas-funclist 
  '("cblas_sdsdot" "cblas_dsdot" "cblas_sdot" "cblas_ddot" 
    "cblas_cdotu_sub" "cblas_cdotc_sub" "cblas_zdotu_sub" "cblas_zdotc_sub" 
    "cblas_snrm2" "cblas_sasum" "cblas_dnrm2" "cblas_dasum"
    "cblas_scnrm2" "cblas_scasum" "cblas_dznrm2" "cblas_dzasum"
    "cblas_isamax" "cblas_idamax" "cblas_icamax" "cblas_izamax"
    "cblas_sswap" "cblas_scopy" "cblas_saxpy" "cblas_dswap"
    "cblas_dcopy" "cblas_daxpy" "cblas_cswap" "cblas_ccopy"
    "cblas_caxpy" "cblas_zswap" "cblas_zcopy" "cblas_zaxpy"
    "cblas_srotg" "cblas_srotmg" "cblas_srot" "cblas_srotm"
    "cblas_drotg" "cblas_drotmg" "cblas_drot" "cblas_drotm"
    "cblas_sscal" "cblas_dscal" "cblas_cscal" "cblas_zscal"
    "cblas_csscal" "cblas_zdscal" "cblas_sgemv" "cblas_sgbmv"
    "cblas_strmv" "cblas_stbmv" "cblas_stpmv" "cblas_strsv"
    "cblas_stbsv" "cblas_stpsv" "cblas_dgemv" "cblas_dgbmv"
    "cblas_dtrmv" "cblas_dtbmv" "cblas_dtpmv" "cblas_dtrsv"
    "cblas_dtbsv" "cblas_dtpsv" "cblas_cgemv" "cblas_cgbmv"
    "cblas_ctrmv" "cblas_ctbmv" "cblas_ctpmv" "cblas_ctrsv"
    "cblas_ctbsv" "cblas_ctpsv" "cblas_zgemv" "cblas_zgbmv"
    "cblas_ztrmv" "cblas_ztbmv" "cblas_ztpmv" "cblas_ztrsv"
    "cblas_ztbsv" "cblas_ztpsv" "cblas_ssymv" "cblas_ssbmv"
    "cblas_sspmv" "cblas_sger" "cblas_ssyr" "cblas_sspr"
    "cblas_ssyr2" "cblas_sspr2" "cblas_dsymv" "cblas_dsbmv"
    "cblas_dspmv" "cblas_dger" "cblas_dsyr" "cblas_dspr"
    "cblas_dsyr2" "cblas_dspr2" "cblas_chemv" "cblas_chbmv"
    "cblas_chpmv" "cblas_cgeru" "cblas_cgerc" "cblas_cher"
    "cblas_chpr" "cblas_cher2" "cblas_chpr2" "cblas_zhemv"
    "cblas_zhbmv" "cblas_zhpmv" "cblas_zgeru" "cblas_zgerc"
    "cblas_zher" "cblas_zhpr" "cblas_zher2" "cblas_zhpr2"
    "cblas_sgemm" "cblas_ssymm" "cblas_ssyrk" "cblas_ssyr2k"
    "cblas_strmm" "cblas_strsm" "cblas_dgemm" "cblas_dsymm"
    "cblas_dsyrk" "cblas_dsyr2k" "cblas_dtrmm" "cblas_dtrsm"
    "cblas_cgemm" "cblas_csymm" "cblas_csyrk" "cblas_csyr2k"
    "cblas_ctrmm" "cblas_ctrsm" "cblas_zgemm" "cblas_zsymm"
    "cblas_zsyrk" "cblas_zsyr2k" "cblas_ztrmm" "cblas_ztrsm"
    "cblas_chemm" "cblas_cherk" "cblas_cher2k" "cblas_zhemm"
    "cblas_zherk" "cblas_zher2k"))

(dhc-make-all 
 ()
 (mapcar namedclean (mapcar downcase (append '("cblas-dummy") cblas-funclist )))
 cblas-libcblas)



