# ScriptIntrinsicBLAS

`public final class ScriptIntrinsicBLAS`
`extends ScriptIntrinsic`

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

ScriptIntrinsicBLAS类为BLAS提供了高性能的RenderScript API。 BLAS（基本线性代数子程序）是为执行基本向量和矩阵操作提供标准构建块的例程。 有关BLAS的详细说明，请参阅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) `

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

CGBMV执行矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y或y：= alpha * A ** H * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d0/d75/cgbmv_8f.html注意：对于M * N矩阵，输入分配的大小也应为M * N（dimY = M，dimX = N），但仅引用区域M *（KL + KU + 1）。

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

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

CGEMV执行矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y或y：= alpha * A ** H * x + beta * y详细信息：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执行等级1操作A：= alpha * x * y ** H + A详细信息：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执行等级1操作A：= alpha * x * y ** T + A详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/db/dc2/chbmv_8f.html注意：对于N * N矩阵时，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。

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

CHEMM执行矩阵操作之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：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执行等级1操作A：= alpha * x * x ** H + A详细信息：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执行对称秩2操作A：= alpha * x * y ** H + alpha * y * x ** H + A详细信息：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执行埃尔米特秩2k操作之一C：= alpha * A * B ** H + conjgα* B * A ** H + beta * C或C：= alpha * A ** H * B + conjg （alpha）* B ** H * A + beta * C详情：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执行厄密特级k操作之一C：= alpha * A * A ** H + beta * C或C：= alpha * A ** H * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d2/d06/chpmv_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

CHPR执行等级1操作A：= alpha * x * x ** H + A详细信息：http：//www.netlib.org/lapack/explore-html/db/dcd/chpr_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

CHPR2执行对称秩2操作A：= alpha * x * y ** H + alpha * y * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/d6/d44 /chpr2_8f.html注意：对于N×N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，下面的子例程can是一个示例，显示如何将UPPER三角矩阵'a'填充矩阵'b'。

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

CSYMM执行矩阵操作之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：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执行对称秩2k操作之一C：= alpha * A * B ** T + alpha * B * A ** T + beta * C或C：= alpha * A ** T * B + alpha * B * * T * A + beta * C详情：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执行对称秩K运算之一C：= alpha * A * A ** T + beta * C或C：= alpha * A ** T * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML / D3 / D6A / csyrk_8f.html

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

CTBMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / d3 / dcd / ctbmv_8f.html注意：对于一个N * N矩阵，输入分配的大小也应该是N * N（dimY = N，dimX = N），但只有区域N *（K + 1 ）将被引用。

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

CTBSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d9 /d5f/ctbsv_8f.html注意：对于N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但只会引用区域N *（K + 1） 。

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

CTPMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / d4 / dbb / ctpmv_8f.html注意：对于N×N矩阵，输入分配应该是大小为dimX = N *（N + 1）/ 2的一维分配，下面的子例程can可以举例说明将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

CTPSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d8 /d56/ctpsv_8f.html注意：对于一个N * N矩阵，输入分配应该是一个尺寸为dimX = N *（N + 1）/ 2的一维分配，以下子例程can可以显示如何将一个UPPER三角矩阵'a'到压缩矩阵'b'。

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

CTRMM执行矩阵操作之一B：= alpha * op（A）* B或B：= alpha * B * op（A）op（A）是op（A）= A或op = A ** T或op（A）= A ** H详情：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执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：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求解一个矩阵方程op（A）* X：= alpha * B或X * op（A）：= alpha * B op（A）是op（A）= A或op（A）= A ** T或op（A）= A ** H详情：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求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：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执行矩阵向量运算之一y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y详细信息：http://www.netlib.org/lapack /explore-html/d2/d3f/dgbmv_8f.html注意：对于M * N矩阵，输入分配的大小也应为M * N（dimY = M，dimX = N），但只有区域M *（KL + KU + 1）将被引用。

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

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

DGEMV执行矩阵向量运算之一y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y详细信息：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执行1级操作A：= alpha * x * y ** T + A详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d8/d1e/dsbmv_8f.html注意：对于N * N矩阵时，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。

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

DSPMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d4/d85/dspmv_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

DSPR执行等级1操作A：= alpha * x * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/dd/dba/dspr_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

DSPR2执行对称秩2操作A：= alpha * x * y ** T + alpha * y * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/dd/d9e /dspr2_8f.html注意：对于N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can可以显示如何将UPPER三角矩阵'a'填充矩阵'b'。

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

DSYMM执行矩阵运算之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：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执行等级1操作A：= alpha * x * x ** T + A详细信息：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执行对称秩2操作A：= alpha * x * y ** T + alpha * y * x ** T + A详细信息：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执行对称秩2k运算之一C：= alpha * A * B ** T + alpha * B * A ** T + beta * C或C：= alpha * A ** T * B + alpha * B * * T * A + beta * C详情：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执行对称秩k操作之一C：= alpha * A * A ** T + beta * C或C：= alpha * A ** T * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML / DC / D05 / dsyrk_8f.html

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

DTBMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/df/d29/dtbmv_8f.html注意：对于N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。

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

DTBSV求解方程组A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d4/dcf/dtbsv_8f.html注意：对于一个N * N矩阵，输入分配的大小也应该是N * N（dimY = N，dimX = N），但是只有区域N *（K + 1）将被引用。

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

DTPMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/dc/dcd/dtpmv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can是一个示例，显示如何将UPPER三角矩阵'a'转换为填充矩阵'b'。

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

DTPSV求解方程A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d9/d84/dtpsv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1D的分配dimX = N *（N + 1）/ 2，以下子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵' b”。

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

DTRMM执行矩阵操作之一B：= alpha * op（A）* B或B：= alpha * B * op（A）op（A）是op（A）= A或op = A ** T详情：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执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：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求解一个矩阵方程op（A）* X：= alpha * B或X * op（A）：= alpha * B op（A）是op（A）= A或op（A）= A ** T详细信息：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求解方程组A * x = b或A ** T * x = b的系统之一详细信息：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执行一个矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y详细信息：http://www.netlib.org/lapack /explore-html/d6/d46/sgbmv_8f.html注意：对于M * N矩阵，输入分配的大小也应为M * N（dimY = M，dimX = N），但只有区域M *（KL + KU + 1）将被引用。

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

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

SGEMV执行矩阵向量运算之一y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y详细信息：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执行1级操作A：= alpha * x * y ** T + A详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d3/da1/ssbmv_8f.html注意：对于N * N矩阵时，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。

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

SSPMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d8/d68/sspmv_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

SSPR执行等级1操作A：= alpha * x * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/d2/d9b/sspr_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

SSPR2执行对称秩2操作A：= alpha * x * y ** T + alpha * y * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/db/d3e /sspr2_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can可以显示如何将UPPER三角矩阵'a'填充矩阵'b'。

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

SSYMM执行矩阵操作之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：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执行等级1操作A：= alpha * x * x ** T + A详细信息：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执行对称秩2操作A：= alpha * x * y ** T + alpha * y * x ** T + A详细信息：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执行对称秩2k操作之一C：= alpha * A * B ** T + alpha * B * A ** T + beta * C或C：= alpha * A ** T * B + alpha * B * * T * A + beta * C详情：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执行对称秩k操作之一C：= alpha * A * A ** T + beta * C或C：= alpha * A ** T * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML / D0 / D40 / ssyrk_8f.html

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

STBMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/d6/d7d/stbmv_8f.html注意：对于N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。

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

STBSV求解方程A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d0/d1f/stbsv_8f.html注意：对于一个N * N矩阵，输入分配的大小也应该是N * N（dimY = N，dimX = N），但是只有区域N *（K + 1）将被引用。

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

STPMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/db/db1/stpmv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can是一个示例，显示如何将UPPER三角矩阵'a'转换为填充矩阵'b'。

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

STPSV求解方程A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d0/d7c/stpsv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1D的分配dimX = N *（N + 1）/ 2，以下子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵' b”。

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

STRMM执行矩阵操作之一B：= alpha * op（A）* B或B：= alpha * B * op（A）op（A）是op（A）= A或op（A） = A ** T详情：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执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：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求解一个矩阵方程op（A）* X：= alpha * B或X * op（A）：= alpha * B op（A）是op（A）= A或op（A）= A ** T详细信息：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求解方程组A * x = b或A ** T * x = b的系统之一详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y或y：= alpha * A ** H * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d9/d46/zgbmv_8f.html注意：对于M * N矩阵，输入分配的大小也应为M * N（dimY = M，dimX = N），但仅引用区域M *（KL + KU + 1）。

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

ZGEMM执行一个矩阵矩阵运算C：= alpha * op（A）* op（B）+ beta * C其中op（X）是op（X）= X或op（X）= X **之一T或op（X）= X ** H详细信息：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执行一个矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y或y：= alpha * A ** H * x + beta * y详细信息：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执行等级1操作A：= alpha * x * y ** H + A详细信息：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执行等级1操作A：= alpha * x * y ** T + A详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d3/d1a/zhbmv_8f.html注意：对于N * N矩阵时，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。

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

ZHEMM执行矩阵运算之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：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执行等级1操作A：= alpha * x * x ** H + A详细信息：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执行对称秩2操作A：= alpha * x * y ** H + alpha * y * x ** H + A详细信息：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执行埃米特级别2k操作之一C：= alpha * A * B ** H + conjgα* B * A ** H + beta * C或C：= alpha * A ** H * B + conjg （alpha）* B ** H * A + beta * C详情：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执行厄密特级k操作之一C：= alpha * A * A ** H + beta * C或C：= alpha * A ** H * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-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执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d0/d60/zhpmv_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

ZHPR执行等级1操作A：= alpha * x * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/de/de1/zhpr_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

ZHPR2执行对称秩2操作A：= alpha * x * y ** H + alpha * y * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/d5/d52 /zhpr2_8f.html注意：对于N×N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，下面的子例程can是一个示例，显示如何将UPPER三角矩阵'a'填充矩阵'b'。

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

ZSYMM执行矩阵操作之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：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执行对称秩2k运算之一C：= alpha * A * B ** T + alpha * B * A ** T + beta * C或C：= alpha * A ** T * B + alpha * B * * T * A + beta * C详情：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执行对称秩k操作之一C：= alpha * A * A ** T + beta * C或C：= alpha * A ** T * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML /德/ D54 / zsyrk_8f.html

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

ZTBMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / d3 / d39 / ztbmv_8f.html注意：对于一个N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但只有区域N *（K + 1 ）将被引用。

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

ZTBSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d4 /d5a/ztbsv_8f.html注意：对于N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但只有区域N *（K + 1）将被引用。

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

ZTPMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / d2 / d9e / ztpmv_8f.html注意：对于N×N矩阵，输入分配应该是大小为dimX = N *（N + 1）/ 2的一维分配，以下子例程can可以是一个示例将UPPER三角矩阵'a'转换为压缩矩阵'b'。

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

ZTPSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/da /d57/ztpsv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can可以显示如何将UPPER三角矩阵'a'到压缩矩阵'b'。

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

ZTRMM执行矩阵运算之一B：= alpha * op（A）* B或B：= alpha * B * op（A）op（A）是op（A）= A或op = A ** T或op（A）= A ** H详情：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执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：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求解一个矩阵方程op（A）* X：= alpha * B或X * op（A）：= alpha * B op（A）是op（A）= A或op（A）= A ** T或op（A）= A ** H详情：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求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d1 /d2f/ztrsv_8f.html

` static ScriptIntrinsicBLAS` ` create(RenderScript rs) `

### Inherited methods

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

## Constants

### CONJ_TRANSPOSE

`int CONJ_TRANSPOSE`

### LEFT

`int LEFT`

### LOWER

`int LOWER`

### NON_UNIT

`int NON_UNIT`

### NO_TRANSPOSE

`int NO_TRANSPOSE`

### RIGHT

`int RIGHT`

### TRANSPOSE

`int TRANSPOSE`

### UNIT

`int UNIT`

### UPPER

`int UPPER`

## Public methods

### BNNM

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

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

### CGBMV

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

CGBMV执行矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y或y：= alpha * A ** H * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d0/d75/cgbmv_8f.html注意：对于M * N矩阵，输入分配的大小也应为M * N（dimY = M，dimX = N），但仅引用区域M *（KL + KU + 1）。 下面的子程序可以显示如何将原始矩阵'a'转换为基于行的频带矩阵'b'。 对于范围内的i（0，m）：对于范围内的j（max（0，i-kl），min（i + ku + 1，n））：b [i，j- i + kl] = a [i ，j]

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`KL` `int`: The number of sub-diagonals of the matrix A.
`KU` `int`: The number of super-diagonals of the matrix A.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains the band matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Float2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### CGEMM

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

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`TransB` `int`: The type of transpose applied to matrix B.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.
`beta` `Float2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

