Added in API level 23
Deprecated in API level 31

ScriptIntrinsicBLAS

class ScriptIntrinsicBLAS : ScriptIntrinsic
kotlin.Any
   ↳ android.renderscript.BaseObj
   ↳ android.renderscript.Script
   ↳ android.renderscript.ScriptIntrinsic
   ↳ android.renderscript.ScriptIntrinsicBLAS

ScriptIntrinsicBLAS class provides high performance RenderScript APIs to BLAS. The BLAS (Basic Linear Algebra Subprograms) are routines that provide standard building blocks for performing basic vector and matrix operations. For detailed description of BLAS, please refer to http://www.netlib.org/blas/

Summary

Constants
static Int

static Int

static Int

static Int

static Int

static Int

static Int

static Int

static Int

Public methods
Unit
BNNM(A: Allocation!, a_offset: Int, B: Allocation!, b_offset: Int, C: Allocation!, c_offset: Int, c_mult: Int)

8-bit GEMM-like operation for neural networks: C = A * Transpose(B) Calculations are done in 1.
Unit
CGBMV(TransA: Int, KL: Int, KU: Int, alpha: Float2!, A: Allocation!, X: Allocation!, incX: Int, beta: Float2!, Y: Allocation!, incY: Int)

CGBMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y Details: http://www.
Unit
CGEMM(TransA: Int, TransB: Int, alpha: Float2!, A: Allocation!, B: Allocation!, beta: Float2!, C: Allocation!)

CGEMM performs one of the matrix-matrix operations C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T or op(X) = X**H Details: http://www.
Unit
CGEMV(TransA: Int, alpha: Float2!, A: Allocation!, X: Allocation!, incX: Int, beta: Float2!, Y: Allocation!, incY: Int)

CGEMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y Details: http://www.
Unit
CGERC(alpha: Float2!, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

CGERC performs the rank 1 operation A := alpha*x*y**H + A Details: http://www.
Unit
CGERU(alpha: Float2!, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

CGERU performs the rank 1 operation A := alpha*x*y**T + A Details: http://www.
Unit
CHBMV(Uplo: Int, K: Int, alpha: Float2!, A: Allocation!, X: Allocation!, incX: Int, beta: Float2!, Y: Allocation!, incY: Int)

CHBMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
CHEMM(Side: Int, Uplo: Int, alpha: Float2!, A: Allocation!, B: Allocation!, beta: Float2!, C: Allocation!)

CHEMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.
Unit
CHEMV(Uplo: Int, alpha: Float2!, A: Allocation!, X: Allocation!, incX: Int, beta: Float2!, Y: Allocation!, incY: Int)

CHEMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
CHER(Uplo: Int, alpha: Float, X: Allocation!, incX: Int, A: Allocation!)

CHER performs the rank 1 operation A := alpha*x*x**H + A Details: http://www.
Unit
CHER2(Uplo: Int, alpha: Float2!, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

CHER2 performs the symmetric rank 2 operation A := alpha*x*y**H + alpha*y*x**H + A Details: http://www.
Unit
CHER2K(Uplo: Int, Trans: Int, alpha: Float2!, A: Allocation!, B: Allocation!, beta: Float, C: Allocation!)

CHER2K performs one of the hermitian rank 2k operations C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C or C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C Details: http://www.
Unit
CHERK(Uplo: Int, Trans: Int, alpha: Float, A: Allocation!, beta: Float, C: Allocation!)

CHERK performs one of the hermitian rank k operations C := alpha*A*A**H + beta*C or C := alpha*A**H*A + beta*C Details: http://www.
Unit
CHPMV(Uplo: Int, alpha: Float2!, Ap: Allocation!, X: Allocation!, incX: Int, beta: Float2!, Y: Allocation!, incY: Int)

CHPMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
CHPR(Uplo: Int, alpha: Float, X: Allocation!, incX: Int, Ap: Allocation!)

CHPR performs the rank 1 operation A := alpha*x*x**H + A Details: http://www.
Unit
CHPR2(Uplo: Int, alpha: Float2!, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, Ap: Allocation!)

CHPR2 performs the symmetric rank 2 operation A := alpha*x*y**H + alpha*y*x**H + A Details: http://www.
Unit
CSYMM(Side: Int, Uplo: Int, alpha: Float2!, A: Allocation!, B: Allocation!, beta: Float2!, C: Allocation!)

CSYMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.
Unit
CSYR2K(Uplo: Int, Trans: Int, alpha: Float2!, A: Allocation!, B: Allocation!, beta: Float2!, C: Allocation!)

CSYR2K performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C Details: http://www.
Unit
CSYRK(Uplo: Int, Trans: Int, alpha: Float2!, A: Allocation!, beta: Float2!, C: Allocation!)

CSYRK performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C Details: http://www.
Unit
CTBMV(Uplo: Int, TransA: Int, Diag: Int, K: Int, A: Allocation!, X: Allocation!, incX: Int)

CTBMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.
Unit
CTBSV(Uplo: Int, TransA: Int, Diag: Int, K: Int, A: Allocation!, X: Allocation!, incX: Int)

CTBSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.
Unit
CTPMV(Uplo: Int, TransA: Int, Diag: Int, Ap: Allocation!, X: Allocation!, incX: Int)

CTPMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.
Unit
CTPSV(Uplo: Int, TransA: Int, Diag: Int, Ap: Allocation!, X: Allocation!, incX: Int)

CTPSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.
Unit
CTRMM(Side: Int, Uplo: Int, TransA: Int, Diag: Int, alpha: Float2!, A: Allocation!, B: Allocation!)

CTRMM performs one of the matrix-matrix operations B := alpha*op(A)*B or B := alpha*B*op(A) op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H Details: http://www.
Unit
CTRMV(Uplo: Int, TransA: Int, Diag: Int, A: Allocation!, X: Allocation!, incX: Int)

CTRMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.
Unit
CTRSM(Side: Int, Uplo: Int, TransA: Int, Diag: Int, alpha: Float2!, A: Allocation!, B: Allocation!)

CTRSM solves one of the matrix equations op(A)*X := alpha*B or X*op(A) := alpha*B op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H Details: http://www.
Unit
CTRSV(Uplo: Int, TransA: Int, Diag: Int, A: Allocation!, X: Allocation!, incX: Int)

CTRSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.
Unit
DGBMV(TransA: Int, KL: Int, KU: Int, alpha: Double, A: Allocation!, X: Allocation!, incX: Int, beta: Double, Y: Allocation!, incY: Int)

DGBMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y Details: http://www.
Unit
DGEMM(TransA: Int, TransB: Int, alpha: Double, A: Allocation!, B: Allocation!, beta: Double, C: Allocation!)

DGEMM performs one of the matrix-matrix operations C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T Details: http://www.
Unit
DGEMV(TransA: Int, alpha: Double, A: Allocation!, X: Allocation!, incX: Int, beta: Double, Y: Allocation!, incY: Int)

DGEMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y Details: http://www.
Unit
DGER(alpha: Double, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

DGER performs the rank 1 operation A := alpha*x*y**T + A Details: http://www.
Unit
DSBMV(Uplo: Int, K: Int, alpha: Double, A: Allocation!, X: Allocation!, incX: Int, beta: Double, Y: Allocation!, incY: Int)

DSBMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
DSPMV(Uplo: Int, alpha: Double, Ap: Allocation!, X: Allocation!, incX: Int, beta: Double, Y: Allocation!, incY: Int)

DSPMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
DSPR(Uplo: Int, alpha: Double, X: Allocation!, incX: Int, Ap: Allocation!)

DSPR performs the rank 1 operation A := alpha*x*x**T + A Details: http://www.
Unit
DSPR2(Uplo: Int, alpha: Double, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, Ap: Allocation!)

DSPR2 performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A Details: http://www.
Unit
DSYMM(Side: Int, Uplo: Int, alpha: Double, A: Allocation!, B: Allocation!, beta: Double, C: Allocation!)

DSYMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.
Unit
DSYMV(Uplo: Int, alpha: Double, A: Allocation!, X: Allocation!, incX: Int, beta: Double, Y: Allocation!, incY: Int)

DSYMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
DSYR(Uplo: Int, alpha: Double, X: Allocation!, incX: Int, A: Allocation!)

DSYR performs the rank 1 operation A := alpha*x*x**T + A Details: http://www.
Unit
DSYR2(Uplo: Int, alpha: Double, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

DSYR2 performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A Details: http://www.
Unit
DSYR2K(Uplo: Int, Trans: Int, alpha: Double, A: Allocation!, B: Allocation!, beta: Double, C: Allocation!)

DSYR2K performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C Details: http://www.
Unit
DSYRK(Uplo: Int, Trans: Int, alpha: Double, A: Allocation!, beta: Double, C: Allocation!)

DSYRK performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C Details: http://www.
Unit
DTBMV(Uplo: Int, TransA: Int, Diag: Int, K: Int, A: Allocation!, X: Allocation!, incX: Int)

DTBMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.
Unit
DTBSV(Uplo: Int, TransA: Int, Diag: Int, K: Int, A: Allocation!, X: Allocation!, incX: Int)

DTBSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.
Unit
DTPMV(Uplo: Int, TransA: Int, Diag: Int, Ap: Allocation!, X: Allocation!, incX: Int)

DTPMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.
Unit
DTPSV(Uplo: Int, TransA: Int, Diag: Int, Ap: Allocation!, X: Allocation!, incX: Int)

DTPSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.
Unit
DTRMM(Side: Int, Uplo: Int, TransA: Int, Diag: Int, alpha: Double, A: Allocation!, B: Allocation!)

DTRMM performs one of the matrix-matrix operations B := alpha*op(A)*B or B := alpha*B*op(A) op(A) is one of op(A) = A or op(A) = A**T Details: http://www.
Unit
DTRMV(Uplo: Int, TransA: Int, Diag: Int, A: Allocation!, X: Allocation!, incX: Int)

DTRMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.
Unit
DTRSM(Side: Int, Uplo: Int, TransA: Int, Diag: Int, alpha: Double, A: Allocation!, B: Allocation!)

DTRSM solves one of the matrix equations op(A)*X := alpha*B or X*op(A) := alpha*B op(A) is one of op(A) = A or op(A) = A**T Details: http://www.
Unit
DTRSV(Uplo: Int, TransA: Int, Diag: Int, A: Allocation!, X: Allocation!, incX: Int)

DTRSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.
Unit
SGBMV(TransA: Int, KL: Int, KU: Int, alpha: Float, A: Allocation!, X: Allocation!, incX: Int, beta: Float, Y: Allocation!, incY: Int)

SGBMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y Details: http://www.
Unit
SGEMM(TransA: Int, TransB: Int, alpha: Float, A: Allocation!, B: Allocation!, beta: Float, C: Allocation!)

SGEMM performs one of the matrix-matrix operations C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T Details: http://www.
Unit
SGEMV(TransA: Int, alpha: Float, A: Allocation!, X: Allocation!, incX: Int, beta: Float, Y: Allocation!, incY: Int)

SGEMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y Details: http://www.
Unit
SGER(alpha: Float, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

SGER performs the rank 1 operation A := alpha*x*y**T + A Details: http://www.
Unit
SSBMV(Uplo: Int, K: Int, alpha: Float, A: Allocation!, X: Allocation!, incX: Int, beta: Float, Y: Allocation!, incY: Int)

SSBMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
SSPMV(Uplo: Int, alpha: Float, Ap: Allocation!, X: Allocation!, incX: Int, beta: Float, Y: Allocation!, incY: Int)

SSPMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
SSPR(Uplo: Int, alpha: Float, X: Allocation!, incX: Int, Ap: Allocation!)

SSPR performs the rank 1 operation A := alpha*x*x**T + A Details: http://www.
Unit
SSPR2(Uplo: Int, alpha: Float, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, Ap: Allocation!)

SSPR2 performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A Details: http://www.
Unit
SSYMM(Side: Int, Uplo: Int, alpha: Float, A: Allocation!, B: Allocation!, beta: Float, C: Allocation!)

SSYMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.
Unit
SSYMV(Uplo: Int, alpha: Float, A: Allocation!, X: Allocation!, incX: Int, beta: Float, Y: Allocation!, incY: Int)

SSYMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
SSYR(Uplo: Int, alpha: Float, X: Allocation!, incX: Int, A: Allocation!)

SSYR performs the rank 1 operation A := alpha*x*x**T + A Details: http://www.
Unit
SSYR2(Uplo: Int, alpha: Float, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

SSYR2 performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A Details: http://www.
Unit
SSYR2K(Uplo: Int, Trans: Int, alpha: Float, A: Allocation!, B: Allocation!, beta: Float, C: Allocation!)

SSYR2K performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C Details: http://www.
Unit
SSYRK(Uplo: Int, Trans: Int, alpha: Float, A: Allocation!, beta: Float, C: Allocation!)

SSYRK performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C Details: http://www.
Unit
STBMV(Uplo: Int, TransA: Int, Diag: Int, K: Int, A: Allocation!, X: Allocation!, incX: Int)

STBMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.
Unit
STBSV(Uplo: Int, TransA: Int, Diag: Int, K: Int, A: Allocation!, X: Allocation!, incX: Int)

STBSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.
Unit
STPMV(Uplo: Int, TransA: Int, Diag: Int, Ap: Allocation!, X: Allocation!, incX: Int)

STPMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.
Unit
STPSV(Uplo: Int, TransA: Int, Diag: Int, Ap: Allocation!, X: Allocation!, incX: Int)

STPSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.
Unit
STRMM(Side: Int, Uplo: Int, TransA: Int, Diag: Int, alpha: Float, A: Allocation!, B: Allocation!)

STRMM performs one of the matrix-matrix operations B := alpha*op(A)*B or B := alpha*B*op(A) op(A) is one of op(A) = A or op(A) = A**T Details: http://www.
Unit
STRMV(Uplo: Int, TransA: Int, Diag: Int, A: Allocation!, X: Allocation!, incX: Int)

STRMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.
Unit
STRSM(Side: Int, Uplo: Int, TransA: Int, Diag: Int, alpha: Float, A: Allocation!, B: Allocation!)

STRSM solves one of the matrix equations op(A)*X := alpha*B or X*op(A) := alpha*B op(A) is one of op(A) = A or op(A) = A**T Details: http://www.
Unit
STRSV(Uplo: Int, TransA: Int, Diag: Int, A: Allocation!, X: Allocation!, incX: Int)

STRSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.
Unit
ZGBMV(TransA: Int, KL: Int, KU: Int, alpha: Double2!, A: Allocation!, X: Allocation!, incX: Int, beta: Double2!, Y: Allocation!, incY: Int)

ZGBMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y Details: http://www.
Unit
ZGEMM(TransA: Int, TransB: Int, alpha: Double2!, A: Allocation!, B: Allocation!, beta: Double2!, C: Allocation!)

ZGEMM performs one of the matrix-matrix operations C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T or op(X) = X**H Details: http://www.
Unit
ZGEMV(TransA: Int, alpha: Double2!, A: Allocation!, X: Allocation!, incX: Int, beta: Double2!, Y: Allocation!, incY: Int)

ZGEMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y Details: http://www.
Unit
ZGERC(alpha: Double2!, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

ZGERC performs the rank 1 operation A := alpha*x*y**H + A Details: http://www.
Unit
ZGERU(alpha: Double2!, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

ZGERU performs the rank 1 operation A := alpha*x*y**T + A Details: http://www.
Unit
ZHBMV(Uplo: Int, K: Int, alpha: Double2!, A: Allocation!, X: Allocation!, incX: Int, beta: Double2!, Y: Allocation!, incY: Int)

ZHBMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
ZHEMM(Side: Int, Uplo: Int, alpha: Double2!, A: Allocation!, B: Allocation!, beta: Double2!, C: Allocation!)

ZHEMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.
Unit
ZHEMV(Uplo: Int, alpha: Double2!, A: Allocation!, X: Allocation!, incX: Int, beta: Double2!, Y: Allocation!, incY: Int)

ZHEMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
ZHER(Uplo: Int, alpha: Double, X: Allocation!, incX: Int, A: Allocation!)

ZHER performs the rank 1 operation A := alpha*x*x**H + A Details: http://www.
Unit
ZHER2(Uplo: Int, alpha: Double2!, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, A: Allocation!)

ZHER2 performs the symmetric rank 2 operation A := alpha*x*y**H + alpha*y*x**H + A Details: http://www.
Unit
ZHER2K(Uplo: Int, Trans: Int, alpha: Double2!, A: Allocation!, B: Allocation!, beta: Double, C: Allocation!)

ZHER2K performs one of the hermitian rank 2k operations C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C or C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C Details: http://www.
Unit
ZHERK(Uplo: Int, Trans: Int, alpha: Double, A: Allocation!, beta: Double, C: Allocation!)

ZHERK performs one of the hermitian rank k operations C := alpha*A*A**H + beta*C or C := alpha*A**H*A + beta*C Details: http://www.
Unit
ZHPMV(Uplo: Int, alpha: Double2!, Ap: Allocation!, X: Allocation!, incX: Int, beta: Double2!, Y: Allocation!, incY: Int)

ZHPMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.
Unit
ZHPR(Uplo: Int, alpha: Double, X: Allocation!, incX: Int, Ap: Allocation!)

ZHPR performs the rank 1 operation A := alpha*x*x**H + A Details: http://www.
Unit
ZHPR2(Uplo: Int, alpha: Double2!, X: Allocation!, incX: Int, Y: Allocation!, incY: Int, Ap: Allocation!)

ZHPR2 performs the symmetric rank 2 operation A := alpha*x*y**H + alpha*y*x**H + A Details: http://www.
Unit
ZSYMM(Side: Int, Uplo: Int, alpha: Double2!, A: Allocation!, B: Allocation!, beta: Double2!, C: Allocation!)

ZSYMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.
Unit
ZSYR2K(Uplo: Int, Trans: Int, alpha: Double2!, A: Allocation!, B: Allocation!, beta: Double2!, C: Allocation!)

ZSYR2K performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C Details: http://www.
Unit
ZSYRK(Uplo: Int, Trans: Int, alpha: Double2!, A: Allocation!, beta: Double2!, C: Allocation!)

ZSYRK performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C Details: http://www.
Unit
ZTBMV(Uplo: Int, TransA: Int, Diag: Int, K: Int, A: Allocation!, X: Allocation!, incX: Int)

ZTBMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.
Unit
ZTBSV(Uplo: Int, TransA: Int, Diag: Int, K: Int, A: Allocation!, X: Allocation!, incX: Int)

ZTBSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.
Unit
ZTPMV(Uplo: Int, TransA: Int, Diag: Int, Ap: Allocation!, X: Allocation!, incX: Int)

ZTPMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.
Unit
ZTPSV(Uplo: Int, TransA: Int, Diag: Int, Ap: Allocation!, X: Allocation!, incX: Int)

ZTPSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.
Unit
ZTRMM(Side: Int, Uplo: Int, TransA: Int, Diag: Int, alpha: Double2!, A: Allocation!, B: Allocation!)

ZTRMM performs one of the matrix-matrix operations B := alpha*op(A)*B or B := alpha*B*op(A) op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H Details: http://www.
Unit
ZTRMV(Uplo: Int, TransA: Int, Diag: Int, A: Allocation!, X: Allocation!, incX: Int)

ZTRMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.
Unit
ZTRSM(Side: Int, Uplo: Int, TransA: Int, Diag: Int, alpha: Double2!, A: Allocation!, B: Allocation!)

ZTRSM solves one of the matrix equations op(A)*X := alpha*B or X*op(A) := alpha*B op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H Details: http://www.
Unit
ZTRSV(Uplo: Int, TransA: Int, Diag: Int, A: Allocation!, X: Allocation!, incX: Int)

ZTRSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.
static ScriptIntrinsicBLAS!

Create an intrinsic to access BLAS subroutines.

Constants

CONJ_TRANSPOSE

Added in API level 23
static val CONJ_TRANSPOSE: Int

Deprecated: Deprecated in Java. 

Value: 113

LEFT

Added in API level 23
static val LEFT: Int

Deprecated: Deprecated in Java. 

Value: 141

LOWER

Added in API level 23
static val LOWER: Int

Deprecated: Deprecated in Java. 

Value: 122

NON_UNIT

Added in API level 23
static val NON_UNIT: Int

Deprecated: Deprecated in Java. 

Value: 131

NO_TRANSPOSE

Added in API level 23
static val NO_TRANSPOSE: Int

Deprecated: Deprecated in Java. 

Value: 111
Added in API level 23
static val RIGHT: Int

Deprecated: Deprecated in Java. 

Value: 142

TRANSPOSE

Added in API level 23
static val TRANSPOSE: Int

Deprecated: Deprecated in Java. 

Value: 112

UNIT

Added in API level 23
static val UNIT: Int

Deprecated: Deprecated in Java. 

Value: 132

UPPER

Added in API level 23
static val UPPER: Int

Deprecated: Deprecated in Java. 

Value: 121

Public methods

BNNM

Added in API level 23
fun BNNM(
    A: Allocation!, 
    a_offset: Int, 
    B: Allocation!, 
    b_offset: Int, 
    C: Allocation!, 
    c_offset: Int, 
    c_mult: Int
): Unit

Deprecated: Deprecated in Java.

8-bit GEMM-like operation for neural networks: C = A * Transpose(B) Calculations are done in 1.10.21 fixed-point format for the final output, just before there's a shift down to drop the fractional parts. The output values are gated to 0 to 255 to fit in a byte, but the 10-bit format gives some headroom to avoid wrapping around on small overflows.

Parameters
A Allocation!: The input allocation contains matrix A, supported elements type Element#U8.
a_offset Int: The offset for all values in matrix A, e.g A[i,j] = A[i,j] - a_offset. Value should be from 0 to 255.
B Allocation!: The input allocation contains matrix B, supported elements type Element#U8.
b_offset Int: The offset for all values in matrix B, e.g B[i,j] = B[i,j] - b_offset. Value should be from 0 to 255.
C Allocation!: The input allocation contains matrix C, supported elements type Element#U8.
c_offset Int: The offset for all values in matrix C.
c_mult Int: The multiplier for all values in matrix C, e.g C[i,j] = (C[i,j] + c_offset) * c_mult.

CGBMV

Added in API level 23
fun CGBMV(
    TransA: Int, 
    KL: Int, 
    KU: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

CGBMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d0/d75/cgbmv_8f.html Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N), but only the region M*(KL+KU+1) will be referenced. The following subroutine can is an example showing how to convert the original matrix 'a' to row-based band matrix 'b'. for i in range(0, m): for j in range(max(0, i-kl), min(i+ku+1, n)): b[i, j-i+kl] = a[i, j]

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
KL Int: The number of sub-diagonals of the matrix A.
KU Int: The number of super-diagonals of the matrix A.
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains the band matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

CGEMM

Added in API level 23
fun CGEMM(
    TransA: Int, 
    TransB: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

CGEMM performs one of the matrix-matrix operations C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T or op(X) = X**H Details: http://www.netlib.org/lapack/explore-html/d6/d5b/cgemm_8f.html

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
TransB Int: The type of transpose applied to matrix B. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32_2.
beta Float2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32_2.

CGEMV

Added in API level 23
fun CGEMV(
    TransA: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

CGEMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d4/d8a/cgemv_8f.html

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

CGERC

Added in API level 23
fun CGERC(
    alpha: Float2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

CGERC performs the rank 1 operation A := alpha*x*y**H + A Details: http://www.netlib.org/lapack/explore-html/dd/d84/cgerc_8f.html

Parameters
alpha Float2!: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.

CGERU

Added in API level 23
fun CGERU(
    alpha: Float2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

CGERU performs the rank 1 operation A := alpha*x*y**T + A Details: http://www.netlib.org/lapack/explore-html/db/d5f/cgeru_8f.html

Parameters
alpha Float2!: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.

CHBMV

Added in API level 23
fun CHBMV(
    Uplo: Int, 
    K: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

CHBMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/db/dc2/chbmv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of the band matrix A is being supplied. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
K Int: The number of off-diagonals of the matrix A
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

CHEMM

Added in API level 23
fun CHEMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

CHEMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d3/d66/chemm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32_2.
beta Float2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32_2.

CHEMV

Added in API level 23
fun CHEMV(
    Uplo: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

CHEMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d7/d51/chemv_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

CHER

Added in API level 23
fun CHER(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

CHER performs the rank 1 operation A := alpha*x*x**H + A Details: http://www.netlib.org/lapack/explore-html/d3/d6d/cher_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.

CHER2

Added in API level 23
fun CHER2(
    Uplo: Int, 
    alpha: Float2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

CHER2 performs the symmetric rank 2 operation A := alpha*x*y**H + alpha*y*x**H + A Details: http://www.netlib.org/lapack/explore-html/db/d87/cher2_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float2!: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.

CHER2K

Added in API level 23
fun CHER2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

CHER2K performs one of the hermitian rank 2k operations C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C or C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d1/d82/cher2k_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32_2.
beta Float: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32_2.

CHERK

Added in API level 23
fun CHERK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float, 
    A: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

CHERK performs one of the hermitian rank k operations C := alpha*A*A**H + beta*C or C := alpha*A**H*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d8/d52/cherk_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
beta Float: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32_2.

CHPMV

Added in API level 23
fun CHPMV(
    Uplo: Int, 
    alpha: Float2!, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

CHPMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d2/d06/chpmv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float2!: The scalar alpha.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

CHPR

Added in API level 23
fun CHPR(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

CHPR performs the rank 1 operation A := alpha*x*x**H + A Details: http://www.netlib.org/lapack/explore-html/db/dcd/chpr_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be supplied in the packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.

CHPR2

Added in API level 23
fun CHPR2(
    Uplo: Int, 
    alpha: Float2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

CHPR2 performs the symmetric rank 2 operation A := alpha*x*y**H + alpha*y*x**H + A Details: http://www.netlib.org/lapack/explore-html/d6/d44/chpr2_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be supplied in the packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float2!: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32_2.
incY Int: The increment for the elements of vector y, must be larger than zero.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.

CSYMM

Added in API level 23
fun CSYMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

CSYMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.netlib.org/lapack/explore-html/db/d59/csymm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32_2.
beta Float2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32_2.

CSYR2K

Added in API level 23
fun CSYR2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

CSYR2K performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C Details: http://www.netlib.org/lapack/explore-html/de/d7e/csyr2k_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32_2.
beta Float2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32_2.

CSYRK

Added in API level 23
fun CSYRK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

CSYRK performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d3/d6a/csyrk_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
beta Float2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32_2.

CTBMV

Added in API level 23
fun CTBMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

CTBMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.netlib.org/lapack/explore-html/d3/dcd/ctbmv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
K Int: The number of off-diagonals of the matrix A
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

CTBSV

Added in API level 23
fun CTBSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

CTBSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.netlib.org/lapack/explore-html/d9/d5f/ctbsv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
K Int: The number of off-diagonals of the matrix A
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

CTPMV

Added in API level 23
fun CTPMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

CTPMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.netlib.org/lapack/explore-html/d4/dbb/ctpmv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
Ap Allocation!: The input allocation contains packed matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

CTPSV

Added in API level 23
fun CTPSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

CTPSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.netlib.org/lapack/explore-html/d8/d56/ctpsv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
Ap Allocation!: The input allocation contains packed matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

CTRMM

Added in API level 23
fun CTRMM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

CTRMM performs one of the matrix-matrix operations B := alpha*op(A)*B or B := alpha*B*op(A) op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H Details: http://www.netlib.org/lapack/explore-html/d4/d9b/ctrmm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether matrix A is upper or lower triangular. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32_2.

CTRMV

Added in API level 23
fun CTRMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

CTRMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.netlib.org/lapack/explore-html/df/d78/ctrmv_8f.html

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

CTRSM

Added in API level 23
fun CTRSM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

CTRSM solves one of the matrix equations op(A)*X := alpha*B or X*op(A) := alpha*B op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H Details: http://www.netlib.org/lapack/explore-html/de/d30/ctrsm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether matrix A is upper or lower triangular. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
alpha Float2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32_2.

CTRSV

Added in API level 23
fun CTRSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

CTRSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.netlib.org/lapack/explore-html/d4/dc8/ctrsv_8f.html

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

DGBMV

Added in API level 23
fun DGBMV(
    TransA: Int, 
    KL: Int, 
    KU: Int, 
    alpha: Double, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

DGBMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d2/d3f/dgbmv_8f.html Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N), but only the region M*(KL+KU+1) will be referenced. The following subroutine can is an example showing how to convert the original matrix 'a' to row-based band matrix 'b'. for i in range(0, m): for j in range(max(0, i-kl), min(i+ku+1, n)): b[i, j-i+kl] = a[i, j]

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
KL Int: The number of sub-diagonals of the matrix A.
KU Int: The number of super-diagonals of the matrix A.
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains the band matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64.
incY Int: The increment for the elements of vector y, must be larger than zero.

DGEMM

Added in API level 23
fun DGEMM(
    TransA: Int, 
    TransB: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

DGEMM performs one of the matrix-matrix operations C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T Details: http://www.netlib.org/lapack/explore-html/d7/d2b/dgemm_8f.html

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
TransB Int: The type of transpose applied to matrix B. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64.
beta Double: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64.

DGEMV

Added in API level 23
fun DGEMV(
    TransA: Int, 
    alpha: Double, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

DGEMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y Details: http://www.netlib.org/lapack/explore-html/dc/da8/dgemv_8f.html

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64.
incY Int: The increment for the elements of vector y, must be larger than zero.

DGER

Added in API level 23
fun DGER(
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

DGER performs the rank 1 operation A := alpha*x*y**T + A Details: http://www.netlib.org/lapack/explore-html/dc/da8/dger_8f.html

Parameters
alpha Double: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.

DSBMV

Added in API level 23
fun DSBMV(
    Uplo: Int, 
    K: Int, 
    alpha: Double, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

DSBMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d8/d1e/dsbmv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of the band matrix A is being supplied. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
K Int: The number of off-diagonals of the matrix A
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64.
incY Int: The increment for the elements of vector y, must be larger than zero.

DSPMV

Added in API level 23
fun DSPMV(
    Uplo: Int, 
    alpha: Double, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

DSPMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d4/d85/dspmv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64.
incY Int: The increment for the elements of vector y, must be larger than zero.

DSPR

Added in API level 23
fun DSPR(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

DSPR performs the rank 1 operation A := alpha*x*x**T + A Details: http://www.netlib.org/lapack/explore-html/dd/dba/dspr_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be supplied in the packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F64.

DSPR2

Added in API level 23
fun DSPR2(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

DSPR2 performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A Details: http://www.netlib.org/lapack/explore-html/dd/d9e/dspr2_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be supplied in the packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64.
incY Int: The increment for the elements of vector y, must be larger than zero.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F64.

DSYMM

Added in API level 23
fun DSYMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

DSYMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d8/db0/dsymm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64.
beta Double: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64.

DSYMV

Added in API level 23
fun DSYMV(
    Uplo: Int, 
    alpha: Double, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

DSYMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d8/dbe/dsymv_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64.
incY Int: The increment for the elements of vector y, must be larger than zero.

DSYR

Added in API level 23
fun DSYR(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

DSYR performs the rank 1 operation A := alpha*x*x**T + A Details: http://www.netlib.org/lapack/explore-html/d3/d60/dsyr_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.

DSYR2

Added in API level 23
fun DSYR2(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

DSYR2 performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A Details: http://www.netlib.org/lapack/explore-html/de/d41/dsyr2_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.

DSYR2K

Added in API level 23
fun DSYR2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

DSYR2K performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d1/dec/dsyr2k_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64.
beta Double: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64.

DSYRK

Added in API level 23
fun DSYRK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double, 
    A: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

DSYRK performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C Details: http://www.netlib.org/lapack/explore-html/dc/d05/dsyrk_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
beta Double: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64.

DTBMV

Added in API level 23
fun DTBMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

DTBMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.netlib.org/lapack/explore-html/df/d29/dtbmv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
K Int: The number of off-diagonals of the matrix A
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.

DTBSV

Added in API level 23
fun DTBSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

DTBSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.netlib.org/lapack/explore-html/d4/dcf/dtbsv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
K Int: The number of off-diagonals of the matrix A
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.

DTPMV

Added in API level 23
fun DTPMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

DTPMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.netlib.org/lapack/explore-html/dc/dcd/dtpmv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
Ap Allocation!: The input allocation contains packed matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.

DTPSV

Added in API level 23
fun DTPSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

DTPSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.netlib.org/lapack/explore-html/d9/d84/dtpsv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
Ap Allocation!: The input allocation contains packed matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.

DTRMM

Added in API level 23
fun DTRMM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

DTRMM performs one of the matrix-matrix operations B := alpha*op(A)*B or B := alpha*B*op(A) op(A) is one of op(A) = A or op(A) = A**T Details: http://www.netlib.org/lapack/explore-html/dd/d19/dtrmm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether matrix A is upper or lower triangular. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64.

DTRMV

Added in API level 23
fun DTRMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

DTRMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.netlib.org/lapack/explore-html/dc/d7e/dtrmv_8f.html

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.

DTRSM

Added in API level 23
fun DTRSM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

DTRSM solves one of the matrix equations op(A)*X := alpha*B or X*op(A) := alpha*B op(A) is one of op(A) = A or op(A) = A**T Details: http://www.netlib.org/lapack/explore-html/de/da7/dtrsm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether matrix A is upper or lower triangular. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64.

DTRSV

Added in API level 23
fun DTRSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

DTRSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.netlib.org/lapack/explore-html/d6/d96/dtrsv_8f.html

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64.
incX Int: The increment for the elements of vector x, must be larger than zero.

SGBMV

Added in API level 23
fun SGBMV(
    TransA: Int, 
    KL: Int, 
    KU: Int, 
    alpha: Float, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

SGBMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d6/d46/sgbmv_8f.html Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N), but only the region M*(KL+KU+1) will be referenced. The following subroutine can is an example showing how to convert the original matrix 'a' to row-based band matrix 'b'. for i in range(0, m): for j in range(max(0, i-kl), min(i+ku+1, n)): b[i, j-i+kl] = a[i, j]

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
KL Int: The number of sub-diagonals of the matrix A.
KU Int: The number of super-diagonals of the matrix A.
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains the band matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32.
incY Int: The increment for the elements of vector y, must be larger than zero.

SGEMM

Added in API level 23
fun SGEMM(
    TransA: Int, 
    TransB: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

SGEMM performs one of the matrix-matrix operations C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T Details: http://www.netlib.org/lapack/explore-html/d4/de2/sgemm_8f.html

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
TransB Int: The type of transpose applied to matrix B. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32.
beta Float: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32.

SGEMV

Added in API level 23
fun SGEMV(
    TransA: Int, 
    alpha: Float, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

SGEMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y Details: http://www.netlib.org/lapack/explore-html/db/d58/sgemv_8f.html

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32.
incY Int: The increment for the elements of vector y, must be larger than zero.

SGER

Added in API level 23
fun SGER(
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

SGER performs the rank 1 operation A := alpha*x*y**T + A Details: http://www.netlib.org/lapack/explore-html/db/d5c/sger_8f.html

Parameters
alpha Float: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.

SSBMV

Added in API level 23
fun SSBMV(
    Uplo: Int, 
    K: Int, 
    alpha: Float, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

SSBMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d3/da1/ssbmv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of the band matrix A is being supplied. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
K Int: The number of off-diagonals of the matrix A
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32.
incY Int: The increment for the elements of vector y, must be larger than zero.

SSPMV

Added in API level 23
fun SSPMV(
    Uplo: Int, 
    alpha: Float, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

SSPMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d8/d68/sspmv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32.
incY Int: The increment for the elements of vector y, must be larger than zero.

SSPR

Added in API level 23
fun SSPR(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

SSPR performs the rank 1 operation A := alpha*x*x**T + A Details: http://www.netlib.org/lapack/explore-html/d2/d9b/sspr_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be supplied in the packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F32.

SSPR2

Added in API level 23
fun SSPR2(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

SSPR2 performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A Details: http://www.netlib.org/lapack/explore-html/db/d3e/sspr2_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be supplied in the packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32.
incY Int: The increment for the elements of vector y, must be larger than zero.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F32.

SSYMM

Added in API level 23
fun SSYMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

SSYMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d7/d42/ssymm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32.
beta Float: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32.

SSYMV

Added in API level 23
fun SSYMV(
    Uplo: Int, 
    alpha: Float, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

SSYMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d2/d94/ssymv_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Float: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32.
incY Int: The increment for the elements of vector y, must be larger than zero.

SSYR

Added in API level 23
fun SSYR(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

SSYR performs the rank 1 operation A := alpha*x*x**T + A Details: http://www.netlib.org/lapack/explore-html/d6/dac/ssyr_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.

SSYR2

Added in API level 23
fun SSYR2(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

SSYR2 performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A Details: http://www.netlib.org/lapack/explore-html/db/d99/ssyr2_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Float: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F32.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.

SSYR2K

Added in API level 23
fun SSYR2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

SSYR2K performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C Details: http://www.netlib.org/lapack/explore-html/df/d3d/ssyr2k_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32.
beta Float: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32.

SSYRK

Added in API level 23
fun SSYRK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float, 
    A: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

SSYRK performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d0/d40/ssyrk_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
beta Float: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F32.

STBMV

Added in API level 23
fun STBMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

STBMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.netlib.org/lapack/explore-html/d6/d7d/stbmv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
K Int: The number of off-diagonals of the matrix A
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.

STBSV

Added in API level 23
fun STBSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

STBSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.netlib.org/lapack/explore-html/d0/d1f/stbsv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
K Int: The number of off-diagonals of the matrix A
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.

STPMV

Added in API level 23
fun STPMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

STPMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.netlib.org/lapack/explore-html/db/db1/stpmv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
Ap Allocation!: The input allocation contains packed matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.

STPSV

Added in API level 23
fun STPSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

STPSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.netlib.org/lapack/explore-html/d0/d7c/stpsv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
Ap Allocation!: The input allocation contains packed matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.

STRMM

Added in API level 23
fun STRMM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

STRMM performs one of the matrix-matrix operations B := alpha*op(A)*B or B := alpha*B*op(A) op(A) is one of op(A) = A or op(A) = A**T Details: http://www.netlib.org/lapack/explore-html/df/d01/strmm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether matrix A is upper or lower triangular. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32.

STRMV

Added in API level 23
fun STRMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

STRMV performs one of the matrix-vector operations x := A*x or x := A**T*x Details: http://www.netlib.org/lapack/explore-html/de/d45/strmv_8f.html

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.

STRSM

Added in API level 23
fun STRSM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

STRSM solves one of the matrix equations op(A)*X := alpha*B or X*op(A) := alpha*B op(A) is one of op(A) = A or op(A) = A**T Details: http://www.netlib.org/lapack/explore-html/d2/d8b/strsm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether matrix A is upper or lower triangular. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
alpha Float: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F32.

STRSV

Added in API level 23
fun STRSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

STRSV solves one of the systems of equations A*x = b or A**T*x = b Details: http://www.netlib.org/lapack/explore-html/d0/d2a/strsv_8f.html

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
A Allocation!: The input allocation contains matrix A, supported elements type Element#F32.
X Allocation!: The input allocation contains vector x, supported elements type Element#F32.
incX Int: The increment for the elements of vector x, must be larger than zero.

ZGBMV

Added in API level 23
fun ZGBMV(
    TransA: Int, 
    KL: Int, 
    KU: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

ZGBMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d9/d46/zgbmv_8f.html Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N), but only the region M*(KL+KU+1) will be referenced. The following subroutine can is an example showing how to convert the original matrix 'a' to row-based band matrix 'b'. for i in range(0, m): for j in range(max(0, i-kl), min(i+ku+1, n)): b[i, j-i+kl] = a[i, j]

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
KL Int: The number of sub-diagonals of the matrix A.
KU Int: The number of super-diagonals of the matrix A.
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains the band matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

ZGEMM

Added in API level 23
fun ZGEMM(
    TransA: Int, 
    TransB: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZGEMM performs one of the matrix-matrix operations C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T or op(X) = X**H Details: http://www.netlib.org/lapack/explore-html/d7/d76/zgemm_8f.html

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
TransB Int: The type of transpose applied to matrix B. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64_2.
beta Double2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64_2.

ZGEMV

Added in API level 23
fun ZGEMV(
    TransA: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

ZGEMV performs one of the matrix-vector operations y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y Details: http://www.netlib.org/lapack/explore-html/db/d40/zgemv_8f.html

Parameters
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

ZGERC

Added in API level 23
fun ZGERC(
    alpha: Double2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZGERC performs the rank 1 operation A := alpha*x*y**H + A Details: http://www.netlib.org/lapack/explore-html/d3/dad/zgerc_8f.html

Parameters
alpha Double2!: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.

ZGERU

Added in API level 23
fun ZGERU(
    alpha: Double2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZGERU performs the rank 1 operation A := alpha*x*y**T + A Details: http://www.netlib.org/lapack/explore-html/d7/d12/zgeru_8f.html

Parameters
alpha Double2!: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.

ZHBMV

Added in API level 23
fun ZHBMV(
    Uplo: Int, 
    K: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

ZHBMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d3/d1a/zhbmv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of the band matrix A is being supplied. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
K Int: The number of off-diagonals of the matrix A
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

ZHEMM

Added in API level 23
fun ZHEMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZHEMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d6/d3e/zhemm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64_2.
beta Double2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64_2.

ZHEMV

Added in API level 23
fun ZHEMV(
    Uplo: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

ZHEMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d0/ddd/zhemv_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

ZHER

Added in API level 23
fun ZHER(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZHER performs the rank 1 operation A := alpha*x*x**H + A Details: http://www.netlib.org/lapack/explore-html/de/d0e/zher_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.

ZHER2

Added in API level 23
fun ZHER2(
    Uplo: Int, 
    alpha: Double2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZHER2 performs the symmetric rank 2 operation A := alpha*x*y**H + alpha*y*x**H + A Details: http://www.netlib.org/lapack/explore-html/da/d8a/zher2_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double2!: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.

ZHER2K

Added in API level 23
fun ZHER2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZHER2K performs one of the hermitian rank 2k operations C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C or C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d7/dfa/zher2k_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64_2.
beta Double: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64_2.

ZHERK

Added in API level 23
fun ZHERK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double, 
    A: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZHERK performs one of the hermitian rank k operations C := alpha*A*A**H + beta*C or C := alpha*A**H*A + beta*C Details: http://www.netlib.org/lapack/explore-html/d1/db1/zherk_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
beta Double: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64_2.

ZHPMV

Added in API level 23
fun ZHPMV(
    Uplo: Int, 
    alpha: Double2!, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

ZHPMV performs the matrix-vector operation y := alpha*A*x + beta*y Details: http://www.netlib.org/lapack/explore-html/d0/d60/zhpmv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double2!: The scalar alpha.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
beta Double2!: The scalar beta.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.

ZHPR

Added in API level 23
fun ZHPR(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZHPR performs the rank 1 operation A := alpha*x*x**H + A Details: http://www.netlib.org/lapack/explore-html/de/de1/zhpr_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be supplied in the packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.

ZHPR2

Added in API level 23
fun ZHPR2(
    Uplo: Int, 
    alpha: Double2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZHPR2 performs the symmetric rank 2 operation A := alpha*x*y**H + alpha*y*x**H + A Details: http://www.netlib.org/lapack/explore-html/d5/d52/zhpr2_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the upper or lower triangular part is to be supplied in the packed form. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double2!: The scalar alpha.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.
Y Allocation!: The input allocation contains vector y, supported elements type Element#F64_2.
incY Int: The increment for the elements of vector y, must be larger than zero.
Ap Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.

ZSYMM

Added in API level 23
fun ZSYMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZSYMM performs one of the matrix-matrix operations C := alpha*A*B + beta*C or C := alpha*B*A + beta*C Details: http://www.netlib.org/lapack/explore-html/df/d51/zsymm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether the upper or lower triangular part is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64_2.
beta Double2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64_2.

ZSYR2K

Added in API level 23
fun ZSYR2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZSYR2K performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C Details: http://www.netlib.org/lapack/explore-html/df/d20/zsyr2k_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64_2.
beta Double2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64_2.

ZSYRK

Added in API level 23
fun ZSYRK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZSYRK performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C Details: http://www.netlib.org/lapack/explore-html/de/d54/zsyrk_8f.html

Parameters
Uplo Int: Specifies whether the upper or lower triangular part of C is to be referenced. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
Trans Int: The type of transpose applied to the operation. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
beta Double2!: The scalar beta.
C Allocation!: The input allocation contains matrix C, supported elements type Element#F64_2.

ZTBMV

Added in API level 23
fun ZTBMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

ZTBMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.netlib.org/lapack/explore-html/d3/d39/ztbmv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
K Int: The number of off-diagonals of the matrix A
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

ZTBSV

Added in API level 23
fun ZTBSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

ZTBSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.netlib.org/lapack/explore-html/d4/d5a/ztbsv_8f.html Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N), but only the region N*(K+1) will be referenced. The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'. for i in range(0, n): for j in range(i, min(i+k+1, n)): b[i, j-i] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
K Int: The number of off-diagonals of the matrix A
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

ZTPMV

Added in API level 23
fun ZTPMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

ZTPMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.netlib.org/lapack/explore-html/d2/d9e/ztpmv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
Ap Allocation!: The input allocation contains packed matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

ZTPSV

Added in API level 23
fun ZTPSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

ZTPSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.netlib.org/lapack/explore-html/da/d57/ztpsv_8f.html Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2, The following subroutine can is an example showing how to convert a UPPER trianglar matrix 'a' to packed matrix 'b'. k = 0 for i in range(0, n): for j in range(i, n): b[k++] = a[i, j]

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
Ap Allocation!: The input allocation contains packed matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

ZTRMM

Added in API level 23
fun ZTRMM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZTRMM performs one of the matrix-matrix operations B := alpha*op(A)*B or B := alpha*B*op(A) op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H Details: http://www.netlib.org/lapack/explore-html/d8/de1/ztrmm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether matrix A is upper or lower triangular. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64_2.

ZTRMV

Added in API level 23
fun ZTRMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

ZTRMV performs one of the matrix-vector operations x := A*x or x := A**T*x or x := A**H*x Details: http://www.netlib.org/lapack/explore-html/d0/dd1/ztrmv_8f.html

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

ZTRSM

Added in API level 23
fun ZTRSM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

ZTRSM solves one of the matrix equations op(A)*X := alpha*B or X*op(A) := alpha*B op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H Details: http://www.netlib.org/lapack/explore-html/d1/d39/ztrsm_8f.html

Parameters
Side Int: Specifies whether the symmetric matrix A appears on the left or right. Value is android.renderscript.ScriptIntrinsicBLAS#LEFT, or android.renderscript.ScriptIntrinsicBLAS#RIGHT
Uplo Int: Specifies whether matrix A is upper or lower triangular. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
alpha Double2!: The scalar alpha.
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
B Allocation!: The input allocation contains matrix B, supported elements type Element#F64_2.

ZTRSV

Added in API level 23
fun ZTRSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

ZTRSV solves one of the systems of equations A*x = b or A**T*x = b or A**H*x = b Details: http://www.netlib.org/lapack/explore-html/d1/d2f/ztrsv_8f.html

Parameters
Uplo Int: Specifies whether the matrix is an upper or lower triangular matrix. Value is android.renderscript.ScriptIntrinsicBLAS#UPPER, or android.renderscript.ScriptIntrinsicBLAS#LOWER
TransA Int: The type of transpose applied to matrix A. Value is android.renderscript.ScriptIntrinsicBLAS#NO_TRANSPOSE, android.renderscript.ScriptIntrinsicBLAS#TRANSPOSE, or android.renderscript.ScriptIntrinsicBLAS#CONJ_TRANSPOSE
Diag Int: Specifies whether or not A is unit triangular. Value is android.renderscript.ScriptIntrinsicBLAS#NON_UNIT, or android.renderscript.ScriptIntrinsicBLAS#UNIT
A Allocation!: The input allocation contains matrix A, supported elements type Element#F64_2.
X Allocation!: The input allocation contains vector x, supported elements type Element#F64_2.
incX Int: The increment for the elements of vector x, must be larger than zero.

create

Added in API level 23
static fun create(rs: RenderScript!): ScriptIntrinsicBLAS!

Deprecated: Deprecated in Java.

Create an intrinsic to access BLAS subroutines.

Parameters
rs RenderScript!: The RenderScript context
Return
ScriptIntrinsicBLAS! ScriptIntrinsicBLAS