Skip to content

Most visited

Recently visited

navigation

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

added in version 23.0.0
int CONJ_TRANSPOSE

Constant Value: 113 (0x00000071)

LEFT

added in version 23.0.0
int LEFT

Constant Value: 141 (0x0000008d)

LOWER

added in version 23.0.0
int LOWER

Constant Value: 122 (0x0000007a)

NON_UNIT

added in version 23.0.0
int NON_UNIT

Constant Value: 131 (0x00000083)

NO_TRANSPOSE

added in version 23.0.0
int NO_TRANSPOSE

Constant Value: 111 (0x0000006f)

RIGHT

added in version 23.0.0
int RIGHT

Constant Value: 142 (0x0000008e)

TRANSPOSE

added in version 23.0.0
int TRANSPOSE

Constant Value: 112 (0x00000070)

UNIT

added in version 23.0.0
int UNIT

Constant Value: 132 (0x00000084)

UPPER

added in version 23.0.0
int UPPER

Constant Value: 121 (0x00000079)

Public methods

BNNM

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
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

added in version 23.0.0
ScriptIntrinsicBLAS create (RenderScript rs)

Create an intrinsic to access BLAS subroutines.

Parameters
rs RenderScript: The RenderScript context

Returns
ScriptIntrinsicBLAS ScriptIntrinsicBLAS

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

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Follow Google Developers on WeChat

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.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience. (Dec 2017 Android Platform & Tools Survey)