1423 lines
63 KiB
Cython
1423 lines
63 KiB
Cython
# This file was generated by _generate_pyx.py.
|
|
# Do not edit this file directly.
|
|
# cython: boundscheck = False
|
|
# cython: wraparound = False
|
|
# cython: cdivision = True
|
|
|
|
"""
|
|
BLAS Functions for Cython
|
|
=========================
|
|
|
|
Usable from Cython via::
|
|
|
|
cimport scipy.linalg.cython_blas
|
|
|
|
These wrappers do not check for alignment of arrays.
|
|
Alignment should be checked before these wrappers are used.
|
|
|
|
Raw function pointers (Fortran-style pointer arguments):
|
|
|
|
- caxpy
|
|
- ccopy
|
|
- cdotc
|
|
- cdotu
|
|
- cgbmv
|
|
- cgemm
|
|
- cgemv
|
|
- cgerc
|
|
- cgeru
|
|
- chbmv
|
|
- chemm
|
|
- chemv
|
|
- cher
|
|
- cher2
|
|
- cher2k
|
|
- cherk
|
|
- chpmv
|
|
- chpr
|
|
- chpr2
|
|
- crotg
|
|
- cscal
|
|
- csrot
|
|
- csscal
|
|
- cswap
|
|
- csymm
|
|
- csyr2k
|
|
- csyrk
|
|
- ctbmv
|
|
- ctbsv
|
|
- ctpmv
|
|
- ctpsv
|
|
- ctrmm
|
|
- ctrmv
|
|
- ctrsm
|
|
- ctrsv
|
|
- dasum
|
|
- daxpy
|
|
- dcabs1
|
|
- dcopy
|
|
- ddot
|
|
- dgbmv
|
|
- dgemm
|
|
- dgemv
|
|
- dger
|
|
- dnrm2
|
|
- drot
|
|
- drotg
|
|
- drotm
|
|
- drotmg
|
|
- dsbmv
|
|
- dscal
|
|
- dsdot
|
|
- dspmv
|
|
- dspr
|
|
- dspr2
|
|
- dswap
|
|
- dsymm
|
|
- dsymv
|
|
- dsyr
|
|
- dsyr2
|
|
- dsyr2k
|
|
- dsyrk
|
|
- dtbmv
|
|
- dtbsv
|
|
- dtpmv
|
|
- dtpsv
|
|
- dtrmm
|
|
- dtrmv
|
|
- dtrsm
|
|
- dtrsv
|
|
- dzasum
|
|
- dznrm2
|
|
- icamax
|
|
- idamax
|
|
- isamax
|
|
- izamax
|
|
- lsame
|
|
- sasum
|
|
- saxpy
|
|
- scasum
|
|
- scnrm2
|
|
- scopy
|
|
- sdot
|
|
- sdsdot
|
|
- sgbmv
|
|
- sgemm
|
|
- sgemv
|
|
- sger
|
|
- snrm2
|
|
- srot
|
|
- srotg
|
|
- srotm
|
|
- srotmg
|
|
- ssbmv
|
|
- sscal
|
|
- sspmv
|
|
- sspr
|
|
- sspr2
|
|
- sswap
|
|
- ssymm
|
|
- ssymv
|
|
- ssyr
|
|
- ssyr2
|
|
- ssyr2k
|
|
- ssyrk
|
|
- stbmv
|
|
- stbsv
|
|
- stpmv
|
|
- stpsv
|
|
- strmm
|
|
- strmv
|
|
- strsm
|
|
- strsv
|
|
- zaxpy
|
|
- zcopy
|
|
- zdotc
|
|
- zdotu
|
|
- zdrot
|
|
- zdscal
|
|
- zgbmv
|
|
- zgemm
|
|
- zgemv
|
|
- zgerc
|
|
- zgeru
|
|
- zhbmv
|
|
- zhemm
|
|
- zhemv
|
|
- zher
|
|
- zher2
|
|
- zher2k
|
|
- zherk
|
|
- zhpmv
|
|
- zhpr
|
|
- zhpr2
|
|
- zrotg
|
|
- zscal
|
|
- zswap
|
|
- zsymm
|
|
- zsyr2k
|
|
- zsyrk
|
|
- ztbmv
|
|
- ztbsv
|
|
- ztpmv
|
|
- ztpsv
|
|
- ztrmm
|
|
- ztrmv
|
|
- ztrsm
|
|
- ztrsv
|
|
|
|
|
|
"""
|
|
|
|
# Within SciPy, these wrappers can be used via relative or absolute cimport.
|
|
# Examples:
|
|
# from ..linalg cimport cython_blas
|
|
# from scipy.linalg cimport cython_blas
|
|
# cimport scipy.linalg.cython_blas as cython_blas
|
|
# cimport ..linalg.cython_blas as cython_blas
|
|
|
|
# Within SciPy, if BLAS functions are needed in C/C++/Fortran,
|
|
# these wrappers should not be used.
|
|
# The original libraries should be linked directly.
|
|
|
|
cdef extern from "fortran_defs.h":
|
|
pass
|
|
|
|
from numpy cimport npy_complex64, npy_complex128
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_caxpy "BLAS_FUNC(caxpy)"(int *n, npy_complex64 *ca, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil
|
|
cdef void caxpy(int *n, c *ca, c *cx, int *incx, c *cy, int *incy) noexcept nogil:
|
|
|
|
_fortran_caxpy(n, <npy_complex64*>ca, <npy_complex64*>cx, incx, <npy_complex64*>cy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ccopy "BLAS_FUNC(ccopy)"(int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil
|
|
cdef void ccopy(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil:
|
|
|
|
_fortran_ccopy(n, <npy_complex64*>cx, incx, <npy_complex64*>cy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cdotc "(cdotcwrp_)"(npy_complex64 *out, int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil
|
|
cdef c cdotc(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil:
|
|
cdef c out
|
|
_fortran_cdotc(<npy_complex64*>&out, n, <npy_complex64*>cx, incx, <npy_complex64*>cy, incy)
|
|
return out
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cdotu "(cdotuwrp_)"(npy_complex64 *out, int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil
|
|
cdef c cdotu(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil:
|
|
cdef c out
|
|
_fortran_cdotu(<npy_complex64*>&out, n, <npy_complex64*>cx, incx, <npy_complex64*>cy, incy)
|
|
return out
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cgbmv "BLAS_FUNC(cgbmv)"(char *trans, int *m, int *n, int *kl, int *ku, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil
|
|
cdef void cgbmv(char *trans, int *m, int *n, int *kl, int *ku, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_cgbmv(trans, m, n, kl, ku, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>x, incx, <npy_complex64*>beta, <npy_complex64*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cgemm "BLAS_FUNC(cgemm)"(char *transa, char *transb, int *m, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil
|
|
cdef void cgemm(char *transa, char *transb, int *m, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_cgemm(transa, transb, m, n, k, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>b, ldb, <npy_complex64*>beta, <npy_complex64*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cgemv "BLAS_FUNC(cgemv)"(char *trans, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil
|
|
cdef void cgemv(char *trans, int *m, int *n, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_cgemv(trans, m, n, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>x, incx, <npy_complex64*>beta, <npy_complex64*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cgerc "BLAS_FUNC(cgerc)"(int *m, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, npy_complex64 *a, int *lda) nogil
|
|
cdef void cgerc(int *m, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_cgerc(m, n, <npy_complex64*>alpha, <npy_complex64*>x, incx, <npy_complex64*>y, incy, <npy_complex64*>a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cgeru "BLAS_FUNC(cgeru)"(int *m, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, npy_complex64 *a, int *lda) nogil
|
|
cdef void cgeru(int *m, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_cgeru(m, n, <npy_complex64*>alpha, <npy_complex64*>x, incx, <npy_complex64*>y, incy, <npy_complex64*>a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_chbmv "BLAS_FUNC(chbmv)"(char *uplo, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil
|
|
cdef void chbmv(char *uplo, int *n, int *k, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_chbmv(uplo, n, k, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>x, incx, <npy_complex64*>beta, <npy_complex64*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_chemm "BLAS_FUNC(chemm)"(char *side, char *uplo, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil
|
|
cdef void chemm(char *side, char *uplo, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_chemm(side, uplo, m, n, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>b, ldb, <npy_complex64*>beta, <npy_complex64*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_chemv "BLAS_FUNC(chemv)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil
|
|
cdef void chemv(char *uplo, int *n, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_chemv(uplo, n, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>x, incx, <npy_complex64*>beta, <npy_complex64*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cher "BLAS_FUNC(cher)"(char *uplo, int *n, s *alpha, npy_complex64 *x, int *incx, npy_complex64 *a, int *lda) nogil
|
|
cdef void cher(char *uplo, int *n, s *alpha, c *x, int *incx, c *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_cher(uplo, n, alpha, <npy_complex64*>x, incx, <npy_complex64*>a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cher2 "BLAS_FUNC(cher2)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, npy_complex64 *a, int *lda) nogil
|
|
cdef void cher2(char *uplo, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_cher2(uplo, n, <npy_complex64*>alpha, <npy_complex64*>x, incx, <npy_complex64*>y, incy, <npy_complex64*>a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cher2k "BLAS_FUNC(cher2k)"(char *uplo, char *trans, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, s *beta, npy_complex64 *c, int *ldc) nogil
|
|
cdef void cher2k(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, s *beta, c *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_cher2k(uplo, trans, n, k, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>b, ldb, beta, <npy_complex64*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cherk "BLAS_FUNC(cherk)"(char *uplo, char *trans, int *n, int *k, s *alpha, npy_complex64 *a, int *lda, s *beta, npy_complex64 *c, int *ldc) nogil
|
|
cdef void cherk(char *uplo, char *trans, int *n, int *k, s *alpha, c *a, int *lda, s *beta, c *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_cherk(uplo, trans, n, k, alpha, <npy_complex64*>a, lda, beta, <npy_complex64*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_chpmv "BLAS_FUNC(chpmv)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *ap, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil
|
|
cdef void chpmv(char *uplo, int *n, c *alpha, c *ap, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_chpmv(uplo, n, <npy_complex64*>alpha, <npy_complex64*>ap, <npy_complex64*>x, incx, <npy_complex64*>beta, <npy_complex64*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_chpr "BLAS_FUNC(chpr)"(char *uplo, int *n, s *alpha, npy_complex64 *x, int *incx, npy_complex64 *ap) nogil
|
|
cdef void chpr(char *uplo, int *n, s *alpha, c *x, int *incx, c *ap) noexcept nogil:
|
|
|
|
_fortran_chpr(uplo, n, alpha, <npy_complex64*>x, incx, <npy_complex64*>ap)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_chpr2 "BLAS_FUNC(chpr2)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, npy_complex64 *ap) nogil
|
|
cdef void chpr2(char *uplo, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *ap) noexcept nogil:
|
|
|
|
_fortran_chpr2(uplo, n, <npy_complex64*>alpha, <npy_complex64*>x, incx, <npy_complex64*>y, incy, <npy_complex64*>ap)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_crotg "BLAS_FUNC(crotg)"(npy_complex64 *ca, npy_complex64 *cb, s *c, npy_complex64 *s) nogil
|
|
cdef void crotg(c *ca, c *cb, s *c, c *s) noexcept nogil:
|
|
|
|
_fortran_crotg(<npy_complex64*>ca, <npy_complex64*>cb, c, <npy_complex64*>s)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cscal "BLAS_FUNC(cscal)"(int *n, npy_complex64 *ca, npy_complex64 *cx, int *incx) nogil
|
|
cdef void cscal(int *n, c *ca, c *cx, int *incx) noexcept nogil:
|
|
|
|
_fortran_cscal(n, <npy_complex64*>ca, <npy_complex64*>cx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_csrot "BLAS_FUNC(csrot)"(int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy, s *c, s *s) nogil
|
|
cdef void csrot(int *n, c *cx, int *incx, c *cy, int *incy, s *c, s *s) noexcept nogil:
|
|
|
|
_fortran_csrot(n, <npy_complex64*>cx, incx, <npy_complex64*>cy, incy, c, s)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_csscal "BLAS_FUNC(csscal)"(int *n, s *sa, npy_complex64 *cx, int *incx) nogil
|
|
cdef void csscal(int *n, s *sa, c *cx, int *incx) noexcept nogil:
|
|
|
|
_fortran_csscal(n, sa, <npy_complex64*>cx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_cswap "BLAS_FUNC(cswap)"(int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil
|
|
cdef void cswap(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil:
|
|
|
|
_fortran_cswap(n, <npy_complex64*>cx, incx, <npy_complex64*>cy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_csymm "BLAS_FUNC(csymm)"(char *side, char *uplo, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil
|
|
cdef void csymm(char *side, char *uplo, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_csymm(side, uplo, m, n, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>b, ldb, <npy_complex64*>beta, <npy_complex64*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_csyr2k "BLAS_FUNC(csyr2k)"(char *uplo, char *trans, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil
|
|
cdef void csyr2k(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_csyr2k(uplo, trans, n, k, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>b, ldb, <npy_complex64*>beta, <npy_complex64*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_csyrk "BLAS_FUNC(csyrk)"(char *uplo, char *trans, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil
|
|
cdef void csyrk(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *beta, c *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_csyrk(uplo, trans, n, k, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>beta, <npy_complex64*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ctbmv "BLAS_FUNC(ctbmv)"(char *uplo, char *trans, char *diag, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx) nogil
|
|
cdef void ctbmv(char *uplo, char *trans, char *diag, int *n, int *k, c *a, int *lda, c *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ctbmv(uplo, trans, diag, n, k, <npy_complex64*>a, lda, <npy_complex64*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ctbsv "BLAS_FUNC(ctbsv)"(char *uplo, char *trans, char *diag, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx) nogil
|
|
cdef void ctbsv(char *uplo, char *trans, char *diag, int *n, int *k, c *a, int *lda, c *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ctbsv(uplo, trans, diag, n, k, <npy_complex64*>a, lda, <npy_complex64*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ctpmv "BLAS_FUNC(ctpmv)"(char *uplo, char *trans, char *diag, int *n, npy_complex64 *ap, npy_complex64 *x, int *incx) nogil
|
|
cdef void ctpmv(char *uplo, char *trans, char *diag, int *n, c *ap, c *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ctpmv(uplo, trans, diag, n, <npy_complex64*>ap, <npy_complex64*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ctpsv "BLAS_FUNC(ctpsv)"(char *uplo, char *trans, char *diag, int *n, npy_complex64 *ap, npy_complex64 *x, int *incx) nogil
|
|
cdef void ctpsv(char *uplo, char *trans, char *diag, int *n, c *ap, c *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ctpsv(uplo, trans, diag, n, <npy_complex64*>ap, <npy_complex64*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ctrmm "BLAS_FUNC(ctrmm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb) nogil
|
|
cdef void ctrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb) noexcept nogil:
|
|
|
|
_fortran_ctrmm(side, uplo, transa, diag, m, n, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>b, ldb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ctrmv "BLAS_FUNC(ctrmv)"(char *uplo, char *trans, char *diag, int *n, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx) nogil
|
|
cdef void ctrmv(char *uplo, char *trans, char *diag, int *n, c *a, int *lda, c *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ctrmv(uplo, trans, diag, n, <npy_complex64*>a, lda, <npy_complex64*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ctrsm "BLAS_FUNC(ctrsm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb) nogil
|
|
cdef void ctrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb) noexcept nogil:
|
|
|
|
_fortran_ctrsm(side, uplo, transa, diag, m, n, <npy_complex64*>alpha, <npy_complex64*>a, lda, <npy_complex64*>b, ldb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ctrsv "BLAS_FUNC(ctrsv)"(char *uplo, char *trans, char *diag, int *n, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx) nogil
|
|
cdef void ctrsv(char *uplo, char *trans, char *diag, int *n, c *a, int *lda, c *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ctrsv(uplo, trans, diag, n, <npy_complex64*>a, lda, <npy_complex64*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
d _fortran_dasum "BLAS_FUNC(dasum)"(int *n, d *dx, int *incx) nogil
|
|
cdef d dasum(int *n, d *dx, int *incx) noexcept nogil:
|
|
|
|
return _fortran_dasum(n, dx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_daxpy "BLAS_FUNC(daxpy)"(int *n, d *da, d *dx, int *incx, d *dy, int *incy) nogil
|
|
cdef void daxpy(int *n, d *da, d *dx, int *incx, d *dy, int *incy) noexcept nogil:
|
|
|
|
_fortran_daxpy(n, da, dx, incx, dy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
d _fortran_dcabs1 "BLAS_FUNC(dcabs1)"(npy_complex128 *z) nogil
|
|
cdef d dcabs1(z *z) noexcept nogil:
|
|
|
|
return _fortran_dcabs1(<npy_complex128*>z)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dcopy "BLAS_FUNC(dcopy)"(int *n, d *dx, int *incx, d *dy, int *incy) nogil
|
|
cdef void dcopy(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil:
|
|
|
|
_fortran_dcopy(n, dx, incx, dy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
d _fortran_ddot "BLAS_FUNC(ddot)"(int *n, d *dx, int *incx, d *dy, int *incy) nogil
|
|
cdef d ddot(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil:
|
|
|
|
return _fortran_ddot(n, dx, incx, dy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dgbmv "BLAS_FUNC(dgbmv)"(char *trans, int *m, int *n, int *kl, int *ku, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) nogil
|
|
cdef void dgbmv(char *trans, int *m, int *n, int *kl, int *ku, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_dgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dgemm "BLAS_FUNC(dgemm)"(char *transa, char *transb, int *m, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) nogil
|
|
cdef void dgemm(char *transa, char *transb, int *m, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_dgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dgemv "BLAS_FUNC(dgemv)"(char *trans, int *m, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) nogil
|
|
cdef void dgemv(char *trans, int *m, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_dgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dger "BLAS_FUNC(dger)"(int *m, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) nogil
|
|
cdef void dger(int *m, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_dger(m, n, alpha, x, incx, y, incy, a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
d _fortran_dnrm2 "BLAS_FUNC(dnrm2)"(int *n, d *x, int *incx) nogil
|
|
cdef d dnrm2(int *n, d *x, int *incx) noexcept nogil:
|
|
|
|
return _fortran_dnrm2(n, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_drot "BLAS_FUNC(drot)"(int *n, d *dx, int *incx, d *dy, int *incy, d *c, d *s) nogil
|
|
cdef void drot(int *n, d *dx, int *incx, d *dy, int *incy, d *c, d *s) noexcept nogil:
|
|
|
|
_fortran_drot(n, dx, incx, dy, incy, c, s)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_drotg "BLAS_FUNC(drotg)"(d *da, d *db, d *c, d *s) nogil
|
|
cdef void drotg(d *da, d *db, d *c, d *s) noexcept nogil:
|
|
|
|
_fortran_drotg(da, db, c, s)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_drotm "BLAS_FUNC(drotm)"(int *n, d *dx, int *incx, d *dy, int *incy, d *dparam) nogil
|
|
cdef void drotm(int *n, d *dx, int *incx, d *dy, int *incy, d *dparam) noexcept nogil:
|
|
|
|
_fortran_drotm(n, dx, incx, dy, incy, dparam)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_drotmg "BLAS_FUNC(drotmg)"(d *dd1, d *dd2, d *dx1, d *dy1, d *dparam) nogil
|
|
cdef void drotmg(d *dd1, d *dd2, d *dx1, d *dy1, d *dparam) noexcept nogil:
|
|
|
|
_fortran_drotmg(dd1, dd2, dx1, dy1, dparam)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dsbmv "BLAS_FUNC(dsbmv)"(char *uplo, int *n, int *k, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) nogil
|
|
cdef void dsbmv(char *uplo, int *n, int *k, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_dsbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dscal "BLAS_FUNC(dscal)"(int *n, d *da, d *dx, int *incx) nogil
|
|
cdef void dscal(int *n, d *da, d *dx, int *incx) noexcept nogil:
|
|
|
|
_fortran_dscal(n, da, dx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
d _fortran_dsdot "BLAS_FUNC(dsdot)"(int *n, s *sx, int *incx, s *sy, int *incy) nogil
|
|
cdef d dsdot(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil:
|
|
|
|
return _fortran_dsdot(n, sx, incx, sy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dspmv "BLAS_FUNC(dspmv)"(char *uplo, int *n, d *alpha, d *ap, d *x, int *incx, d *beta, d *y, int *incy) nogil
|
|
cdef void dspmv(char *uplo, int *n, d *alpha, d *ap, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_dspmv(uplo, n, alpha, ap, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dspr "BLAS_FUNC(dspr)"(char *uplo, int *n, d *alpha, d *x, int *incx, d *ap) nogil
|
|
cdef void dspr(char *uplo, int *n, d *alpha, d *x, int *incx, d *ap) noexcept nogil:
|
|
|
|
_fortran_dspr(uplo, n, alpha, x, incx, ap)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dspr2 "BLAS_FUNC(dspr2)"(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *ap) nogil
|
|
cdef void dspr2(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *ap) noexcept nogil:
|
|
|
|
_fortran_dspr2(uplo, n, alpha, x, incx, y, incy, ap)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dswap "BLAS_FUNC(dswap)"(int *n, d *dx, int *incx, d *dy, int *incy) nogil
|
|
cdef void dswap(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil:
|
|
|
|
_fortran_dswap(n, dx, incx, dy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dsymm "BLAS_FUNC(dsymm)"(char *side, char *uplo, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) nogil
|
|
cdef void dsymm(char *side, char *uplo, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_dsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dsymv "BLAS_FUNC(dsymv)"(char *uplo, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) nogil
|
|
cdef void dsymv(char *uplo, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_dsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dsyr "BLAS_FUNC(dsyr)"(char *uplo, int *n, d *alpha, d *x, int *incx, d *a, int *lda) nogil
|
|
cdef void dsyr(char *uplo, int *n, d *alpha, d *x, int *incx, d *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_dsyr(uplo, n, alpha, x, incx, a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dsyr2 "BLAS_FUNC(dsyr2)"(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) nogil
|
|
cdef void dsyr2(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_dsyr2(uplo, n, alpha, x, incx, y, incy, a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dsyr2k "BLAS_FUNC(dsyr2k)"(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) nogil
|
|
cdef void dsyr2k(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_dsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dsyrk "BLAS_FUNC(dsyrk)"(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *beta, d *c, int *ldc) nogil
|
|
cdef void dsyrk(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *beta, d *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_dsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dtbmv "BLAS_FUNC(dtbmv)"(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) nogil
|
|
cdef void dtbmv(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_dtbmv(uplo, trans, diag, n, k, a, lda, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dtbsv "BLAS_FUNC(dtbsv)"(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) nogil
|
|
cdef void dtbsv(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_dtbsv(uplo, trans, diag, n, k, a, lda, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dtpmv "BLAS_FUNC(dtpmv)"(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) nogil
|
|
cdef void dtpmv(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_dtpmv(uplo, trans, diag, n, ap, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dtpsv "BLAS_FUNC(dtpsv)"(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) nogil
|
|
cdef void dtpsv(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_dtpsv(uplo, trans, diag, n, ap, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dtrmm "BLAS_FUNC(dtrmm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) nogil
|
|
cdef void dtrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) noexcept nogil:
|
|
|
|
_fortran_dtrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dtrmv "BLAS_FUNC(dtrmv)"(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) nogil
|
|
cdef void dtrmv(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_dtrmv(uplo, trans, diag, n, a, lda, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dtrsm "BLAS_FUNC(dtrsm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) nogil
|
|
cdef void dtrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) noexcept nogil:
|
|
|
|
_fortran_dtrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_dtrsv "BLAS_FUNC(dtrsv)"(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) nogil
|
|
cdef void dtrsv(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_dtrsv(uplo, trans, diag, n, a, lda, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
d _fortran_dzasum "BLAS_FUNC(dzasum)"(int *n, npy_complex128 *zx, int *incx) nogil
|
|
cdef d dzasum(int *n, z *zx, int *incx) noexcept nogil:
|
|
|
|
return _fortran_dzasum(n, <npy_complex128*>zx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
d _fortran_dznrm2 "BLAS_FUNC(dznrm2)"(int *n, npy_complex128 *x, int *incx) nogil
|
|
cdef d dznrm2(int *n, z *x, int *incx) noexcept nogil:
|
|
|
|
return _fortran_dznrm2(n, <npy_complex128*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
int _fortran_icamax "BLAS_FUNC(icamax)"(int *n, npy_complex64 *cx, int *incx) nogil
|
|
cdef int icamax(int *n, c *cx, int *incx) noexcept nogil:
|
|
|
|
return _fortran_icamax(n, <npy_complex64*>cx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
int _fortran_idamax "BLAS_FUNC(idamax)"(int *n, d *dx, int *incx) nogil
|
|
cdef int idamax(int *n, d *dx, int *incx) noexcept nogil:
|
|
|
|
return _fortran_idamax(n, dx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
int _fortran_isamax "BLAS_FUNC(isamax)"(int *n, s *sx, int *incx) nogil
|
|
cdef int isamax(int *n, s *sx, int *incx) noexcept nogil:
|
|
|
|
return _fortran_isamax(n, sx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
int _fortran_izamax "BLAS_FUNC(izamax)"(int *n, npy_complex128 *zx, int *incx) nogil
|
|
cdef int izamax(int *n, z *zx, int *incx) noexcept nogil:
|
|
|
|
return _fortran_izamax(n, <npy_complex128*>zx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
bint _fortran_lsame "BLAS_FUNC(lsame)"(char *ca, char *cb) nogil
|
|
cdef bint lsame(char *ca, char *cb) noexcept nogil:
|
|
|
|
return _fortran_lsame(ca, cb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
s _fortran_sasum "BLAS_FUNC(sasum)"(int *n, s *sx, int *incx) nogil
|
|
cdef s sasum(int *n, s *sx, int *incx) noexcept nogil:
|
|
|
|
return _fortran_sasum(n, sx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_saxpy "BLAS_FUNC(saxpy)"(int *n, s *sa, s *sx, int *incx, s *sy, int *incy) nogil
|
|
cdef void saxpy(int *n, s *sa, s *sx, int *incx, s *sy, int *incy) noexcept nogil:
|
|
|
|
_fortran_saxpy(n, sa, sx, incx, sy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
s _fortran_scasum "BLAS_FUNC(scasum)"(int *n, npy_complex64 *cx, int *incx) nogil
|
|
cdef s scasum(int *n, c *cx, int *incx) noexcept nogil:
|
|
|
|
return _fortran_scasum(n, <npy_complex64*>cx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
s _fortran_scnrm2 "BLAS_FUNC(scnrm2)"(int *n, npy_complex64 *x, int *incx) nogil
|
|
cdef s scnrm2(int *n, c *x, int *incx) noexcept nogil:
|
|
|
|
return _fortran_scnrm2(n, <npy_complex64*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_scopy "BLAS_FUNC(scopy)"(int *n, s *sx, int *incx, s *sy, int *incy) nogil
|
|
cdef void scopy(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil:
|
|
|
|
_fortran_scopy(n, sx, incx, sy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
s _fortran_sdot "BLAS_FUNC(sdot)"(int *n, s *sx, int *incx, s *sy, int *incy) nogil
|
|
cdef s sdot(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil:
|
|
|
|
return _fortran_sdot(n, sx, incx, sy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
s _fortran_sdsdot "BLAS_FUNC(sdsdot)"(int *n, s *sb, s *sx, int *incx, s *sy, int *incy) nogil
|
|
cdef s sdsdot(int *n, s *sb, s *sx, int *incx, s *sy, int *incy) noexcept nogil:
|
|
|
|
return _fortran_sdsdot(n, sb, sx, incx, sy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sgbmv "BLAS_FUNC(sgbmv)"(char *trans, int *m, int *n, int *kl, int *ku, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) nogil
|
|
cdef void sgbmv(char *trans, int *m, int *n, int *kl, int *ku, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_sgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sgemm "BLAS_FUNC(sgemm)"(char *transa, char *transb, int *m, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) nogil
|
|
cdef void sgemm(char *transa, char *transb, int *m, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_sgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sgemv "BLAS_FUNC(sgemv)"(char *trans, int *m, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) nogil
|
|
cdef void sgemv(char *trans, int *m, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_sgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sger "BLAS_FUNC(sger)"(int *m, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) nogil
|
|
cdef void sger(int *m, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_sger(m, n, alpha, x, incx, y, incy, a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
s _fortran_snrm2 "BLAS_FUNC(snrm2)"(int *n, s *x, int *incx) nogil
|
|
cdef s snrm2(int *n, s *x, int *incx) noexcept nogil:
|
|
|
|
return _fortran_snrm2(n, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_srot "BLAS_FUNC(srot)"(int *n, s *sx, int *incx, s *sy, int *incy, s *c, s *s) nogil
|
|
cdef void srot(int *n, s *sx, int *incx, s *sy, int *incy, s *c, s *s) noexcept nogil:
|
|
|
|
_fortran_srot(n, sx, incx, sy, incy, c, s)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_srotg "BLAS_FUNC(srotg)"(s *sa, s *sb, s *c, s *s) nogil
|
|
cdef void srotg(s *sa, s *sb, s *c, s *s) noexcept nogil:
|
|
|
|
_fortran_srotg(sa, sb, c, s)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_srotm "BLAS_FUNC(srotm)"(int *n, s *sx, int *incx, s *sy, int *incy, s *sparam) nogil
|
|
cdef void srotm(int *n, s *sx, int *incx, s *sy, int *incy, s *sparam) noexcept nogil:
|
|
|
|
_fortran_srotm(n, sx, incx, sy, incy, sparam)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_srotmg "BLAS_FUNC(srotmg)"(s *sd1, s *sd2, s *sx1, s *sy1, s *sparam) nogil
|
|
cdef void srotmg(s *sd1, s *sd2, s *sx1, s *sy1, s *sparam) noexcept nogil:
|
|
|
|
_fortran_srotmg(sd1, sd2, sx1, sy1, sparam)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ssbmv "BLAS_FUNC(ssbmv)"(char *uplo, int *n, int *k, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) nogil
|
|
cdef void ssbmv(char *uplo, int *n, int *k, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_ssbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sscal "BLAS_FUNC(sscal)"(int *n, s *sa, s *sx, int *incx) nogil
|
|
cdef void sscal(int *n, s *sa, s *sx, int *incx) noexcept nogil:
|
|
|
|
_fortran_sscal(n, sa, sx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sspmv "BLAS_FUNC(sspmv)"(char *uplo, int *n, s *alpha, s *ap, s *x, int *incx, s *beta, s *y, int *incy) nogil
|
|
cdef void sspmv(char *uplo, int *n, s *alpha, s *ap, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_sspmv(uplo, n, alpha, ap, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sspr "BLAS_FUNC(sspr)"(char *uplo, int *n, s *alpha, s *x, int *incx, s *ap) nogil
|
|
cdef void sspr(char *uplo, int *n, s *alpha, s *x, int *incx, s *ap) noexcept nogil:
|
|
|
|
_fortran_sspr(uplo, n, alpha, x, incx, ap)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sspr2 "BLAS_FUNC(sspr2)"(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *ap) nogil
|
|
cdef void sspr2(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *ap) noexcept nogil:
|
|
|
|
_fortran_sspr2(uplo, n, alpha, x, incx, y, incy, ap)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_sswap "BLAS_FUNC(sswap)"(int *n, s *sx, int *incx, s *sy, int *incy) nogil
|
|
cdef void sswap(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil:
|
|
|
|
_fortran_sswap(n, sx, incx, sy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ssymm "BLAS_FUNC(ssymm)"(char *side, char *uplo, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) nogil
|
|
cdef void ssymm(char *side, char *uplo, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_ssymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ssymv "BLAS_FUNC(ssymv)"(char *uplo, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) nogil
|
|
cdef void ssymv(char *uplo, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_ssymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ssyr "BLAS_FUNC(ssyr)"(char *uplo, int *n, s *alpha, s *x, int *incx, s *a, int *lda) nogil
|
|
cdef void ssyr(char *uplo, int *n, s *alpha, s *x, int *incx, s *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_ssyr(uplo, n, alpha, x, incx, a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ssyr2 "BLAS_FUNC(ssyr2)"(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) nogil
|
|
cdef void ssyr2(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_ssyr2(uplo, n, alpha, x, incx, y, incy, a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ssyr2k "BLAS_FUNC(ssyr2k)"(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) nogil
|
|
cdef void ssyr2k(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_ssyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ssyrk "BLAS_FUNC(ssyrk)"(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *beta, s *c, int *ldc) nogil
|
|
cdef void ssyrk(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *beta, s *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_ssyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_stbmv "BLAS_FUNC(stbmv)"(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) nogil
|
|
cdef void stbmv(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_stbmv(uplo, trans, diag, n, k, a, lda, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_stbsv "BLAS_FUNC(stbsv)"(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) nogil
|
|
cdef void stbsv(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_stbsv(uplo, trans, diag, n, k, a, lda, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_stpmv "BLAS_FUNC(stpmv)"(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) nogil
|
|
cdef void stpmv(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_stpmv(uplo, trans, diag, n, ap, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_stpsv "BLAS_FUNC(stpsv)"(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) nogil
|
|
cdef void stpsv(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_stpsv(uplo, trans, diag, n, ap, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_strmm "BLAS_FUNC(strmm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) nogil
|
|
cdef void strmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) noexcept nogil:
|
|
|
|
_fortran_strmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_strmv "BLAS_FUNC(strmv)"(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) nogil
|
|
cdef void strmv(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_strmv(uplo, trans, diag, n, a, lda, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_strsm "BLAS_FUNC(strsm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) nogil
|
|
cdef void strsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) noexcept nogil:
|
|
|
|
_fortran_strsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_strsv "BLAS_FUNC(strsv)"(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) nogil
|
|
cdef void strsv(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_strsv(uplo, trans, diag, n, a, lda, x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zaxpy "BLAS_FUNC(zaxpy)"(int *n, npy_complex128 *za, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil
|
|
cdef void zaxpy(int *n, z *za, z *zx, int *incx, z *zy, int *incy) noexcept nogil:
|
|
|
|
_fortran_zaxpy(n, <npy_complex128*>za, <npy_complex128*>zx, incx, <npy_complex128*>zy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zcopy "BLAS_FUNC(zcopy)"(int *n, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil
|
|
cdef void zcopy(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil:
|
|
|
|
_fortran_zcopy(n, <npy_complex128*>zx, incx, <npy_complex128*>zy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zdotc "(zdotcwrp_)"(npy_complex128 *out, int *n, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil
|
|
cdef z zdotc(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil:
|
|
cdef z out
|
|
_fortran_zdotc(<npy_complex128*>&out, n, <npy_complex128*>zx, incx, <npy_complex128*>zy, incy)
|
|
return out
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zdotu "(zdotuwrp_)"(npy_complex128 *out, int *n, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil
|
|
cdef z zdotu(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil:
|
|
cdef z out
|
|
_fortran_zdotu(<npy_complex128*>&out, n, <npy_complex128*>zx, incx, <npy_complex128*>zy, incy)
|
|
return out
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zdrot "BLAS_FUNC(zdrot)"(int *n, npy_complex128 *cx, int *incx, npy_complex128 *cy, int *incy, d *c, d *s) nogil
|
|
cdef void zdrot(int *n, z *cx, int *incx, z *cy, int *incy, d *c, d *s) noexcept nogil:
|
|
|
|
_fortran_zdrot(n, <npy_complex128*>cx, incx, <npy_complex128*>cy, incy, c, s)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zdscal "BLAS_FUNC(zdscal)"(int *n, d *da, npy_complex128 *zx, int *incx) nogil
|
|
cdef void zdscal(int *n, d *da, z *zx, int *incx) noexcept nogil:
|
|
|
|
_fortran_zdscal(n, da, <npy_complex128*>zx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zgbmv "BLAS_FUNC(zgbmv)"(char *trans, int *m, int *n, int *kl, int *ku, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil
|
|
cdef void zgbmv(char *trans, int *m, int *n, int *kl, int *ku, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_zgbmv(trans, m, n, kl, ku, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>x, incx, <npy_complex128*>beta, <npy_complex128*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zgemm "BLAS_FUNC(zgemm)"(char *transa, char *transb, int *m, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil
|
|
cdef void zgemm(char *transa, char *transb, int *m, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_zgemm(transa, transb, m, n, k, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>b, ldb, <npy_complex128*>beta, <npy_complex128*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zgemv "BLAS_FUNC(zgemv)"(char *trans, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil
|
|
cdef void zgemv(char *trans, int *m, int *n, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_zgemv(trans, m, n, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>x, incx, <npy_complex128*>beta, <npy_complex128*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zgerc "BLAS_FUNC(zgerc)"(int *m, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, npy_complex128 *a, int *lda) nogil
|
|
cdef void zgerc(int *m, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_zgerc(m, n, <npy_complex128*>alpha, <npy_complex128*>x, incx, <npy_complex128*>y, incy, <npy_complex128*>a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zgeru "BLAS_FUNC(zgeru)"(int *m, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, npy_complex128 *a, int *lda) nogil
|
|
cdef void zgeru(int *m, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_zgeru(m, n, <npy_complex128*>alpha, <npy_complex128*>x, incx, <npy_complex128*>y, incy, <npy_complex128*>a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zhbmv "BLAS_FUNC(zhbmv)"(char *uplo, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil
|
|
cdef void zhbmv(char *uplo, int *n, int *k, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_zhbmv(uplo, n, k, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>x, incx, <npy_complex128*>beta, <npy_complex128*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zhemm "BLAS_FUNC(zhemm)"(char *side, char *uplo, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil
|
|
cdef void zhemm(char *side, char *uplo, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_zhemm(side, uplo, m, n, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>b, ldb, <npy_complex128*>beta, <npy_complex128*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zhemv "BLAS_FUNC(zhemv)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil
|
|
cdef void zhemv(char *uplo, int *n, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_zhemv(uplo, n, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>x, incx, <npy_complex128*>beta, <npy_complex128*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zher "BLAS_FUNC(zher)"(char *uplo, int *n, d *alpha, npy_complex128 *x, int *incx, npy_complex128 *a, int *lda) nogil
|
|
cdef void zher(char *uplo, int *n, d *alpha, z *x, int *incx, z *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_zher(uplo, n, alpha, <npy_complex128*>x, incx, <npy_complex128*>a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zher2 "BLAS_FUNC(zher2)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, npy_complex128 *a, int *lda) nogil
|
|
cdef void zher2(char *uplo, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil:
|
|
|
|
_fortran_zher2(uplo, n, <npy_complex128*>alpha, <npy_complex128*>x, incx, <npy_complex128*>y, incy, <npy_complex128*>a, lda)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zher2k "BLAS_FUNC(zher2k)"(char *uplo, char *trans, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, d *beta, npy_complex128 *c, int *ldc) nogil
|
|
cdef void zher2k(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, d *beta, z *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_zher2k(uplo, trans, n, k, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>b, ldb, beta, <npy_complex128*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zherk "BLAS_FUNC(zherk)"(char *uplo, char *trans, int *n, int *k, d *alpha, npy_complex128 *a, int *lda, d *beta, npy_complex128 *c, int *ldc) nogil
|
|
cdef void zherk(char *uplo, char *trans, int *n, int *k, d *alpha, z *a, int *lda, d *beta, z *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_zherk(uplo, trans, n, k, alpha, <npy_complex128*>a, lda, beta, <npy_complex128*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zhpmv "BLAS_FUNC(zhpmv)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *ap, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil
|
|
cdef void zhpmv(char *uplo, int *n, z *alpha, z *ap, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil:
|
|
|
|
_fortran_zhpmv(uplo, n, <npy_complex128*>alpha, <npy_complex128*>ap, <npy_complex128*>x, incx, <npy_complex128*>beta, <npy_complex128*>y, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zhpr "BLAS_FUNC(zhpr)"(char *uplo, int *n, d *alpha, npy_complex128 *x, int *incx, npy_complex128 *ap) nogil
|
|
cdef void zhpr(char *uplo, int *n, d *alpha, z *x, int *incx, z *ap) noexcept nogil:
|
|
|
|
_fortran_zhpr(uplo, n, alpha, <npy_complex128*>x, incx, <npy_complex128*>ap)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zhpr2 "BLAS_FUNC(zhpr2)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, npy_complex128 *ap) nogil
|
|
cdef void zhpr2(char *uplo, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *ap) noexcept nogil:
|
|
|
|
_fortran_zhpr2(uplo, n, <npy_complex128*>alpha, <npy_complex128*>x, incx, <npy_complex128*>y, incy, <npy_complex128*>ap)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zrotg "BLAS_FUNC(zrotg)"(npy_complex128 *ca, npy_complex128 *cb, d *c, npy_complex128 *s) nogil
|
|
cdef void zrotg(z *ca, z *cb, d *c, z *s) noexcept nogil:
|
|
|
|
_fortran_zrotg(<npy_complex128*>ca, <npy_complex128*>cb, c, <npy_complex128*>s)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zscal "BLAS_FUNC(zscal)"(int *n, npy_complex128 *za, npy_complex128 *zx, int *incx) nogil
|
|
cdef void zscal(int *n, z *za, z *zx, int *incx) noexcept nogil:
|
|
|
|
_fortran_zscal(n, <npy_complex128*>za, <npy_complex128*>zx, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zswap "BLAS_FUNC(zswap)"(int *n, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil
|
|
cdef void zswap(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil:
|
|
|
|
_fortran_zswap(n, <npy_complex128*>zx, incx, <npy_complex128*>zy, incy)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zsymm "BLAS_FUNC(zsymm)"(char *side, char *uplo, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil
|
|
cdef void zsymm(char *side, char *uplo, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_zsymm(side, uplo, m, n, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>b, ldb, <npy_complex128*>beta, <npy_complex128*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zsyr2k "BLAS_FUNC(zsyr2k)"(char *uplo, char *trans, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil
|
|
cdef void zsyr2k(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_zsyr2k(uplo, trans, n, k, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>b, ldb, <npy_complex128*>beta, <npy_complex128*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_zsyrk "BLAS_FUNC(zsyrk)"(char *uplo, char *trans, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil
|
|
cdef void zsyrk(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *beta, z *c, int *ldc) noexcept nogil:
|
|
|
|
_fortran_zsyrk(uplo, trans, n, k, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>beta, <npy_complex128*>c, ldc)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ztbmv "BLAS_FUNC(ztbmv)"(char *uplo, char *trans, char *diag, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx) nogil
|
|
cdef void ztbmv(char *uplo, char *trans, char *diag, int *n, int *k, z *a, int *lda, z *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ztbmv(uplo, trans, diag, n, k, <npy_complex128*>a, lda, <npy_complex128*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ztbsv "BLAS_FUNC(ztbsv)"(char *uplo, char *trans, char *diag, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx) nogil
|
|
cdef void ztbsv(char *uplo, char *trans, char *diag, int *n, int *k, z *a, int *lda, z *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ztbsv(uplo, trans, diag, n, k, <npy_complex128*>a, lda, <npy_complex128*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ztpmv "BLAS_FUNC(ztpmv)"(char *uplo, char *trans, char *diag, int *n, npy_complex128 *ap, npy_complex128 *x, int *incx) nogil
|
|
cdef void ztpmv(char *uplo, char *trans, char *diag, int *n, z *ap, z *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ztpmv(uplo, trans, diag, n, <npy_complex128*>ap, <npy_complex128*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ztpsv "BLAS_FUNC(ztpsv)"(char *uplo, char *trans, char *diag, int *n, npy_complex128 *ap, npy_complex128 *x, int *incx) nogil
|
|
cdef void ztpsv(char *uplo, char *trans, char *diag, int *n, z *ap, z *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ztpsv(uplo, trans, diag, n, <npy_complex128*>ap, <npy_complex128*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ztrmm "BLAS_FUNC(ztrmm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb) nogil
|
|
cdef void ztrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb) noexcept nogil:
|
|
|
|
_fortran_ztrmm(side, uplo, transa, diag, m, n, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>b, ldb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ztrmv "BLAS_FUNC(ztrmv)"(char *uplo, char *trans, char *diag, int *n, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx) nogil
|
|
cdef void ztrmv(char *uplo, char *trans, char *diag, int *n, z *a, int *lda, z *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ztrmv(uplo, trans, diag, n, <npy_complex128*>a, lda, <npy_complex128*>x, incx)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ztrsm "BLAS_FUNC(ztrsm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb) nogil
|
|
cdef void ztrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb) noexcept nogil:
|
|
|
|
_fortran_ztrsm(side, uplo, transa, diag, m, n, <npy_complex128*>alpha, <npy_complex128*>a, lda, <npy_complex128*>b, ldb)
|
|
|
|
|
|
cdef extern from "_blas_subroutines.h":
|
|
void _fortran_ztrsv "BLAS_FUNC(ztrsv)"(char *uplo, char *trans, char *diag, int *n, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx) nogil
|
|
cdef void ztrsv(char *uplo, char *trans, char *diag, int *n, z *a, int *lda, z *x, int *incx) noexcept nogil:
|
|
|
|
_fortran_ztrsv(uplo, trans, diag, n, <npy_complex128*>a, lda, <npy_complex128*>x, incx)
|
|
|
|
|
|
|
|
# Python-accessible wrappers for testing:
|
|
|
|
cdef inline bint _is_contiguous(double[:,:] a, int axis) noexcept nogil:
|
|
return (a.strides[axis] == sizeof(a[0,0]) or a.shape[axis] == 1)
|
|
|
|
cpdef float complex _test_cdotc(float complex[:] cx, float complex[:] cy) noexcept nogil:
|
|
cdef:
|
|
int n = cx.shape[0]
|
|
int incx = cx.strides[0] // sizeof(cx[0])
|
|
int incy = cy.strides[0] // sizeof(cy[0])
|
|
return cdotc(&n, &cx[0], &incx, &cy[0], &incy)
|
|
|
|
cpdef float complex _test_cdotu(float complex[:] cx, float complex[:] cy) noexcept nogil:
|
|
cdef:
|
|
int n = cx.shape[0]
|
|
int incx = cx.strides[0] // sizeof(cx[0])
|
|
int incy = cy.strides[0] // sizeof(cy[0])
|
|
return cdotu(&n, &cx[0], &incx, &cy[0], &incy)
|
|
|
|
cpdef double _test_dasum(double[:] dx) noexcept nogil:
|
|
cdef:
|
|
int n = dx.shape[0]
|
|
int incx = dx.strides[0] // sizeof(dx[0])
|
|
return dasum(&n, &dx[0], &incx)
|
|
|
|
cpdef double _test_ddot(double[:] dx, double[:] dy) noexcept nogil:
|
|
cdef:
|
|
int n = dx.shape[0]
|
|
int incx = dx.strides[0] // sizeof(dx[0])
|
|
int incy = dy.strides[0] // sizeof(dy[0])
|
|
return ddot(&n, &dx[0], &incx, &dy[0], &incy)
|
|
|
|
cpdef int _test_dgemm(double alpha, double[:,:] a, double[:,:] b, double beta,
|
|
double[:,:] c) except -1 nogil:
|
|
cdef:
|
|
char *transa
|
|
char *transb
|
|
int m, n, k, lda, ldb, ldc
|
|
double *a0=&a[0,0]
|
|
double *b0=&b[0,0]
|
|
double *c0=&c[0,0]
|
|
# In the case that c is C contiguous, swap a and b and
|
|
# swap whether or not each of them is transposed.
|
|
# This can be done because a.dot(b) = b.T.dot(a.T).T.
|
|
if _is_contiguous(c, 1):
|
|
if _is_contiguous(a, 1):
|
|
transb = 'n'
|
|
ldb = (&a[1,0]) - a0 if a.shape[0] > 1 else 1
|
|
elif _is_contiguous(a, 0):
|
|
transb = 't'
|
|
ldb = (&a[0,1]) - a0 if a.shape[1] > 1 else 1
|
|
else:
|
|
with gil:
|
|
raise ValueError("Input 'a' is neither C nor Fortran contiguous.")
|
|
if _is_contiguous(b, 1):
|
|
transa = 'n'
|
|
lda = (&b[1,0]) - b0 if b.shape[0] > 1 else 1
|
|
elif _is_contiguous(b, 0):
|
|
transa = 't'
|
|
lda = (&b[0,1]) - b0 if b.shape[1] > 1 else 1
|
|
else:
|
|
with gil:
|
|
raise ValueError("Input 'b' is neither C nor Fortran contiguous.")
|
|
k = b.shape[0]
|
|
if k != a.shape[1]:
|
|
with gil:
|
|
raise ValueError("Shape mismatch in input arrays.")
|
|
m = b.shape[1]
|
|
n = a.shape[0]
|
|
if n != c.shape[0] or m != c.shape[1]:
|
|
with gil:
|
|
raise ValueError("Output array does not have the correct shape.")
|
|
ldc = (&c[1,0]) - c0 if c.shape[0] > 1 else 1
|
|
dgemm(transa, transb, &m, &n, &k, &alpha, b0, &lda, a0,
|
|
&ldb, &beta, c0, &ldc)
|
|
elif _is_contiguous(c, 0):
|
|
if _is_contiguous(a, 1):
|
|
transa = 't'
|
|
lda = (&a[1,0]) - a0 if a.shape[0] > 1 else 1
|
|
elif _is_contiguous(a, 0):
|
|
transa = 'n'
|
|
lda = (&a[0,1]) - a0 if a.shape[1] > 1 else 1
|
|
else:
|
|
with gil:
|
|
raise ValueError("Input 'a' is neither C nor Fortran contiguous.")
|
|
if _is_contiguous(b, 1):
|
|
transb = 't'
|
|
ldb = (&b[1,0]) - b0 if b.shape[0] > 1 else 1
|
|
elif _is_contiguous(b, 0):
|
|
transb = 'n'
|
|
ldb = (&b[0,1]) - b0 if b.shape[1] > 1 else 1
|
|
else:
|
|
with gil:
|
|
raise ValueError("Input 'b' is neither C nor Fortran contiguous.")
|
|
m = a.shape[0]
|
|
k = a.shape[1]
|
|
if k != b.shape[0]:
|
|
with gil:
|
|
raise ValueError("Shape mismatch in input arrays.")
|
|
n = b.shape[1]
|
|
if m != c.shape[0] or n != c.shape[1]:
|
|
with gil:
|
|
raise ValueError("Output array does not have the correct shape.")
|
|
ldc = (&c[0,1]) - c0 if c.shape[1] > 1 else 1
|
|
dgemm(transa, transb, &m, &n, &k, &alpha, a0, &lda, b0,
|
|
&ldb, &beta, c0, &ldc)
|
|
else:
|
|
with gil:
|
|
raise ValueError("Input 'c' is neither C nor Fortran contiguous.")
|
|
return 0
|
|
|
|
cpdef double _test_dnrm2(double[:] x) noexcept nogil:
|
|
cdef:
|
|
int n = x.shape[0]
|
|
int incx = x.strides[0] // sizeof(x[0])
|
|
return dnrm2(&n, &x[0], &incx)
|
|
|
|
cpdef double _test_dzasum(double complex[:] zx) noexcept nogil:
|
|
cdef:
|
|
int n = zx.shape[0]
|
|
int incx = zx.strides[0] // sizeof(zx[0])
|
|
return dzasum(&n, &zx[0], &incx)
|
|
|
|
cpdef double _test_dznrm2(double complex[:] x) noexcept nogil:
|
|
cdef:
|
|
int n = x.shape[0]
|
|
int incx = x.strides[0] // sizeof(x[0])
|
|
return dznrm2(&n, &x[0], &incx)
|
|
|
|
cpdef int _test_icamax(float complex[:] cx) noexcept nogil:
|
|
cdef:
|
|
int n = cx.shape[0]
|
|
int incx = cx.strides[0] // sizeof(cx[0])
|
|
return icamax(&n, &cx[0], &incx)
|
|
|
|
cpdef int _test_idamax(double[:] dx) noexcept nogil:
|
|
cdef:
|
|
int n = dx.shape[0]
|
|
int incx = dx.strides[0] // sizeof(dx[0])
|
|
return idamax(&n, &dx[0], &incx)
|
|
|
|
cpdef int _test_isamax(float[:] sx) noexcept nogil:
|
|
cdef:
|
|
int n = sx.shape[0]
|
|
int incx = sx.strides[0] // sizeof(sx[0])
|
|
return isamax(&n, &sx[0], &incx)
|
|
|
|
cpdef int _test_izamax(double complex[:] zx) noexcept nogil:
|
|
cdef:
|
|
int n = zx.shape[0]
|
|
int incx = zx.strides[0] // sizeof(zx[0])
|
|
return izamax(&n, &zx[0], &incx)
|
|
|
|
cpdef float _test_sasum(float[:] sx) noexcept nogil:
|
|
cdef:
|
|
int n = sx.shape[0]
|
|
int incx = sx.strides[0] // sizeof(sx[0])
|
|
return sasum(&n, &sx[0], &incx)
|
|
|
|
cpdef float _test_scasum(float complex[:] cx) noexcept nogil:
|
|
cdef:
|
|
int n = cx.shape[0]
|
|
int incx = cx.strides[0] // sizeof(cx[0])
|
|
return scasum(&n, &cx[0], &incx)
|
|
|
|
cpdef float _test_scnrm2(float complex[:] x) noexcept nogil:
|
|
cdef:
|
|
int n = x.shape[0]
|
|
int incx = x.strides[0] // sizeof(x[0])
|
|
return scnrm2(&n, &x[0], &incx)
|
|
|
|
cpdef float _test_sdot(float[:] sx, float[:] sy) noexcept nogil:
|
|
cdef:
|
|
int n = sx.shape[0]
|
|
int incx = sx.strides[0] // sizeof(sx[0])
|
|
int incy = sy.strides[0] // sizeof(sy[0])
|
|
return sdot(&n, &sx[0], &incx, &sy[0], &incy)
|
|
|
|
cpdef float _test_snrm2(float[:] x) noexcept nogil:
|
|
cdef:
|
|
int n = x.shape[0]
|
|
int incx = x.strides[0] // sizeof(x[0])
|
|
return snrm2(&n, &x[0], &incx)
|
|
|
|
cpdef double complex _test_zdotc(double complex[:] zx, double complex[:] zy) noexcept nogil:
|
|
cdef:
|
|
int n = zx.shape[0]
|
|
int incx = zx.strides[0] // sizeof(zx[0])
|
|
int incy = zy.strides[0] // sizeof(zy[0])
|
|
return zdotc(&n, &zx[0], &incx, &zy[0], &incy)
|
|
|
|
cpdef double complex _test_zdotu(double complex[:] zx, double complex[:] zy) noexcept nogil:
|
|
cdef:
|
|
int n = zx.shape[0]
|
|
int incx = zx.strides[0] // sizeof(zx[0])
|
|
int incy = zy.strides[0] // sizeof(zy[0])
|
|
return zdotu(&n, &zx[0], &incx, &zy[0], &incy)
|