Added in API level 23
Deprecated in API level 31

ScriptIntrinsicBLAS

---

Kotlin |Java

class ScriptIntrinsicBLAS : ScriptIntrinsic

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

---

This class was deprecated in API level 31.

Renderscript has been deprecated in API level 31. Please refer to the migration guide for the proposed alternatives.

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	CONJ_TRANSPOSE
static Int	LEFT
static Int	LOWER
static Int	NON_UNIT
static Int	NO_TRANSPOSE
static Int	RIGHT
static Int	TRANSPOSE
static Int	UNIT
static Int	UPPER

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(rs: RenderScript!) Create an intrinsic to access BLAS subroutines.

Constants

CONJ_TRANSPOSE

Added in API level 23

static val CONJ_TRANSPOSE: Int

Deprecated: Deprecated in Java.

Value: 113

LEFT

Added in API level 23

static val LEFT: Int

Deprecated: Deprecated in Java.

Value: 141

LOWER

Added in API level 23

static val LOWER: Int

Deprecated: Deprecated in Java.

Value: 122

NON_UNIT

Added in API level 23

static val NON_UNIT: Int

Deprecated: Deprecated in Java.

Value: 131

NO_TRANSPOSE

Added in API level 23

static val NO_TRANSPOSE: Int

Deprecated: Deprecated in Java.

Value: 111

RIGHT

Added in API level 23

static val RIGHT: Int

Deprecated: Deprecated in Java.

Value: 142

TRANSPOSE

Added in API level 23

static val TRANSPOSE: Int

Deprecated: Deprecated in Java.

Value: 112

UNIT

Added in API level 23

static val UNIT: Int

Deprecated: Deprecated in Java.

Value: 132

UPPER

Added in API level 23

static val UPPER: Int

Deprecated: Deprecated in Java.

Value: 121

Public methods

BNNM

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

CGBMV

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

CGEMM

Added in API level 23