### CGEMV

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

CGEMV执行矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y或y：= alpha * A ** H * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d4/d8a/cgemv_8f.html

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Float2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### CGERC

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

CGERC执行等级1操作A：= alpha * x * y ** H + A详细信息：http://www.netlib.org/lapack/explore-html/dd/d84/cgerc_8f.html

Parameters
`alpha` `Float2`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

### CGERU

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

CGERU执行等级1操作A：= alpha * x * y ** T + A详细信息：http://www.netlib.org/lapack/explore-html/db/d5f/cgeru_8f.html

Parameters
`alpha` `Float2`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

### CHBMV

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

CHBMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/db/dc2/chbmv_8f.html注意：对于N * N矩阵时，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of the band matrix A is being supplied.
`K` `int`: The number of off-diagonals of the matrix A
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Float2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### CHEMM

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

CHEMM执行矩阵操作之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：http://www.netlib.org/lapack/explore- HTML / D3 / D66 / chemm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.
`beta` `Float2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

### CHEMV

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

CHEMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d7/d51/chemv_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Float2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### CHER

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

CHER执行等级1操作A：= alpha * x * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/d3/d6d/cher_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `float`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

### CHER2

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

CHER2执行对称秩2操作A：= alpha * x * y ** H + alpha * y * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/db/d87 /cher2_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `Float2`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

### CHER2K

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

CHER2K执行埃尔米特秩2k操作之一C：= alpha * A * B ** H + conjgα* B * A ** H + beta * C或C：= alpha * A ** H * B + conjg （alpha）* B ** H * A + beta * C详情：http：//www.netlib.org/lapack/explore-html/d1/d82/cher2k_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.
`beta` `float`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

### CHERK

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

CHERK执行厄密特级k操作之一C：= alpha * A * A ** H + beta * C或C：= alpha * A ** H * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML / D8 / D52 / cherk_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`beta` `float`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

### CHPMV

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

CHPMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d2/d06/chpmv_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form.
`alpha` `Float2`: The scalar alpha.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Float2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### CHPR

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

CHPR执行等级1操作A：= alpha * x * x ** H + A详细信息：http：//www.netlib.org/lapack/explore-html/db/dcd/chpr_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be supplied in the packed form.
`alpha` `float`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

### CHPR2

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

CHPR2执行对称秩2操作A：= alpha * x * y ** H + alpha * y * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/d6/d44 /chpr2_8f.html注意：对于N×N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，下面的子例程can是一个示例，显示如何将UPPER三角矩阵'a'填充矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be supplied in the packed form.
`alpha` `Float2`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.

### CSYMM

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

CSYMM执行矩阵操作之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：http://www.netlib.org/lapack/explore- HTML / DB / D59 / csymm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.
`beta` `Float2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

