| from cython cimport floating |
|
|
| from scipy.linalg.cython_blas cimport sdot, ddot |
| from scipy.linalg.cython_blas cimport sasum, dasum |
| from scipy.linalg.cython_blas cimport saxpy, daxpy |
| from scipy.linalg.cython_blas cimport snrm2, dnrm2 |
| from scipy.linalg.cython_blas cimport scopy, dcopy |
| from scipy.linalg.cython_blas cimport sscal, dscal |
| from scipy.linalg.cython_blas cimport srotg, drotg |
| from scipy.linalg.cython_blas cimport srot, drot |
| from scipy.linalg.cython_blas cimport sgemv, dgemv |
| from scipy.linalg.cython_blas cimport sger, dger |
| from scipy.linalg.cython_blas cimport sgemm, dgemm |
|
|
|
|
| |
| |
| |
|
|
| cdef floating _dot(int n, const floating *x, int incx, |
| const floating *y, int incy) noexcept nogil: |
| """x.T.y""" |
| if floating is float: |
| return sdot(&n, <float *> x, &incx, <float *> y, &incy) |
| else: |
| return ddot(&n, <double *> x, &incx, <double *> y, &incy) |
|
|
|
|
| cpdef _dot_memview(const floating[::1] x, const floating[::1] y): |
| return _dot(x.shape[0], &x[0], 1, &y[0], 1) |
|
|
|
|
| cdef floating _asum(int n, const floating *x, int incx) noexcept nogil: |
| """sum(|x_i|)""" |
| if floating is float: |
| return sasum(&n, <float *> x, &incx) |
| else: |
| return dasum(&n, <double *> x, &incx) |
|
|
|
|
| cpdef _asum_memview(const floating[::1] x): |
| return _asum(x.shape[0], &x[0], 1) |
|
|
|
|
| cdef void _axpy(int n, floating alpha, const floating *x, int incx, |
| floating *y, int incy) noexcept nogil: |
| """y := alpha * x + y""" |
| if floating is float: |
| saxpy(&n, &alpha, <float *> x, &incx, y, &incy) |
| else: |
| daxpy(&n, &alpha, <double *> x, &incx, y, &incy) |
|
|
|
|
| cpdef _axpy_memview(floating alpha, const floating[::1] x, floating[::1] y): |
| _axpy(x.shape[0], alpha, &x[0], 1, &y[0], 1) |
|
|
|
|
| cdef floating _nrm2(int n, const floating *x, int incx) noexcept nogil: |
| """sqrt(sum((x_i)^2))""" |
| if floating is float: |
| return snrm2(&n, <float *> x, &incx) |
| else: |
| return dnrm2(&n, <double *> x, &incx) |
|
|
|
|
| cpdef _nrm2_memview(const floating[::1] x): |
| return _nrm2(x.shape[0], &x[0], 1) |
|
|
|
|
| cdef void _copy(int n, const floating *x, int incx, const floating *y, int incy) noexcept nogil: |
| """y := x""" |
| if floating is float: |
| scopy(&n, <float *> x, &incx, <float *> y, &incy) |
| else: |
| dcopy(&n, <double *> x, &incx, <double *> y, &incy) |
|
|
|
|
| cpdef _copy_memview(const floating[::1] x, const floating[::1] y): |
| _copy(x.shape[0], &x[0], 1, &y[0], 1) |
|
|
|
|
| cdef void _scal(int n, floating alpha, const floating *x, int incx) noexcept nogil: |
| """x := alpha * x""" |
| if floating is float: |
| sscal(&n, &alpha, <float *> x, &incx) |
| else: |
| dscal(&n, &alpha, <double *> x, &incx) |
|
|
|
|
| cpdef _scal_memview(floating alpha, const floating[::1] x): |
| _scal(x.shape[0], alpha, &x[0], 1) |
|
|
|
|
| cdef void _rotg(floating *a, floating *b, floating *c, floating *s) noexcept nogil: |
| """Generate plane rotation""" |
| if floating is float: |
| srotg(a, b, c, s) |
| else: |
| drotg(a, b, c, s) |
|
|
|
|
| cpdef _rotg_memview(floating a, floating b, floating c, floating s): |
| _rotg(&a, &b, &c, &s) |
| return a, b, c, s |
|
|
|
|
| cdef void _rot(int n, floating *x, int incx, floating *y, int incy, |
| floating c, floating s) noexcept nogil: |
| """Apply plane rotation""" |
| if floating is float: |
| srot(&n, x, &incx, y, &incy, &c, &s) |
| else: |
| drot(&n, x, &incx, y, &incy, &c, &s) |
|
|
|
|
| cpdef _rot_memview(floating[::1] x, floating[::1] y, floating c, floating s): |
| _rot(x.shape[0], &x[0], 1, &y[0], 1, c, s) |
|
|
|
|
| |
| |
| |
|
|
| cdef void _gemv(BLAS_Order order, BLAS_Trans ta, int m, int n, floating alpha, |
| const floating *A, int lda, const floating *x, int incx, |
| floating beta, floating *y, int incy) noexcept nogil: |
| """y := alpha * op(A).x + beta * y""" |
| cdef char ta_ = ta |
| if order == RowMajor: |
| ta_ = NoTrans if ta == Trans else Trans |
| if floating is float: |
| sgemv(&ta_, &n, &m, &alpha, <float *> A, &lda, <float *> x, |
| &incx, &beta, y, &incy) |
| else: |
| dgemv(&ta_, &n, &m, &alpha, <double *> A, &lda, <double *> x, |
| &incx, &beta, y, &incy) |
| else: |
| if floating is float: |
| sgemv(&ta_, &m, &n, &alpha, <float *> A, &lda, <float *> x, |
| &incx, &beta, y, &incy) |
| else: |
| dgemv(&ta_, &m, &n, &alpha, <double *> A, &lda, <double *> x, |
| &incx, &beta, y, &incy) |
|
|
|
|
| cpdef _gemv_memview(BLAS_Trans ta, floating alpha, const floating[:, :] A, |
| const floating[::1] x, floating beta, floating[::1] y): |
| cdef: |
| int m = A.shape[0] |
| int n = A.shape[1] |
| BLAS_Order order = ColMajor if A.strides[0] == A.itemsize else RowMajor |
| int lda = m if order == ColMajor else n |
|
|
| _gemv(order, ta, m, n, alpha, &A[0, 0], lda, &x[0], 1, beta, &y[0], 1) |
|
|
|
|
| cdef void _ger(BLAS_Order order, int m, int n, floating alpha, |
| const floating *x, int incx, const floating *y, |
| int incy, floating *A, int lda) noexcept nogil: |
| """A := alpha * x.y.T + A""" |
| if order == RowMajor: |
| if floating is float: |
| sger(&n, &m, &alpha, <float *> y, &incy, <float *> x, &incx, A, &lda) |
| else: |
| dger(&n, &m, &alpha, <double *> y, &incy, <double *> x, &incx, A, &lda) |
| else: |
| if floating is float: |
| sger(&m, &n, &alpha, <float *> x, &incx, <float *> y, &incy, A, &lda) |
| else: |
| dger(&m, &n, &alpha, <double *> x, &incx, <double *> y, &incy, A, &lda) |
|
|
|
|
| cpdef _ger_memview(floating alpha, const floating[::1] x, |
| const floating[::1] y, floating[:, :] A): |
| cdef: |
| int m = A.shape[0] |
| int n = A.shape[1] |
| BLAS_Order order = ColMajor if A.strides[0] == A.itemsize else RowMajor |
| int lda = m if order == ColMajor else n |
|
|
| _ger(order, m, n, alpha, &x[0], 1, &y[0], 1, &A[0, 0], lda) |
|
|
|
|
| |
| |
| |
|
|
| cdef void _gemm(BLAS_Order order, BLAS_Trans ta, BLAS_Trans tb, int m, int n, |
| int k, floating alpha, const floating *A, int lda, const floating *B, |
| int ldb, floating beta, floating *C, int ldc) noexcept nogil: |
| """C := alpha * op(A).op(B) + beta * C""" |
| |
| |
| cdef: |
| char ta_ = ta |
| char tb_ = tb |
| if order == RowMajor: |
| if floating is float: |
| sgemm(&tb_, &ta_, &n, &m, &k, &alpha, <float*>B, |
| &ldb, <float*>A, &lda, &beta, C, &ldc) |
| else: |
| dgemm(&tb_, &ta_, &n, &m, &k, &alpha, <double*>B, |
| &ldb, <double*>A, &lda, &beta, C, &ldc) |
| else: |
| if floating is float: |
| sgemm(&ta_, &tb_, &m, &n, &k, &alpha, <float*>A, |
| &lda, <float*>B, &ldb, &beta, C, &ldc) |
| else: |
| dgemm(&ta_, &tb_, &m, &n, &k, &alpha, <double*>A, |
| &lda, <double*>B, &ldb, &beta, C, &ldc) |
|
|
|
|
| cpdef _gemm_memview(BLAS_Trans ta, BLAS_Trans tb, floating alpha, |
| const floating[:, :] A, const floating[:, :] B, floating beta, |
| floating[:, :] C): |
| cdef: |
| int m = A.shape[0] if ta == NoTrans else A.shape[1] |
| int n = B.shape[1] if tb == NoTrans else B.shape[0] |
| int k = A.shape[1] if ta == NoTrans else A.shape[0] |
| int lda, ldb, ldc |
| BLAS_Order order = ColMajor if A.strides[0] == A.itemsize else RowMajor |
|
|
| if order == RowMajor: |
| lda = k if ta == NoTrans else m |
| ldb = n if tb == NoTrans else k |
| ldc = n |
| else: |
| lda = m if ta == NoTrans else k |
| ldb = k if tb == NoTrans else n |
| ldc = m |
|
|
| _gemm(order, ta, tb, m, n, k, alpha, &A[0, 0], |
| lda, &B[0, 0], ldb, beta, &C[0, 0], ldc) |
|
|