fun CGEMM(
    TransA: Int, 
    TransB: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CGEMV

Added in API level 23

fun CGEMV(
    TransA: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

CGERC

Added in API level 23

fun CGERC(
    alpha: Float2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CGERU

Added in API level 23

fun CGERU(
    alpha: Float2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CHBMV

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

CHEMM

Added in API level 23

fun CHEMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CHEMV

Added in API level 23

fun CHEMV(
    Uplo: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

CHER

Added in API level 23

fun CHER(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CHER2

Added in API level 23

fun CHER2(
    Uplo: Int, 
    alpha: Float2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CHER2K

Added in API level 23

fun CHER2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CHERK

Added in API level 23

fun CHERK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float, 
    A: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CHPMV

Added in API level 23

fun CHPMV(
    Uplo: Int, 
    alpha: Float2!, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

CHPR

Added in API level 23

fun CHPR(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CHPR2

Added in API level 23

fun CHPR2(
    Uplo: Int, 
    alpha: Float2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CSYMM

Added in API level 23

fun CSYMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CSYR2K

Added in API level 23

fun CSYR2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CSYRK

Added in API level 23

fun CSYRK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    beta: Float2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CTBMV

Added in API level 23

fun CTBMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

CTBSV

Added in API level 23

fun CTBSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

CTPMV

Added in API level 23

fun CTPMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

CTPSV

Added in API level 23

fun CTPSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

CTRMM

Added in API level 23

fun CTRMM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CTRMV

Added in API level 23

fun CTRMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

CTRSM

Added in API level 23

fun CTRSM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Float2!, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

CTRSV

Added in API level 23

fun CTRSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DGBMV

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

DGEMM

Added in API level 23

fun DGEMM(
    TransA: Int, 
    TransB: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DGEMV

Added in API level 23

fun DGEMV(
    TransA: Int, 
    alpha: Double, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DGER

Added in API level 23

fun DGER(
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DSBMV

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

DSPMV

Added in API level 23

fun DSPMV(
    Uplo: Int, 
    alpha: Double, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DSPR

Added in API level 23

fun DSPR(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DSPR2

Added in API level 23

fun DSPR2(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DSYMM

Added in API level 23

fun DSYMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DSYMV

Added in API level 23

fun DSYMV(
    Uplo: Int, 
    alpha: Double, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DSYR

Added in API level 23

fun DSYR(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DSYR2

Added in API level 23

fun DSYR2(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DSYR2K

Added in API level 23

fun DSYR2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DSYRK

Added in API level 23

fun DSYRK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double, 
    A: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DTBMV

Added in API level 23

fun DTBMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DTBSV

Added in API level 23

fun DTBSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DTPMV

Added in API level 23

fun DTPMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DTPSV

Added in API level 23

fun DTPSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DTRMM

Added in API level 23

fun DTRMM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DTRMV

Added in API level 23

fun DTRMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

DTRSM

Added in API level 23

fun DTRSM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Double, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

DTRSV

Added in API level 23

fun DTRSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

SGBMV

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

SGEMM

Added in API level 23

fun SGEMM(
    TransA: Int, 
    TransB: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

SGEMV

Added in API level 23

fun SGEMV(
    TransA: Int, 
    alpha: Float, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

SGER

Added in API level 23

fun SGER(
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

SSBMV

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

SSPMV

Added in API level 23

fun SSPMV(
    Uplo: Int, 
    alpha: Float, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

SSPR

Added in API level 23

fun SSPR(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

SSPR2

Added in API level 23

fun SSPR2(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

SSYMM

Added in API level 23

fun SSYMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

SSYMV

Added in API level 23

fun SSYMV(
    Uplo: Int, 
    alpha: Float, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Float, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

SSYR

Added in API level 23

fun SSYR(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

SSYR2

Added in API level 23

fun SSYR2(
    Uplo: Int, 
    alpha: Float, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

SSYR2K

Added in API level 23

fun SSYR2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

SSYRK

Added in API level 23

fun SSYRK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Float, 
    A: Allocation!, 
    beta: Float, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

STBMV

Added in API level 23

fun STBMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

STBSV

Added in API level 23

fun STBSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

STPMV

Added in API level 23

fun STPMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

STPSV

Added in API level 23

fun STPSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

STRMM

Added in API level 23

fun STRMM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

STRMV

Added in API level 23

fun STRMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

STRSM

Added in API level 23

fun STRSM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Float, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

STRSV

Added in API level 23

fun STRSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZGBMV

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

ZGEMM

Added in API level 23

fun ZGEMM(
    TransA: Int, 
    TransB: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZGEMV

Added in API level 23

fun ZGEMV(
    TransA: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZGERC

Added in API level 23

fun ZGERC(
    alpha: Double2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZGERU

Added in API level 23

fun ZGERU(
    alpha: Double2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZHBMV

Added in API level 23

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

Deprecated: Deprecated in Java.

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

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

ZHEMM

Added in API level 23

fun ZHEMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZHEMV

Added in API level 23

fun ZHEMV(
    Uplo: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZHER

Added in API level 23

fun ZHER(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZHER2

Added in API level 23

fun ZHER2(
    Uplo: Int, 
    alpha: Double2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    A: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZHER2K

Added in API level 23

fun ZHER2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZHERK

Added in API level 23

fun ZHERK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double, 
    A: Allocation!, 
    beta: Double, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZHPMV

Added in API level 23

fun ZHPMV(
    Uplo: Int, 
    alpha: Double2!, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int, 
    beta: Double2!, 
    Y: Allocation!, 
    incY: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZHPR

Added in API level 23

fun ZHPR(
    Uplo: Int, 
    alpha: Double, 
    X: Allocation!, 
    incX: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZHPR2

Added in API level 23

fun ZHPR2(
    Uplo: Int, 
    alpha: Double2!, 
    X: Allocation!, 
    incX: Int, 
    Y: Allocation!, 
    incY: Int, 
    Ap: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZSYMM

Added in API level 23

fun ZSYMM(
    Side: Int, 
    Uplo: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZSYR2K

Added in API level 23

fun ZSYR2K(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZSYRK

Added in API level 23

fun ZSYRK(
    Uplo: Int, 
    Trans: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    beta: Double2!, 
    C: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZTBMV

Added in API level 23

fun ZTBMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZTBSV

Added in API level 23

fun ZTBSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    K: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZTPMV

Added in API level 23

fun ZTPMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZTPSV

Added in API level 23

fun ZTPSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    Ap: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZTRMM

Added in API level 23

fun ZTRMM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZTRMV

Added in API level 23

fun ZTRMV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

ZTRSM

Added in API level 23

fun ZTRSM(
    Side: Int, 
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    alpha: Double2!, 
    A: Allocation!, 
    B: Allocation!
): Unit

Deprecated: Deprecated in Java.

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

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

ZTRSV

Added in API level 23

fun ZTRSV(
    Uplo: Int, 
    TransA: Int, 
    Diag: Int, 
    A: Allocation!, 
    X: Allocation!, 
    incX: Int
): Unit

Deprecated: Deprecated in Java.

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

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

create

Added in API level 23

static fun create(rs: RenderScript!): ScriptIntrinsicBLAS!

Deprecated: Deprecated in Java.

Create an intrinsic to access BLAS subroutines.

Parameters
rs	RenderScript!: The RenderScript context

Return
ScriptIntrinsicBLAS!	ScriptIntrinsicBLAS