### CSYR2K

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

CSYR2K执行对称秩2k操作之一C：= alpha * A * B ** T + alpha * B * A ** T + beta * C或C：= alpha * A ** T * B + alpha * B * * T * A + beta * C详情：http：//www.netlib.org/lapack/explore-html/de/d7e/csyr2k_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.
`beta` `Float2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

### CSYRK

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

CSYRK执行对称秩K运算之一C：= alpha * A * A ** T + beta * C或C：= alpha * A ** T * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML / D3 / D6A / csyrk_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`beta` `Float2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32_2(RenderScript)`.

### CTBMV

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

CTBMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / d3 / dcd / ctbmv_8f.html注意：对于一个N * N矩阵，输入分配的大小也应该是N * N（dimY = N，dimX = N），但只有区域N *（K + 1 ）将被引用。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`K` `int`: The number of off-diagonals of the matrix A
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### CTBSV

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

CTBSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d9 /d5f/ctbsv_8f.html注意：对于N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但只会引用区域N *（K + 1） 。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`K` `int`: The number of off-diagonals of the matrix A
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### CTPMV

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

CTPMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / d4 / dbb / ctpmv_8f.html注意：对于N×N矩阵，输入分配应该是大小为dimX = N *（N + 1）/ 2的一维分配，下面的子例程can可以举例说明将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### CTPSV

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

CTPSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d8 /d56/ctpsv_8f.html注意：对于一个N * N矩阵，输入分配应该是一个尺寸为dimX = N *（N + 1）/ 2的一维分配，以下子例程can可以显示如何将一个UPPER三角矩阵'a'到压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### CTRMM

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

CTRMM执行矩阵操作之一B：= alpha * op（A）* B或B：= alpha * B * op（A）op（A）是op（A）= A或op = A ** T或op（A）= A ** H详情：http://www.netlib.org/lapack/explore-html/d4/d9b/ctrmm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

### CTRMV

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

CTRMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / DF / D78 / ctrmv_8f.html

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### CTRSM

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

CTRSM求解一个矩阵方程op（A）* X：= alpha * B或X * op（A）：= alpha * B op（A）是op（A）= A或op（A）= A ** T或op（A）= A ** H详情：http://www.netlib.org/lapack/explore-html/de/d30/ctrsm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`alpha` `Float2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32_2(RenderScript)`.

### CTRSV

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

CTRSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d4 /dc8/ctrsv_8f.html

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### DGBMV

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

DGBMV执行矩阵向量运算之一y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y详细信息：http://www.netlib.org/lapack /explore-html/d2/d3f/dgbmv_8f.html注意：对于M * N矩阵，输入分配的大小也应为M * N（dimY = M，dimX = N），但只有区域M *（KL + KU + 1）将被引用。 下面的子程序可以显示如何将原始矩阵'a'转换为基于行的频带矩阵'b'。 对于范围内的i（0，m）：对于范围内的j（max（0，i-kl），min（i + ku + 1，n））：b [i，j- i + kl] = a [i ，j]

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`KL` `int`: The number of sub-diagonals of the matrix A.
`KU` `int`: The number of super-diagonals of the matrix A.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains the band matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `double`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### DGEMM

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

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`TransB` `int`: The type of transpose applied to matrix B.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.
`beta` `double`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64(RenderScript)`.

