ScriptIntrinsicBLAS

``` public final class ScriptIntrinsicBLAS ```
``` ``` ``` ``` ``` ``` ``` extends ScriptIntrinsic ``` ``` ```

 java.lang.Object ↳ android.support.v8.renderscript.BaseObj ↳ android.support.v8.renderscript.Script ↳ android.support.v8.renderscript.ScriptIntrinsic ↳ android.support.v8.renderscript.ScriptIntrinsicBLAS

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

Summary

Constants

`int` `CONJ_TRANSPOSE`

`int` `LEFT`

`int` `LOWER`

`int` `NON_UNIT`

`int` `NO_TRANSPOSE`

`int` `RIGHT`

`int` `TRANSPOSE`

`int` `UNIT`

`int` `UPPER`

Public methods

``` void``` ``` BNNM(Allocation A, int a_offset, Allocation B, int b_offset, Allocation C, int c_offset, int c_mult) ```

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.

``` void``` ``` CGBMV(int TransA, int KL, int KU, Float2 alpha, Allocation A, Allocation X, int incX, Float2 beta, Allocation Y, int incY) ```

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.

``` void``` ``` CGEMM(int TransA, int TransB, Float2 alpha, Allocation A, Allocation B, Float2 beta, Allocation C) ```

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

``` void``` ``` CGEMV(int TransA, Float2 alpha, Allocation A, Allocation X, int incX, Float2 beta, Allocation Y, int incY) ```

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

