Google is committed to advancing racial equity for Black communities. See how.
Added in API level 23

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
Value: 113

LEFT

Added in API level 23
static val LEFT: Int
Value: 141

LOWER

Added in API level 23
static val LOWER: Int
Value: 122

NON_UNIT

Added in API level 23
static val NON_UNIT: Int
Value: 131

NO_TRANSPOSE

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

TRANSPOSE

Added in API level 23
static val TRANSPOSE: Int
Value: 112

UNIT

Added in API level 23
static val UNIT: Int
Value: 132

UPPER

Added in API level 23
static val UPPER: Int
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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!

Create an intrinsic to access BLAS subroutines.

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