### DGEMV

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

DGEMV执行矩阵向量运算之一y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y详细信息：http://www.netlib.org/lapack /explore-html/dc/da8/dgemv_8f.html

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `double`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### DGER

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

DGER执行1级操作A：= alpha * x * y ** T + A详细信息：http://www.netlib.org/lapack/explore-html/dc/da8/dger_8f.html

Parameters
`alpha` `double`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

### DSBMV

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

DSBMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d8/d1e/dsbmv_8f.html注意：对于N * N矩阵时，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of the band matrix A is being supplied.
`K` `int`: The number of off-diagonals of the matrix A
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `double`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### DSPMV

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

DSPMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d4/d85/dspmv_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form.
`alpha` `double`: The scalar alpha.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `double`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### DSPR

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

DSPR执行等级1操作A：= alpha * x * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/dd/dba/dspr_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be supplied in the packed form.
`alpha` `double`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

### DSPR2

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

DSPR2执行对称秩2操作A：= alpha * x * y ** T + alpha * y * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/dd/d9e /dspr2_8f.html注意：对于N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can可以显示如何将UPPER三角矩阵'a'填充矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be supplied in the packed form.
`alpha` `double`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

### DSYMM

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

DSYMM执行矩阵运算之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：http://www.netlib.org/lapack/explore- HTML / D8 / DB0 / dsymm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.
`beta` `double`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64(RenderScript)`.

### DSYMV

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

DSYMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d8/dbe/dsymv_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `double`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### DSYR

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

DSYR执行等级1操作A：= alpha * x * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/d3/d60/dsyr_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `double`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

### DSYR2

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

DSYR2执行对称秩2操作A：= alpha * x * y ** T + alpha * y * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/de/d41 /dsyr2_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `double`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.

### DSYR2K

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

DSYR2K执行对称秩2k运算之一C：= alpha * A * B ** T + alpha * B * A ** T + beta * C或C：= alpha * A ** T * B + alpha * B * * T * A + beta * C详情：http：//www.netlib.org/lapack/explore-html/d1/dec/dsyr2k_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.
`beta` `double`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64(RenderScript)`.