``` void``` ``` CGERC(Float2 alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` CGERU(Float2 alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` CHBMV(int Uplo, int K, Float2 alpha, Allocation A, Allocation X, int incX, Float2 beta, Allocation Y, int incY) ```

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.

``` void``` ``` CHEMM(int Side, int Uplo, Float2 alpha, Allocation A, Allocation B, Float2 beta, Allocation C) ```

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

``` void``` ``` CHEMV(int Uplo, Float2 alpha, Allocation A, Allocation X, int incX, Float2 beta, Allocation Y, int incY) ```

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

``` void``` ``` CHER(int Uplo, float alpha, Allocation X, int incX, Allocation A) ```

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

``` void``` ``` CHER2(int Uplo, Float2 alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` CHER2K(int Uplo, int Trans, Float2 alpha, Allocation A, Allocation B, float beta, Allocation C) ```

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

``` void``` ``` CHERK(int Uplo, int Trans, float alpha, Allocation A, float beta, Allocation C) ```

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

``` void``` ``` CHPMV(int Uplo, Float2 alpha, Allocation Ap, Allocation X, int incX, Float2 beta, Allocation Y, int incY) ```

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'.

``` void``` ``` CHPR(int Uplo, float alpha, Allocation X, int incX, Allocation Ap) ```

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'.

``` void``` ``` CHPR2(int Uplo, Float2 alpha, Allocation X, int incX, Allocation Y, int incY, Allocation Ap) ```

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'.

``` void``` ``` CSYMM(int Side, int Uplo, Float2 alpha, Allocation A, Allocation B, Float2 beta, Allocation C) ```

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

``` void``` ``` CSYR2K(int Uplo, int Trans, Float2 alpha, Allocation A, Allocation B, Float2 beta, Allocation C) ```

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

``` void``` ``` CSYRK(int Uplo, int Trans, Float2 alpha, Allocation A, Float2 beta, Allocation C) ```

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

``` void``` ``` CTBMV(int Uplo, int TransA, int Diag, int K, Allocation A, Allocation X, int incX) ```

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.

``` void``` ``` CTBSV(int Uplo, int TransA, int Diag, int K, Allocation A, Allocation X, int incX) ```

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.

``` void``` ``` CTPMV(int Uplo, int TransA, int Diag, Allocation Ap, Allocation X, int incX) ```

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'.

``` void``` ``` CTPSV(int Uplo, int TransA, int Diag, Allocation Ap, Allocation X, int incX) ```

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'.

``` void``` ``` CTRMM(int Side, int Uplo, int TransA, int Diag, Float2 alpha, Allocation A, Allocation B) ```

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

``` void``` ``` CTRMV(int Uplo, int TransA, int Diag, Allocation A, Allocation X, int incX) ```

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

``` void``` ``` CTRSM(int Side, int Uplo, int TransA, int Diag, Float2 alpha, Allocation A, Allocation B) ```

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

``` void``` ``` CTRSV(int Uplo, int TransA, int Diag, Allocation A, Allocation X, int incX) ```

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

``` void``` ``` DGBMV(int TransA, int KL, int KU, double alpha, Allocation A, Allocation X, int incX, double beta, Allocation Y, int incY) ```

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.

``` void``` ``` DGEMM(int TransA, int TransB, double alpha, Allocation A, Allocation B, double beta, Allocation C) ```

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

``` void``` ``` DGEMV(int TransA, double alpha, Allocation A, Allocation X, int incX, double beta, Allocation Y, int incY) ```

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

``` void``` ``` DGER(double alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` DSBMV(int Uplo, int K, double alpha, Allocation A, Allocation X, int incX, double beta, Allocation Y, int incY) ```

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.

``` void``` ``` DSPMV(int Uplo, double alpha, Allocation Ap, Allocation X, int incX, double beta, Allocation Y, int incY) ```

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'.

``` void``` ``` DSPR(int Uplo, double alpha, Allocation X, int incX, Allocation Ap) ```

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'.

``` void``` ``` DSPR2(int Uplo, double alpha, Allocation X, int incX, Allocation Y, int incY, Allocation Ap) ```

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'.

``` void``` ``` DSYMM(int Side, int Uplo, double alpha, Allocation A, Allocation B, double beta, Allocation C) ```

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

``` void``` ``` DSYMV(int Uplo, double alpha, Allocation A, Allocation X, int incX, double beta, Allocation Y, int incY) ```

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

``` void``` ``` DSYR(int Uplo, double alpha, Allocation X, int incX, Allocation A) ```

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

``` void``` ``` DSYR2(int Uplo, double alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` DSYR2K(int Uplo, int Trans, double alpha, Allocation A, Allocation B, double beta, Allocation C) ```

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

``` void``` ``` DSYRK(int Uplo, int Trans, double alpha, Allocation A, double beta, Allocation C) ```

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

``` void``` ``` DTBMV(int Uplo, int TransA, int Diag, int K, Allocation A, Allocation X, int incX) ```

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.

``` void``` ``` DTBSV(int Uplo, int TransA, int Diag, int K, Allocation A, Allocation X, int incX) ```

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.

``` void``` ``` DTPMV(int Uplo, int TransA, int Diag, Allocation Ap, Allocation X, int incX) ```

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'.

``` void``` ``` DTPSV(int Uplo, int TransA, int Diag, Allocation Ap, Allocation X, int incX) ```

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'.

``` void``` ``` DTRMM(int Side, int Uplo, int TransA, int Diag, double alpha, Allocation A, Allocation B) ```

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

``` void``` ``` DTRMV(int Uplo, int TransA, int Diag, Allocation A, Allocation X, int incX) ```

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

``` void``` ``` DTRSM(int Side, int Uplo, int TransA, int Diag, double alpha, Allocation A, Allocation B) ```

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

``` void``` ``` DTRSV(int Uplo, int TransA, int Diag, Allocation A, Allocation X, int incX) ```

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

``` void``` ``` SGBMV(int TransA, int KL, int KU, float alpha, Allocation A, Allocation X, int incX, float beta, Allocation Y, int incY) ```

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.

``` void``` ``` SGEMM(int TransA, int TransB, float alpha, Allocation A, Allocation B, float beta, Allocation C) ```

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

``` void``` ``` SGEMV(int TransA, float alpha, Allocation A, Allocation X, int incX, float beta, Allocation Y, int incY) ```

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

``` void``` ``` SGER(float alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` SSBMV(int Uplo, int K, float alpha, Allocation A, Allocation X, int incX, float beta, Allocation Y, int incY) ```

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.

``` void``` ``` SSPMV(int Uplo, float alpha, Allocation Ap, Allocation X, int incX, float beta, Allocation Y, int incY) ```

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'.

``` void``` ``` SSPR(int Uplo, float alpha, Allocation X, int incX, Allocation Ap) ```

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'.

``` void``` ``` SSPR2(int Uplo, float alpha, Allocation X, int incX, Allocation Y, int incY, Allocation Ap) ```

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'.

``` void``` ``` SSYMM(int Side, int Uplo, float alpha, Allocation A, Allocation B, float beta, Allocation C) ```

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

``` void``` ``` SSYMV(int Uplo, float alpha, Allocation A, Allocation X, int incX, float beta, Allocation Y, int incY) ```

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

``` void``` ``` SSYR(int Uplo, float alpha, Allocation X, int incX, Allocation A) ```

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

``` void``` ``` SSYR2(int Uplo, float alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` SSYR2K(int Uplo, int Trans, float alpha, Allocation A, Allocation B, float beta, Allocation C) ```

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

``` void``` ``` SSYRK(int Uplo, int Trans, float alpha, Allocation A, float beta, Allocation C) ```

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

``` void``` ``` STBMV(int Uplo, int TransA, int Diag, int K, Allocation A, Allocation X, int incX) ```

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.

``` void``` ``` STBSV(int Uplo, int TransA, int Diag, int K, Allocation A, Allocation X, int incX) ```

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.

``` void``` ``` STPMV(int Uplo, int TransA, int Diag, Allocation Ap, Allocation X, int incX) ```

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'.

``` void``` ``` STPSV(int Uplo, int TransA, int Diag, Allocation Ap, Allocation X, int incX) ```

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'.

``` void``` ``` STRMM(int Side, int Uplo, int TransA, int Diag, float alpha, Allocation A, Allocation B) ```

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

``` void``` ``` STRMV(int Uplo, int TransA, int Diag, Allocation A, Allocation X, int incX) ```

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

``` void``` ``` STRSM(int Side, int Uplo, int TransA, int Diag, float alpha, Allocation A, Allocation B) ```

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

``` void``` ``` STRSV(int Uplo, int TransA, int Diag, Allocation A, Allocation X, int incX) ```

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

``` void``` ``` ZGBMV(int TransA, int KL, int KU, Double2 alpha, Allocation A, Allocation X, int incX, Double2 beta, Allocation Y, int incY) ```

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.

``` void``` ``` ZGEMM(int TransA, int TransB, Double2 alpha, Allocation A, Allocation B, Double2 beta, Allocation C) ```

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

``` void``` ``` ZGEMV(int TransA, Double2 alpha, Allocation A, Allocation X, int incX, Double2 beta, Allocation Y, int incY) ```

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

``` void``` ``` ZGERC(Double2 alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` ZGERU(Double2 alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` ZHBMV(int Uplo, int K, Double2 alpha, Allocation A, Allocation X, int incX, Double2 beta, Allocation Y, int incY) ```

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.

``` void``` ``` ZHEMM(int Side, int Uplo, Double2 alpha, Allocation A, Allocation B, Double2 beta, Allocation C) ```

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

``` void``` ``` ZHEMV(int Uplo, Double2 alpha, Allocation A, Allocation X, int incX, Double2 beta, Allocation Y, int incY) ```

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

``` void``` ``` ZHER(int Uplo, double alpha, Allocation X, int incX, Allocation A) ```

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

``` void``` ``` ZHER2(int Uplo, Double2 alpha, Allocation X, int incX, Allocation Y, int incY, Allocation A) ```

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

``` void``` ``` ZHER2K(int Uplo, int Trans, Double2 alpha, Allocation A, Allocation B, double beta, Allocation C) ```

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

``` void``` ``` ZHERK(int Uplo, int Trans, double alpha, Allocation A, double beta, Allocation C) ```

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

``` void``` ``` ZHPMV(int Uplo, Double2 alpha, Allocation Ap, Allocation X, int incX, Double2 beta, Allocation Y, int incY) ```

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'.

``` void``` ``` ZHPR(int Uplo, double alpha, Allocation X, int incX, Allocation Ap) ```

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'.

``` void``` ``` ZHPR2(int Uplo, Double2 alpha, Allocation X, int incX, Allocation Y, int incY, Allocation Ap) ```

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'.

``` void``` ``` ZSYMM(int Side, int Uplo, Double2 alpha, Allocation A, Allocation B, Double2 beta, Allocation C) ```

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

``` void``` ``` ZSYR2K(int Uplo, int Trans, Double2 alpha, Allocation A, Allocation B, Double2 beta, Allocation C) ```

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

``` void``` ``` ZSYRK(int Uplo, int Trans, Double2 alpha, Allocation A, Double2 beta, Allocation C) ```

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

``` void``` ``` ZTBMV(int Uplo, int TransA, int Diag, int K, Allocation A, Allocation X, int incX) ```

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.

``` void``` ``` ZTBSV(int Uplo, int TransA, int Diag, int K, Allocation A, Allocation X, int incX) ```

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.

``` void``` ``` ZTPMV(int Uplo, int TransA, int Diag, Allocation Ap, Allocation X, int incX) ```

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'.

``` void``` ``` ZTPSV(int Uplo, int TransA, int Diag, Allocation Ap, Allocation X, int incX) ```

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'.

``` void``` ``` ZTRMM(int Side, int Uplo, int TransA, int Diag, Double2 alpha, Allocation A, Allocation B) ```

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

``` void``` ``` ZTRMV(int Uplo, int TransA, int Diag, Allocation A, Allocation X, int incX) ```

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

``` void``` ``` ZTRSM(int Side, int Uplo, int TransA, int Diag, Double2 alpha, Allocation A, Allocation B) ```

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

``` void``` ``` ZTRSV(int Uplo, int TransA, int Diag, Allocation A, Allocation X, int incX) ```

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

``` static ScriptIntrinsicBLAS``` ``` create(RenderScript rs) ```

Create an intrinsic to access BLAS subroutines.

Inherited methods

From class ``` android.support.v8.renderscript.Script ```
From class ``` android.support.v8.renderscript.BaseObj ```
From class ``` java.lang.Object ```

Constants

CONJ_TRANSPOSE

`int CONJ_TRANSPOSE`

Constant Value: 113 (0x00000071)

LEFT

`int LEFT`

Constant Value: 141 (0x0000008d)

LOWER

`int LOWER`

Constant Value: 122 (0x0000007a)

NON_UNIT

`int NON_UNIT`

Constant Value: 131 (0x00000083)

NO_TRANSPOSE

`int NO_TRANSPOSE`

Constant Value: 111 (0x0000006f)

RIGHT

`int RIGHT`

Constant Value: 142 (0x0000008e)

TRANSPOSE

`int TRANSPOSE`

Constant Value: 112 (0x00000070)

UNIT

`int UNIT`

Constant Value: 132 (0x00000084)

UPPER

`int UPPER`

Constant Value: 121 (0x00000079)

Public methods

BNNM

```void BNNM (Allocation A,
int a_offset,
Allocation B,
int b_offset,
Allocation C,
int c_offset,
int c_mult)```

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 `U8(RenderScript)`.

`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 `U8(RenderScript)`.

`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 `U8(RenderScript)`.

`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

```void CGBMV (int TransA,
int KL,
int KU,
Float2 alpha,
Allocation A,
Allocation X,
int incX,
Float2 beta,
Allocation Y,
int incY)```

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.

`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 `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

CGEMM

```void CGEMM (int TransA,
int TransB,
Float2 alpha,
Allocation A,
Allocation B,
Float2 beta,
Allocation C)```

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.

`TransB` `int`: The type of transpose applied to matrix B.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

`beta` `Float2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

CGEMV

```void CGEMV (int TransA,
Float2 alpha,
Allocation A,
Allocation X,
int incX,
Float2 beta,
Allocation Y,
int incY)```

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.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

CGERC

```void CGERC (Float2 alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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 `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

CGERU

```void CGERU (Float2 alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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 `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

CHBMV

```void CHBMV (int Uplo,
int K,
Float2 alpha,
Allocation A,
Allocation X,
int incX,
Float2 beta,
Allocation Y,
int incY)```

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.

`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 `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

CHEMM

```void CHEMM (int Side,
int Uplo,
Float2 alpha,
Allocation A,
Allocation B,
Float2 beta,
Allocation C)```

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.

`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

`beta` `Float2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

CHEMV

```void CHEMV (int Uplo,
Float2 alpha,
Allocation A,
Allocation X,
int incX,
Float2 beta,
Allocation Y,
int incY)```

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.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

CHER

```void CHER (int Uplo,
float alpha,
Allocation X,
int incX,
Allocation A)```

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.

`alpha` `float`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

CHER2

```void CHER2 (int Uplo,
Float2 alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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.

`alpha` `Float2`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

CHER2K

```void CHER2K (int Uplo,
int Trans,
Float2 alpha,
Allocation A,
Allocation B,
float beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

`beta` `float`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

CHERK

```void CHERK (int Uplo,
int Trans,
float alpha,
Allocation A,
float beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`beta` `float`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

CHPMV

```void CHPMV (int Uplo,
Float2 alpha,
Allocation Ap,
Allocation X,
int incX,
Float2 beta,
Allocation Y,
int incY)```

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.

`alpha` `Float2`: The scalar alpha.

`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

CHPR

```void CHPR (int Uplo,
float alpha,
Allocation X,
int incX,
Allocation Ap)```

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.

`alpha` `float`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

CHPR2

```void CHPR2 (int Uplo,
Float2 alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation Ap)```

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.

`alpha` `Float2`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

`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 `F32_2(RenderScript)`.

CSYMM

```void CSYMM (int Side,
int Uplo,
Float2 alpha,
Allocation A,
Allocation B,
Float2 beta,
Allocation C)```

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.

`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

`beta` `Float2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

CSYR2K

```void CSYR2K (int Uplo,
int Trans,
Float2 alpha,
Allocation A,
Allocation B,
Float2 beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

`beta` `Float2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

CSYRK

```void CSYRK (int Uplo,
int Trans,
Float2 alpha,
Allocation A,
Float2 beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`beta` `Float2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

CTBMV

```void CTBMV (int Uplo,
int TransA,
int Diag,
int K,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`K` `int`: The number of off-diagonals of the matrix A

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

CTBSV

```void CTBSV (int Uplo,
int TransA,
int Diag,
int K,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`K` `int`: The number of off-diagonals of the matrix A

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

CTPMV

```void CTPMV (int Uplo,
int TransA,
int Diag,
Allocation Ap,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

CTPSV

```void CTPSV (int Uplo,
int TransA,
int Diag,
Allocation Ap,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

CTRMM

```void CTRMM (int Side,
int Uplo,
int TransA,
int Diag,
Float2 alpha,
Allocation A,
Allocation B)```

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.

`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

CTRMV

```void CTRMV (int Uplo,
int TransA,
int Diag,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

CTRSM

```void CTRSM (int Side,
int Uplo,
int TransA,
int Diag,
Float2 alpha,
Allocation A,
Allocation B)```

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.

`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`alpha` `Float2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

CTRSV

```void CTRSV (int Uplo,
int TransA,
int Diag,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

DGBMV

```void DGBMV (int TransA,
int KL,
int KU,
double alpha,
Allocation A,
Allocation X,
int incX,
double beta,
Allocation Y,
int incY)```

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.

`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 `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

DGEMM

```void DGEMM (int TransA,
int TransB,
double alpha,
Allocation A,
Allocation B,
double beta,
Allocation C)```

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.

`TransB` `int`: The type of transpose applied to matrix B.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.

`beta` `double`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64(RenderScript)`.

DGEMV

```void DGEMV (int TransA,
double alpha,
Allocation A,
Allocation X,
int incX,
double beta,
Allocation Y,
int incY)```

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.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

DGER

```void DGER (double alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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 `F64(RenderScript)`.

`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 `F64(RenderScript)`.

`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 `F64(RenderScript)`.

DSBMV

```void DSBMV (int Uplo,
int K,
double alpha,
Allocation A,
Allocation X,
int incX,
double beta,
Allocation Y,
int incY)```

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.

`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 `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

DSPMV

```void DSPMV (int Uplo,
double alpha,
Allocation Ap,
Allocation X,
int incX,
double beta,
Allocation Y,
int incY)```

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.

`alpha` `double`: The scalar alpha.

`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

DSPR

```void DSPR (int Uplo,
double alpha,
Allocation X,
int incX,
Allocation Ap)```

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.

`alpha` `double`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

DSPR2

```void DSPR2 (int Uplo,
double alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation Ap)```

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.

`alpha` `double`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

`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 `F64(RenderScript)`.

DSYMM

```void DSYMM (int Side,
int Uplo,
double alpha,
Allocation A,
Allocation B,
double beta,
Allocation C)```

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.

`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.

`beta` `double`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64(RenderScript)`.

DSYMV

```void DSYMV (int Uplo,
double alpha,
Allocation A,
Allocation X,
int incX,
double beta,
Allocation Y,
int incY)```

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.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

DSYR

```void DSYR (int Uplo,
double alpha,
Allocation X,
int incX,
Allocation A)```

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.

`alpha` `double`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

DSYR2

```void DSYR2 (int Uplo,
double alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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.

`alpha` `double`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`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 `F64(RenderScript)`.

`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 `F64(RenderScript)`.

DSYR2K

```void DSYR2K (int Uplo,
int Trans,
double alpha,
Allocation A,
Allocation B,
double beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.

`beta` `double`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64(RenderScript)`.

DSYRK

```void DSYRK (int Uplo,
int Trans,
double alpha,
Allocation A,
double beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`beta` `double`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64(RenderScript)`.

DTBMV

```void DTBMV (int Uplo,
int TransA,
int Diag,
int K,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`K` `int`: The number of off-diagonals of the matrix A

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

DTBSV

```void DTBSV (int Uplo,
int TransA,
int Diag,
int K,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`K` `int`: The number of off-diagonals of the matrix A

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

DTPMV

```void DTPMV (int Uplo,
int TransA,
int Diag,
Allocation Ap,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

DTPSV

```void DTPSV (int Uplo,
int TransA,
int Diag,
Allocation Ap,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

DTRMM

```void DTRMM (int Side,
int Uplo,
int TransA,
int Diag,
double alpha,
Allocation A,
Allocation B)```

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.

`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.

DTRMV

```void DTRMV (int Uplo,
int TransA,
int Diag,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

DTRSM

```void DTRSM (int Side,
int Uplo,
int TransA,
int Diag,
double alpha,
Allocation A,
Allocation B)```

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.

`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.

DTRSV

```void DTRSV (int Uplo,
int TransA,
int Diag,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

SGBMV

```void SGBMV (int TransA,
int KL,
int KU,
float alpha,
Allocation A,
Allocation X,
int incX,
float beta,
Allocation Y,
int incY)```

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.

`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 `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

SGEMM

```void SGEMM (int TransA,
int TransB,
float alpha,
Allocation A,
Allocation B,
float beta,
Allocation C)```

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.

`TransB` `int`: The type of transpose applied to matrix B.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.

`beta` `float`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32(RenderScript)`.

SGEMV

```void SGEMV (int TransA,
float alpha,
Allocation A,
Allocation X,
int incX,
float beta,
Allocation Y,
int incY)```

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.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

SGER

```void SGER (float alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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 `F32(RenderScript)`.

`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 `F32(RenderScript)`.

`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 `F32(RenderScript)`.

SSBMV

```void SSBMV (int Uplo,
int K,
float alpha,
Allocation A,
Allocation X,
int incX,
float beta,
Allocation Y,
int incY)```

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.

`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 `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

SSPMV

```void SSPMV (int Uplo,
float alpha,
Allocation Ap,
Allocation X,
int incX,
float beta,
Allocation Y,
int incY)```

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.

`alpha` `float`: The scalar alpha.

`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

SSPR

```void SSPR (int Uplo,
float alpha,
Allocation X,
int incX,
Allocation Ap)```

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.

`alpha` `float`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

SSPR2

```void SSPR2 (int Uplo,
float alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation Ap)```

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.

`alpha` `float`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

`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 `F32(RenderScript)`.

SSYMM

```void SSYMM (int Side,
int Uplo,
float alpha,
Allocation A,
Allocation B,
float beta,
Allocation C)```

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.

`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.

`beta` `float`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32(RenderScript)`.

SSYMV

```void SSYMV (int Uplo,
float alpha,
Allocation A,
Allocation X,
int incX,
float beta,
Allocation Y,
int incY)```

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.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

SSYR

```void SSYR (int Uplo,
float alpha,
Allocation X,
int incX,
Allocation A)```

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.

`alpha` `float`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

SSYR2

```void SSYR2 (int Uplo,
float alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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.

`alpha` `float`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`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 `F32(RenderScript)`.

`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 `F32(RenderScript)`.

SSYR2K

```void SSYR2K (int Uplo,
int Trans,
float alpha,
Allocation A,
Allocation B,
float beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.

`beta` `float`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32(RenderScript)`.

SSYRK

```void SSYRK (int Uplo,
int Trans,
float alpha,
Allocation A,
float beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`beta` `float`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32(RenderScript)`.

STBMV

```void STBMV (int Uplo,
int TransA,
int Diag,
int K,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`K` `int`: The number of off-diagonals of the matrix A

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

STBSV

```void STBSV (int Uplo,
int TransA,
int Diag,
int K,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`K` `int`: The number of off-diagonals of the matrix A

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

STPMV

```void STPMV (int Uplo,
int TransA,
int Diag,
Allocation Ap,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

STPSV

```void STPSV (int Uplo,
int TransA,
int Diag,
Allocation Ap,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

STRMM

```void STRMM (int Side,
int Uplo,
int TransA,
int Diag,
float alpha,
Allocation A,
Allocation B)```

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.

`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.

STRMV

```void STRMV (int Uplo,
int TransA,
int Diag,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

STRSM

```void STRSM (int Side,
int Uplo,
int TransA,
int Diag,
float alpha,
Allocation A,
Allocation B)```

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.

`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`alpha` `float`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.

STRSV

```void STRSV (int Uplo,
int TransA,
int Diag,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

ZGBMV

```void ZGBMV (int TransA,
int KL,
int KU,
Double2 alpha,
Allocation A,
Allocation X,
int incX,
Double2 beta,
Allocation Y,
int incY)```

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.

`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 `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

ZGEMM

```void ZGEMM (int TransA,
int TransB,
Double2 alpha,
Allocation A,
Allocation B,
Double2 beta,
Allocation C)```

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.

`TransB` `int`: The type of transpose applied to matrix B.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type {@link Element#F64_2

`B` `Allocation`: The input allocation contains matrix B, supported elements type {@link Element#F64_2

`beta` `Double2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type {@link Element#F64_2

ZGEMV

```void ZGEMV (int TransA,
Double2 alpha,
Allocation A,
Allocation X,
int incX,
Double2 beta,
Allocation Y,
int incY)```

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.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

ZGERC

```void ZGERC (Double2 alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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 `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

ZGERU

```void ZGERU (Double2 alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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 `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

ZHBMV

```void ZHBMV (int Uplo,
int K,
Double2 alpha,
Allocation A,
Allocation X,
int incX,
Double2 beta,
Allocation Y,
int incY)```

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.

`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 `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

ZHEMM

```void ZHEMM (int Side,
int Uplo,
Double2 alpha,
Allocation A,
Allocation B,
Double2 beta,
Allocation C)```

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.

`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.

`beta` `Double2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

ZHEMV

```void ZHEMV (int Uplo,
Double2 alpha,
Allocation A,
Allocation X,
int incX,
Double2 beta,
Allocation Y,
int incY)```

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.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

ZHER

```void ZHER (int Uplo,
double alpha,
Allocation X,
int incX,
Allocation A)```

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.

`alpha` `double`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

ZHER2

```void ZHER2 (int Uplo,
Double2 alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation A)```

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.

`alpha` `Double2`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

ZHER2K

```void ZHER2K (int Uplo,
int Trans,
Double2 alpha,
Allocation A,
Allocation B,
double beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.

`beta` `double`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

ZHERK

```void ZHERK (int Uplo,
int Trans,
double alpha,
Allocation A,
double beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `double`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`beta` `double`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

ZHPMV

```void ZHPMV (int Uplo,
Double2 alpha,
Allocation Ap,
Allocation X,
int incX,
Double2 beta,
Allocation Y,
int incY)```

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.

`alpha` `Double2`: The scalar alpha.

`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`incY` `int`: The increment for the elements of vector y, must be larger than zero.

ZHPR

```void ZHPR (int Uplo,
double alpha,
Allocation X,
int incX,
Allocation Ap)```

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.

`alpha` `double`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

ZHPR2

```void ZHPR2 (int Uplo,
Double2 alpha,
Allocation X,
int incX,
Allocation Y,
int incY,
Allocation Ap)```

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.

`alpha` `Double2`: The scalar alpha.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

`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 `F64_2(RenderScript)`.

ZSYMM

```void ZSYMM (int Side,
int Uplo,
Double2 alpha,
Allocation A,
Allocation B,
Double2 beta,
Allocation C)```

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.

`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.

`beta` `Double2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

ZSYR2K

```void ZSYR2K (int Uplo,
int Trans,
Double2 alpha,
Allocation A,
Allocation B,
Double2 beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.

`beta` `Double2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

ZSYRK

```void ZSYRK (int Uplo,
int Trans,
Double2 alpha,
Allocation A,
Double2 beta,
Allocation C)```

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.

`Trans` `int`: The type of transpose applied to the operation.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`beta` `Double2`: The scalar beta.

`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

ZTBMV

```void ZTBMV (int Uplo,
int TransA,
int Diag,
int K,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`K` `int`: The number of off-diagonals of the matrix A

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

ZTBSV

```void ZTBSV (int Uplo,
int TransA,
int Diag,
int K,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`K` `int`: The number of off-diagonals of the matrix A

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

ZTPMV

```void ZTPMV (int Uplo,
int TransA,
int Diag,
Allocation Ap,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

ZTPSV

```void ZTPSV (int Uplo,
int TransA,
int Diag,
Allocation Ap,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

ZTRMM

```void ZTRMM (int Side,
int Uplo,
int TransA,
int Diag,
Double2 alpha,
Allocation A,
Allocation B)```

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.

`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.

ZTRMV

```void ZTRMV (int Uplo,
int TransA,
int Diag,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

ZTRSM

```void ZTRSM (int Side,
int Uplo,
int TransA,
int Diag,
Double2 alpha,
Allocation A,
Allocation B)```

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.

`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`alpha` `Double2`: The scalar alpha.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.

ZTRSV

```void ZTRSV (int Uplo,
int TransA,
int Diag,
Allocation A,
Allocation X,
int incX)```

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.

`TransA` `int`: The type of transpose applied to matrix A.

`Diag` `int`: Specifies whether or not A is unit triangular.

`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.

`incX` `int`: The increment for the elements of vector x, must be larger than zero.

create

`ScriptIntrinsicBLAS create (RenderScript rs)`

Create an intrinsic to access BLAS subroutines.

Parameters
`rs` `RenderScript`: The RenderScript context

Returns
`ScriptIntrinsicBLAS` ScriptIntrinsicBLAS

• Exceptions

This site uses cookies to store your preferences for site-specific language and display options.

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.