Most visited

Recently visited

Results for

Added in API level 23
Summary: Constants | Methods | Inherited Methods | [Expand All]

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)

用于神经网络的8位GEMM类操作：C = A *移调（B）在1.10.21定点格式中为最终输出完成计算，就在下移小数部分之前。
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)

其中op（X）是op（X）= X或op（X）= X **中的一个，CGEMM执行矩阵操作之一C：= alpha * op（A）* op（B）+ beta * T或op（X）= X ** H详情：http://www.netlib.org/lapack/explore-html/d6/d5b/cgemm_8f.html
void CGEMV(int TransA, Float2 alpha, Allocation A, Allocation X, int incX, Float2 beta, Allocation Y, int incY)

CGEMV执行矩阵向量运算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)

其中op（X）是op（X）= X或op（X）= X **中的一个，则DGEMM执行矩阵操作之一C：= alpha * op（A）* op（B）+ beta * T详细信息：http://www.netlib.org/lapack/explore-html/d7/d2b/dgemm_8f.html
void DGEMV(int TransA, double alpha, Allocation A, Allocation X, int incX, double beta, Allocation Y, int incY)

DGEMV执行矩阵向量运算之一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)

其中op（X）是op（X）= X或op（X）= X **中的一个，SGEMM执行矩阵操作之一C：= alpha * op（A）* op（B）+ beta * T详情：http://www.netlib.org/lapack/explore-html/d4/de2/sgemm_8f.html
void SGEMV(int TransA, float alpha, Allocation A, Allocation X, int incX, float beta, Allocation Y, int incY)

SGEMV执行矩阵向量运算之一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)

创建一个访问BLAS子例程的内部函数。

Inherited methods
From class android.renderscript.Script
From class android.renderscript.BaseObj
From class java.lang.Object

Constants

CONJ_TRANSPOSE

Added in API level 23 
int CONJ_TRANSPOSE

常量值：113（0x00000071）

LEFT

Added in API level 23 
int LEFT

常量值：141（0x0000008d）

LOWER

Added in API level 23 
int LOWER

常量值：122（0x0000007a）

NON_UNIT

Added in API level 23 
int NON_UNIT

常量值：131（0x00000083）

NO_TRANSPOSE

Added in API level 23 
int NO_TRANSPOSE

常量值：111（0x0000006f）

RIGHT

Added in API level 23 
int RIGHT

常量值：142（0x0000008e）

TRANSPOSE

Added in API level 23 
int TRANSPOSE

常量值：112（0x00000070）

UNIT

Added in API level 23 
int UNIT

常量值：132（0x00000084）

UPPER

Added in API level 23 
int UPPER

常量值：121（0x00000079）

Public methods

BNNM

Added in API level 23 
void BNNM (Allocation A, 
                int a_offset, 
                Allocation B, 
                int b_offset, 
                Allocation C, 
                int c_offset, 
                int c_mult)

用于神经网络的8位GEMM类操作：C = A *移调（B）在1.10.21定点格式中为最终输出完成计算，就在下移小数部分之前。 输出值被选通为0到255以适应一个字节，但10位格式提供了一些余量以避免在小的溢出周围。

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

CGBMV

Added in API level 23 
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

Added in API level 23 
void CGEMM (int TransA, 
                int TransB, 
                Float2 alpha, 
                Allocation A, 
                Allocation B, 
                Float2 beta, 
                Allocation C)

其中op（X）是op（X）= X或op（X）= X **中的一个，CGEMM执行矩阵操作之一C：= alpha * op（A）* op（B）+ beta * T或op（X）= X ** H详情：http://www.netlib.org/lapack/explore-html/d6/d5b/cgemm_8f.html

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

CGEMV

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
void DGEMM (int TransA, 
                int TransB, 
                double alpha, 
                Allocation A, 
                Allocation B, 
                double beta, 
                Allocation C)

其中op（X）是op（X）= X或op（X）= X **中的一个，则DGEMM执行矩阵操作之一C：= alpha * op（A）* op（B）+ beta * T详细信息：http://www.netlib.org/lapack/explore-html/d7/d2b/dgemm_8f.html

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

DGEMV

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
void SGEMM (int TransA, 
                int TransB, 
                float alpha, 
                Allocation A, 
                Allocation B, 
                float beta, 
                Allocation C)

其中op（X）是op（X）= X或op（X）= X **中的一个，SGEMM执行矩阵操作之一C：= alpha * op（A）* op（B）+ beta * T详情：http://www.netlib.org/lapack/explore-html/d4/de2/sgemm_8f.html

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

SGEMV

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
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

Added in API level 23 
ScriptIntrinsicBLAS create (RenderScript rs)

创建一个访问BLAS子例程的内部函数。

Parameters
rs RenderScript: The RenderScript context
Returns
ScriptIntrinsicBLAS ScriptIntrinsicBLAS
Android开发手册

Hooray!