### DSYRK

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

DSYRK执行对称秩k操作之一C：= alpha * A * A ** T + beta * C或C：= alpha * A ** T * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML / DC / D05 / dsyrk_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`beta` `double`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64(RenderScript)`.

### DTBMV

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

DTBMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/df/d29/dtbmv_8f.html注意：对于N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`K` `int`: The number of off-diagonals of the matrix A
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### DTBSV

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

DTBSV求解方程组A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d4/dcf/dtbsv_8f.html注意：对于一个N * N矩阵，输入分配的大小也应该是N * N（dimY = N，dimX = N），但是只有区域N *（K + 1）将被引用。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`K` `int`: The number of off-diagonals of the matrix A
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### DTPMV

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

DTPMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/dc/dcd/dtpmv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can是一个示例，显示如何将UPPER三角矩阵'a'转换为填充矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### DTPSV

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

DTPSV求解方程A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d9/d84/dtpsv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1D的分配dimX = N *（N + 1）/ 2，以下子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵' b”。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### DTRMM

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

DTRMM执行矩阵操作之一B：= alpha * op（A）* B或B：= alpha * B * op（A）op（A）是op（A）= A或op = A ** T详情：http：//www.netlib.org/lapack/explore-html/dd/d19/dtrmm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.

### DTRMV

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

DTRMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/dc/d7e/dtrmv_8f.html

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### DTRSM

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

DTRSM求解一个矩阵方程op（A）* X：= alpha * B或X * op（A）：= alpha * B op（A）是op（A）= A或op（A）= A ** T详细信息：http：//www.netlib.org/lapack/explore-html/de/da7/dtrsm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64(RenderScript)`.

### DTRSV

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

DTRSV求解方程组A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d6/d96/dtrsv_8f.html

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### SGBMV

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

SGBMV执行一个矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y详细信息：http://www.netlib.org/lapack /explore-html/d6/d46/sgbmv_8f.html注意：对于M * N矩阵，输入分配的大小也应为M * N（dimY = M，dimX = N），但只有区域M *（KL + KU + 1）将被引用。 下面的子程序可以显示如何将原始矩阵'a'转换为基于行的频带矩阵'b'。 对于范围内的i（0，m）：对于范围内的j（max（0，i-kl），min（i + ku + 1，n））：b [i，j- i + kl] = a [i ，j]

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`KL` `int`: The number of sub-diagonals of the matrix A.
`KU` `int`: The number of super-diagonals of the matrix A.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains the band matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `float`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### SGEMM

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

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`TransB` `int`: The type of transpose applied to matrix B.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.
`beta` `float`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32(RenderScript)`.

### SGEMV

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

SGEMV执行矩阵向量运算之一y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y详细信息：http://www.netlib.org/lapack /explore-html/db/d58/sgemv_8f.html

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `float`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### SGER

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

SGER执行1级操作A：= alpha * x * y ** T + A详细信息：http://www.netlib.org/lapack/explore-html/db/d5c/sger_8f.html

Parameters
`alpha` `float`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

### SSBMV

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

SSBMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d3/da1/ssbmv_8f.html注意：对于N * N矩阵时，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of the band matrix A is being supplied.
`K` `int`: The number of off-diagonals of the matrix A
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `float`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### SSPMV

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

SSPMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d8/d68/sspmv_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form.
`alpha` `float`: The scalar alpha.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `float`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### SSPR

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

SSPR执行等级1操作A：= alpha * x * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/d2/d9b/sspr_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be supplied in the packed form.
`alpha` `float`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

### SSPR2

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

SSPR2执行对称秩2操作A：= alpha * x * y ** T + alpha * y * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/db/d3e /sspr2_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can可以显示如何将UPPER三角矩阵'a'填充矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be supplied in the packed form.
`alpha` `float`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

### SSYMM

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

SSYMM执行矩阵操作之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：http://www.netlib.org/lapack/explore- HTML / D7 / D42 / ssymm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.
`beta` `float`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32(RenderScript)`.

### SSYMV

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

SSYMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d2/d94/ssymv_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `float`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### SSYR

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

SSYR执行等级1操作A：= alpha * x * x ** T + A详细信息：http://www.netlib.org/lapack/explore-html/d6/dac/ssyr_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `float`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

### SSYR2

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

SSYR2执行对称秩2操作A：= alpha * x * y ** T + alpha * y * x ** T + A详细信息：http：//www.netlib.org/lapack/explore-html/db/d99 /ssyr2_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `float`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F32(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.

### SSYR2K

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

SSYR2K执行对称秩2k操作之一C：= alpha * A * B ** T + alpha * B * A ** T + beta * C或C：= alpha * A ** T * B + alpha * B * * T * A + beta * C详情：http：//www.netlib.org/lapack/explore-html/df/d3d/ssyr2k_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.
`beta` `float`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32(RenderScript)`.

### SSYRK

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

SSYRK执行对称秩k操作之一C：= alpha * A * A ** T + beta * C或C：= alpha * A ** T * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML / D0 / D40 / ssyrk_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`beta` `float`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F32(RenderScript)`.

### STBMV

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

STBMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/d6/d7d/stbmv_8f.html注意：对于N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`K` `int`: The number of off-diagonals of the matrix A
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### STBSV

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

STBSV求解方程A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d0/d1f/stbsv_8f.html注意：对于一个N * N矩阵，输入分配的大小也应该是N * N（dimY = N，dimX = N），但是只有区域N *（K + 1）将被引用。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`K` `int`: The number of off-diagonals of the matrix A
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### STPMV

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

STPMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/db/db1/stpmv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can是一个示例，显示如何将UPPER三角矩阵'a'转换为填充矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### STPSV

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

STPSV求解方程A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d0/d7c/stpsv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1D的分配dimX = N *（N + 1）/ 2，以下子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵' b”。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### STRMM

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

STRMM执行矩阵操作之一B：= alpha * op（A）* B或B：= alpha * B * op（A）op（A）是op（A）= A或op（A） = A ** T详情：http：//www.netlib.org/lapack/explore-html/df/d01/strmm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.

### STRMV

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

STRMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x详细信息：http://www.netlib.org/lapack/explore-html/de/d45/strmv_8f.html

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### STRSM

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

STRSM求解一个矩阵方程op（A）* X：= alpha * B或X * op（A）：= alpha * B op（A）是op（A）= A或op（A）= A ** T详细信息：http：//www.netlib.org/lapack/explore-html/d2/d8b/strsm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`alpha` `float`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F32(RenderScript)`.

### STRSV

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

STRSV求解方程组A * x = b或A ** T * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d0/d2a/strsv_8f.html

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F32(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F32(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### ZGBMV

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

ZGBMV执行矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y或y：= alpha * A ** H * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d9/d46/zgbmv_8f.html注意：对于M * N矩阵，输入分配的大小也应为M * N（dimY = M，dimX = N），但仅引用区域M *（KL + KU + 1）。 下面的子程序可以显示如何将原始矩阵'a'转换为基于行的频带矩阵'b'。 对于范围内的i（0，m）：对于范围内的j（max（0，i-kl），min（i + ku + 1，n））：b [i，j- i + kl] = a [i ，j]

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`KL` `int`: The number of sub-diagonals of the matrix A.
`KU` `int`: The number of super-diagonals of the matrix A.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains the band matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Double2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### ZGEMM

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

ZGEMM执行一个矩阵矩阵运算C：= alpha * op（A）* op（B）+ beta * C其中op（X）是op（X）= X或op（X）= X **之一T或op（X）= X ** H详细信息：http：//www.netlib.org/lapack/explore-html/d7/d76/zgemm_8f.html

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`TransB` `int`: The type of transpose applied to matrix B.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type {@link Element#F64_2
`B` `Allocation`: The input allocation contains matrix B, supported elements type {@link Element#F64_2
`beta` `Double2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type {@link Element#F64_2

### ZGEMV

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

ZGEMV执行一个矩阵向量运算y：= alpha * A * x + beta * y或y：= alpha * A ** T * x + beta * y或y：= alpha * A ** H * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/db/d40/zgemv_8f.html

Parameters
`TransA` `int`: The type of transpose applied to matrix A.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Double2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### ZGERC

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

ZGERC执行等级1操作A：= alpha * x * y ** H + A详细信息：http://www.netlib.org/lapack/explore-html/d3/dad/zgerc_8f.html

Parameters
`alpha` `Double2`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

### ZGERU

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

ZGERU执行等级1操作A：= alpha * x * y ** T + A详细信息：http://www.netlib.org/lapack/explore-html/d7/d12/zgeru_8f.html

Parameters
`alpha` `Double2`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

### ZHBMV

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

ZHBMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d3/d1a/zhbmv_8f.html注意：对于N * N矩阵时，输入分配的大小也应为N * N（dimY = N，dimX = N），但仅引用区域N *（K + 1）。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of the band matrix A is being supplied.
`K` `int`: The number of off-diagonals of the matrix A
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Double2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### ZHEMM

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

ZHEMM执行矩阵运算之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：http://www.netlib.org/lapack/explore- HTML / D6 / D3E / zhemm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.
`beta` `Double2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

### ZHEMV

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

ZHEMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d0/ddd/zhemv_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Double2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### ZHER

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

ZHER执行等级1操作A：= alpha * x * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/de/d0e/zher_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `double`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

### ZHER2

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

ZHER2执行对称秩2操作A：= alpha * x * y ** H + alpha * y * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/da/d8a /zher2_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `Double2`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

### ZHER2K

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

ZHER2K执行埃米特级别2k操作之一C：= alpha * A * B ** H + conjgα* B * A ** H + beta * C或C：= alpha * A ** H * B + conjg （alpha）* B ** H * A + beta * C详情：http：//www.netlib.org/lapack/explore-html/d7/dfa/zher2k_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.
`beta` `double`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

### ZHERK

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

ZHERK执行厄密特级k操作之一C：= alpha * A * A ** H + beta * C或C：= alpha * A ** H * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML / D1 / DB1 / zherk_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `double`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`beta` `double`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

### ZHPMV

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

ZHPMV执行矩阵向量运算y：= alpha * A * x + beta * y详细信息：http://www.netlib.org/lapack/explore-html/d0/d60/zhpmv_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form.
`alpha` `Double2`: The scalar alpha.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`beta` `Double2`: The scalar beta.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.

### ZHPR

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

ZHPR执行等级1操作A：= alpha * x * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/de/de1/zhpr_8f.html注意：对于N * N矩阵中，输入分配应该是尺寸dimD = N *（N + 1）/ 2的一维分配。下面的子例程can可以举例说明如何将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be supplied in the packed form.
`alpha` `double`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

### ZHPR2

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

ZHPR2执行对称秩2操作A：= alpha * x * y ** H + alpha * y * x ** H + A详细信息：http://www.netlib.org/lapack/explore-html/d5/d52 /zhpr2_8f.html注意：对于N×N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，下面的子例程can是一个示例，显示如何将UPPER三角矩阵'a'填充矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be supplied in the packed form.
`alpha` `Double2`: The scalar alpha.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.
`Y` `Allocation`: The input allocation contains vector y, supported elements type `F64_2(RenderScript)`.
`incY` `int`: The increment for the elements of vector y, must be larger than zero.
`Ap` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.

### ZSYMM

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

ZSYMM执行矩阵操作之一C：= alpha * A * B + beta * C或C：= alpha * B * A + beta * C详细信息：http://www.netlib.org/lapack/explore- HTML / DF / D51 / zsymm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether the upper or lower triangular part is to be referenced.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.
`beta` `Double2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

### ZSYR2K

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

ZSYR2K执行对称秩2k运算之一C：= alpha * A * B ** T + alpha * B * A ** T + beta * C或C：= alpha * A ** T * B + alpha * B * * T * A + beta * C详情：http：//www.netlib.org/lapack/explore-html/df/d20/zsyr2k_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.
`beta` `Double2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

### ZSYRK

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

ZSYRK执行对称秩k操作之一C：= alpha * A * A ** T + beta * C或C：= alpha * A ** T * A + beta * C详细信息：http：//www.netlib。组织/ LAPACK /探索-HTML /德/ D54 / zsyrk_8f.html

Parameters
`Uplo` `int`: Specifies whether the upper or lower triangular part of C is to be referenced.
`Trans` `int`: The type of transpose applied to the operation.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`beta` `Double2`: The scalar beta.
`C` `Allocation`: The input allocation contains matrix C, supported elements type `F64_2(RenderScript)`.

### ZTBMV

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

ZTBMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / d3 / d39 / ztbmv_8f.html注意：对于一个N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但只有区域N *（K + 1 ）将被引用。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`K` `int`: The number of off-diagonals of the matrix A
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### ZTBSV

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

ZTBSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d4 /d5a/ztbsv_8f.html注意：对于N * N矩阵，输入分配的大小也应为N * N（dimY = N，dimX = N），但只有区域N *（K + 1）将被引用。 下面的子例程can是一个例子，显示如何将UPPER三角形矩阵'a'转换为基于行的带矩阵'b'。 对于范围（0，n）中的i：对于范围（i，min（i + k + 1，n））中的j：b [i，ji] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`K` `int`: The number of off-diagonals of the matrix A
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### ZTPMV

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

ZTPMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / d2 / d9e / ztpmv_8f.html注意：对于N×N矩阵，输入分配应该是大小为dimX = N *（N + 1）/ 2的一维分配，以下子例程can可以是一个示例将UPPER三角矩阵'a'转换为压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### ZTPSV

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

ZTPSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/da /d57/ztpsv_8f.html注意：对于一个N * N矩阵，输入分配应该是大小为1X的分配dimX = N *（N + 1）/ 2，以下子例程can可以显示如何将UPPER三角矩阵'a'到压缩矩阵'b'。 对于范围（0，n）中的i，k = 0：对于范围（i，n）中的j：b [k ++] = a [i，j]

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`Ap` `Allocation`: The input allocation contains packed matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### ZTRMM

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

ZTRMM执行矩阵运算之一B：= alpha * op（A）* B或B：= alpha * B * op（A）op（A）是op（A）= A或op = A ** T或op（A）= A ** H详情：http：//www.netlib.org/lapack/explore-html/d8/de1/ztrmm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.

### ZTRMV

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

ZTRMV执行矩阵向量运算之一x：= A * x或x：= A ** T * x或x：= A ** H * x详细信息：http://www.netlib.org/lapack/explore -html / D0 / DD1 / ztrmv_8f.html

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### ZTRSM

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

ZTRSM求解一个矩阵方程op（A）* X：= alpha * B或X * op（A）：= alpha * B op（A）是op（A）= A或op（A）= A ** T或op（A）= A ** H详情：http：//www.netlib.org/lapack/explore-html/d1/d39/ztrsm_8f.html

Parameters
`Side` `int`: Specifies whether the symmetric matrix A appears on the left or right.
`Uplo` `int`: Specifies whether matrix A is upper or lower triangular.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`alpha` `Double2`: The scalar alpha.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`B` `Allocation`: The input allocation contains matrix B, supported elements type `F64_2(RenderScript)`.

### ZTRSV

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

ZTRSV求解方程A * x = b或A ** T * x = b或A ** H * x = b的系统之一详细信息：http://www.netlib.org/lapack/explore-html/d1 /d2f/ztrsv_8f.html

Parameters
`Uplo` `int`: Specifies whether the matrix is an upper or lower triangular matrix.
`TransA` `int`: The type of transpose applied to matrix A.
`Diag` `int`: Specifies whether or not A is unit triangular.
`A` `Allocation`: The input allocation contains matrix A, supported elements type `F64_2(RenderScript)`.
`X` `Allocation`: The input allocation contains vector x, supported elements type `F64_2(RenderScript)`.
`incX` `int`: The increment for the elements of vector x, must be larger than zero.

### create

`ScriptIntrinsicBLAS create (RenderScript rs)`
`rs` `RenderScript`: The RenderScript context
`ScriptIntrinsicBLAS` ScriptIntrinsicBLAS