signature:
public class JCublas { /** * < pre >
 * void
 * cublasChemm ( char side , char uplo , int m , int n , cuComplex alpha ,
 * const cuComplex * A , int lda , const cuComplex * B , int ldb ,
 * cuComplex beta , cuComplex * C , int ldc ) ;
 * performs one of the matrix - matrix operations
 * C = alpha * A * B + beta * C , or
 * C = alpha * B * A + beta * C ,
 * where alpha and beta are single precision complex scalars , A is a hermitian matrix
 * consisting of single precision complex elements and stored in either lower or upper
 * storage mode , and B and C are m x n matrices consisting of single precision
 * complex elements .
 * Input
 * side specifies whether the hermitian matrix A appears on the left side
 * hand side or right hand side of matrix B , as follows . If side = = ' L '
 * or ' l ' , then C = alpha * A * B + beta * C . If side = ' R ' or ' r ' ,
 * then C = alpha * B * A + beta * C .
 * uplo specifies whether the hermitian matrix A is stored in upper or lower
 * storage mode , as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the hermitian matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the hermitian matrix is to be referenced ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * m specifies the number of rows of the matrix C , and the number of rows
 * of matrix B . It also specifies the dimensions of hermitian matrix A
 * when side = = ' L ' or ' l ' . m must be at least zero .
 * n specifies the number of columns of the matrix C , and the number of
 * columns of matrix B . It also specifies the dimensions of hermitian
 * matrix A when side = = ' R ' or ' r ' . n must be at least zero .
 * alpha single precision complex scalar multiplier applied to A * B , or B * A
 * A single precision complex array of dimensions ( lda , ka ) , where ka is m when
 * side = = ' L ' or ' l ' and is n otherwise . If side = = ' L ' or ' l ' the
 * leading m x m part of array A must contain the hermitian matrix ,
 * such that when uplo = = ' U ' or ' u ' , the leading m x m part stores the
 * upper triangular part of the hermitian matrix , and the strictly lower
 * triangular part of A is not referenced , and when uplo = = ' U ' or ' u ' ,
 * the leading m x m part stores the lower triangular part of the
 * hermitian matrix and the strictly upper triangular part is not
 * referenced . If side = = ' R ' or ' r ' the leading n x n part of array A
 * must contain the hermitian matrix , such that when uplo = = ' U ' or ' u ' ,
 * the leading n x n part stores the upper triangular part of the
 * hermitian matrix and the strictly lower triangular part of A is not
 * referenced , and when uplo = = ' U ' or ' u ' , the leading n x n part
 * stores the lower triangular part of the hermitian matrix and the
 * strictly upper triangular part is not referenced . The imaginary parts
 * of the diagonal elements need not be set , they are assumed to be zero .
 * lda leading dimension of A . When side = = ' L ' or ' l ' , it must be at least
 * max ( 1 , m ) and at least max ( 1 , n ) otherwise .
 * B single precision complex array of dimensions ( ldb , n ) . On entry , the leading
 * m x n part of the array contains the matrix B .
 * ldb leading dimension of B . It must be at least max ( 1 , m ) .
 * beta single precision complex scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input
 * C single precision complex array of dimensions ( ldc , n )
 * ldc leading dimension of C . Must be at least max ( 1 , m )
 * Output
 * C updated according to C = alpha * A * B + beta * C , or C = alpha *
 * B * A + beta * C
 * Reference : http : / / www . netlib . org / blas / chemm . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if m or n are < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasChemm ( char side , char uplo , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuComplex beta , Pointer C , int ldc ) { } }

implementation: cublasChemmNative ( side , uplo , m , n , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCsyrk ( char uplo , char trans , int n , int k , cuComplex alpha ,
 * const cuComplex * A , int lda , cuComplex beta , cuComplex * C , int ldc )
 * performs one of the symmetric rank k operations
 * C = alpha * A * transpose ( A ) + beta * C , or
 * C = alpha * transpose ( A ) * A + beta * C .
 * Alpha and beta are single precision complex scalars . C is an n x n symmetric matrix
 * consisting of single precision complex elements and stored in either lower or
 * upper storage mode . A is a matrix consisting of single precision complex elements
 * with dimension of n x k in the first case , and k x n in the second case .
 * Input
 * uplo specifies whether the symmetric matrix C is stored in upper or lower
 * storage mode as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the symmetric matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the symmetric matrix is to be referenced ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * trans specifies the operation to be performed . If trans = = ' N ' or ' n ' , C =
 * alpha * transpose ( A ) + beta * C . If trans = = ' T ' , ' t ' , ' C ' , or ' c ' ,
 * C = transpose ( A ) * A + beta * C .
 * n specifies the number of rows and the number columns of matrix C . If
 * trans = = ' N ' or ' n ' , n specifies the number of rows of matrix A . If
 * trans = = ' T ' , ' t ' , ' C ' , or ' c ' , n specifies the columns of matrix A .
 * n must be at least zero .
 * k If trans = = ' N ' or ' n ' , k specifies the number of rows of matrix A .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , k specifies the number of rows of
 * matrix A . k must be at least zero .
 * alpha single precision complex scalar multiplier applied to A * transpose ( A ) or
 * transpose ( A ) * A .
 * A single precision complex array of dimensions ( lda , ka ) , where ka is k when
 * trans = = ' N ' or ' n ' , and is n otherwise . When trans = = ' N ' or ' n ' ,
 * the leading n x k part of array A must contain the matrix A ,
 * otherwise the leading k x n part of the array must contains the
 * matrix A .
 * lda leading dimension of A . When trans = = ' N ' or ' n ' then lda must be at
 * least max ( 1 , n ) . Otherwise lda must be at least max ( 1 , k ) .
 * beta single precision complex scalar multiplier applied to C . If beta izs zero , C
 * does not have to be a valid input
 * C single precision complex array of dimensions ( ldc , n ) . If uplo = ' U ' or ' u ' ,
 * the leading n x n triangular part of the array C must contain the
 * upper triangular part of the symmetric matrix C and the strictly
 * lower triangular part of C is not referenced . On exit , the upper
 * triangular part of C is overwritten by the upper triangular part of
 * the updated matrix . If uplo = ' L ' or ' l ' , the leading n x n
 * triangular part of the array C must contain the lower triangular part
 * of the symmetric matrix C and the strictly upper triangular part of C
 * is not referenced . On exit , the lower triangular part of C is
 * overwritten by the lower triangular part of the updated matrix .
 * ldc leading dimension of C . It must be at least max ( 1 , n ) .
 * Output
 * C updated according to C = alpha * A * transpose ( A ) + beta * C , or C =
 * alpha * transpose ( A ) * A + beta * C
 * Reference : http : / / www . netlib . org / blas / csyrk . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 or k < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCsyrk ( char uplo , char trans , int n , int k , cuComplex alpha , Pointer A , int lda , cuComplex beta , Pointer C , int ldc ) { } }

implementation: cublasCsyrkNative ( uplo , trans , n , k , alpha , A , lda , beta , C , ldc ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCherk ( char uplo , char trans , int n , int k , float alpha ,
 * const cuComplex * A , int lda , float beta , cuComplex * C , int ldc )
 * performs one of the hermitian rank k operations
 * C = alpha * A * conjugate ( transpose ( A ) ) + beta * C , or
 * C = alpha * conjugate ( transpose ( A ) ) * A + beta * C .
 * Alpha and beta are single precision real scalars . C is an n x n hermitian matrix
 * consisting of single precision complex elements and stored in either lower or
 * upper storage mode . A is a matrix consisting of single precision complex elements
 * with dimension of n x k in the first case , and k x n in the second case .
 * Input
 * uplo specifies whether the hermitian matrix C is stored in upper or lower
 * storage mode as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the hermitian matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the hermitian matrix is to be referenced ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * trans specifies the operation to be performed . If trans = = ' N ' or ' n ' , C =
 * alpha * A * conjugate ( transpose ( A ) ) + beta * C . If trans = = ' T ' , ' t ' , ' C ' , or ' c ' ,
 * C = alpha * conjugate ( transpose ( A ) ) * A + beta * C .
 * n specifies the number of rows and the number columns of matrix C . If
 * trans = = ' N ' or ' n ' , n specifies the number of rows of matrix A . If
 * trans = = ' T ' , ' t ' , ' C ' , or ' c ' , n specifies the columns of matrix A .
 * n must be at least zero .
 * k If trans = = ' N ' or ' n ' , k specifies the number of columns of matrix A .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , k specifies the number of rows of
 * matrix A . k must be at least zero .
 * alpha single precision scalar multiplier applied to A * conjugate ( transpose ( A ) ) or
 * conjugate ( transpose ( A ) ) * A .
 * A single precision complex array of dimensions ( lda , ka ) , where ka is k when
 * trans = = ' N ' or ' n ' , and is n otherwise . When trans = = ' N ' or ' n ' ,
 * the leading n x k part of array A must contain the matrix A ,
 * otherwise the leading k x n part of the array must contains the
 * matrix A .
 * lda leading dimension of A . When trans = = ' N ' or ' n ' then lda must be at
 * least max ( 1 , n ) . Otherwise lda must be at least max ( 1 , k ) .
 * beta single precision scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input .
 * C single precision complex array of dimensions ( ldc , n ) . If uplo = ' U ' or ' u ' ,
 * the leading n x n triangular part of the array C must contain the
 * upper triangular part of the hermitian matrix C and the strictly
 * lower triangular part of C is not referenced . On exit , the upper
 * triangular part of C is overwritten by the upper triangular part of
 * the updated matrix . If uplo = ' L ' or ' l ' , the leading n x n
 * triangular part of the array C must contain the lower triangular part
 * of the hermitian matrix C and the strictly upper triangular part of C
 * is not referenced . On exit , the lower triangular part of C is
 * overwritten by the lower triangular part of the updated matrix .
 * The imaginary parts of the diagonal elements need
 * not be set , they are assumed to be zero , and on exit they
 * are set to zero .
 * ldc leading dimension of C . It must be at least max ( 1 , n ) .
 * Output
 * C updated according to C = alpha * A * conjugate ( transpose ( A ) ) + beta * C , or C =
 * alpha * conjugate ( transpose ( A ) ) * A + beta * C
 * Reference : http : / / www . netlib . org / blas / cherk . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 or k < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCherk ( char uplo , char trans , int n , int k , float alpha , Pointer A , int lda , float beta , Pointer C , int ldc ) { } }

implementation: cublasCherkNative ( uplo , trans , n , k , alpha , A , lda , beta , C , ldc ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCsyr2k ( char uplo , char trans , int n , int k , cuComplex alpha ,
 * const cuComplex * A , int lda , const cuComplex * B , int ldb ,
 * cuComplex beta , cuComplex * C , int ldc )
 * performs one of the symmetric rank 2k operations
 * C = alpha * A * transpose ( B ) + alpha * B * transpose ( A ) + beta * C , or
 * C = alpha * transpose ( A ) * B + alpha * transpose ( B ) * A + beta * C .
 * Alpha and beta are single precision complex scalars . C is an n x n symmetric matrix
 * consisting of single precision complex elements and stored in either lower or upper
 * storage mode . A and B are matrices consisting of single precision complex elements
 * with dimension of n x k in the first case , and k x n in the second case .
 * Input
 * uplo specifies whether the symmetric matrix C is stored in upper or lower
 * storage mode , as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the symmetric matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the symmetric matrix is to be references ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * trans specifies the operation to be performed . If trans = = ' N ' or ' n ' ,
 * C = alpha * A * transpose ( B ) + alpha * B * transpose ( A ) + beta * C ,
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , C = alpha * transpose ( A ) * B +
 * alpha * transpose ( B ) * A + beta * C .
 * n specifies the number of rows and the number columns of matrix C . If
 * trans = = ' N ' or ' n ' , n specifies the number of rows of matrix A . If
 * trans = = ' T ' , ' t ' , ' C ' , or ' c ' , n specifies the columns of matrix A .
 * n must be at least zero .
 * k If trans = = ' N ' or ' n ' , k specifies the number of rows of matrix A .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , k specifies the number of rows of
 * matrix A . k must be at least zero .
 * alpha single precision complex scalar multiplier .
 * A single precision complex array of dimensions ( lda , ka ) , where ka is k when
 * trans = = ' N ' or ' n ' , and is n otherwise . When trans = = ' N ' or ' n ' ,
 * the leading n x k part of array A must contain the matrix A ,
 * otherwise the leading k x n part of the array must contain the matrix
 * lda leading dimension of A . When trans = = ' N ' or ' n ' then lda must be at
 * least max ( 1 , n ) . Otherwise lda must be at least max ( 1 , k ) .
 * B single precision complex array of dimensions ( lda , kb ) , where kb is k when
 * trans = = ' N ' or ' n ' , and is n otherwise . When trans = = ' N ' or ' n ' ,
 * the leading n x k part of array B must contain the matrix B ,
 * otherwise the leading k x n part of the array must contain the matrix
 * ldb leading dimension of N . When trans = = ' N ' or ' n ' then ldb must be at
 * least max ( 1 , n ) . Otherwise ldb must be at least max ( 1 , k ) .
 * beta single precision complex scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input .
 * C single precision complex array of dimensions ( ldc , n ) . If uplo = = ' U ' or ' u ' ,
 * the leading n x n triangular part of the array C must contain the
 * upper triangular part of the symmetric matrix C and the strictly
 * lower triangular part of C is not referenced . On exit , the upper
 * triangular part of C is overwritten by the upper triangular part of
 * the updated matrix . If uplo = = ' L ' or ' l ' , the leading n x n
 * triangular part of the array C must contain the lower triangular part
 * of the symmetric matrix C and the strictly upper triangular part of C
 * is not referenced . On exit , the lower triangular part of C is
 * overwritten by the lower triangular part of the updated matrix .
 * ldc leading dimension of C . Must be at least max ( 1 , n ) .
 * Output
 * C updated according to alpha * A * transpose ( B ) + alpha * B * transpose ( A ) +
 * beta * C or alpha * transpose ( A ) * B + alpha * transpose ( B ) * A + beta * C
 * Reference : http : / / www . netlib . org / blas / csyr2k . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 or k < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCsyr2k ( char uplo , char trans , int n , int k , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuComplex beta , Pointer C , int ldc ) { } }

implementation: cublasCsyr2kNative ( uplo , trans , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCher2k ( char uplo , char trans , int n , int k , cuComplex alpha ,
 * const cuComplex * A , int lda , const cuComplex * B , int ldb ,
 * float beta , cuComplex * C , int ldc )
 * performs one of the hermitian rank 2k operations
 * C = alpha * A * conjugate ( transpose ( B ) )
 * + conjugate ( alpha ) * B * conjugate ( transpose ( A ) )
 * + beta * C ,
 * or
 * C = alpha * conjugate ( transpose ( A ) ) * B
 * + conjugate ( alpha ) * conjugate ( transpose ( B ) ) * A
 * + beta * C .
 * Alpha is single precision complex scalar whereas Beta is a single preocision real scalar .
 * C is an n x n hermitian matrix consisting of single precision complex elements
 * and stored in either lower or upper storage mode . A and B are matrices consisting
 * of single precision complex elements with dimension of n x k in the first case ,
 * and k x n in the second case .
 * Input
 * uplo specifies whether the hermitian matrix C is stored in upper or lower
 * storage mode , as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the hermitian matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the hermitian matrix is to be references ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * trans specifies the operation to be performed . If trans = = ' N ' or ' n ' ,
 * C = alpha * A * conjugate ( transpose ( B ) )
 * + conjugate ( alpha ) * B * conjugate ( transpose ( A ) )
 * + beta * C .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' ,
 * C = alpha * conjugate ( transpose ( A ) ) * B
 * + conjugate ( alpha ) * conjugate ( transpose ( B ) ) * A
 * + beta * C .
 * n specifies the number of rows and the number columns of matrix C . If
 * trans = = ' N ' or ' n ' , n specifies the number of rows of matrix A . If
 * trans = = ' T ' , ' t ' , ' C ' , or ' c ' , n specifies the columns of matrix A .
 * n must be at least zero .
 * k If trans = = ' N ' or ' n ' , k specifies the number of rows of matrix A .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , k specifies the number of rows of
 * matrix A . k must be at least zero .
 * alpha single precision complex scalar multiplier .
 * A single precision complex array of dimensions ( lda , ka ) , where ka is k when
 * trans = = ' N ' or ' n ' , and is n otherwise . When trans = = ' N ' or ' n ' ,
 * the leading n x k part of array A must contain the matrix A ,
 * otherwise the leading k x n part of the array must contain the matrix
 * lda leading dimension of A . When trans = = ' N ' or ' n ' then lda must be at
 * least max ( 1 , n ) . Otherwise lda must be at least max ( 1 , k ) .
 * B single precision complex array of dimensions ( lda , kb ) , where kb is k when
 * trans = = ' N ' or ' n ' , and is n otherwise . When trans = = ' N ' or ' n ' ,
 * the leading n x k part of array B must contain the matrix B ,
 * otherwise the leading k x n part of the array must contain the matrix
 * ldb leading dimension of N . When trans = = ' N ' or ' n ' then ldb must be at
 * least max ( 1 , n ) . Otherwise ldb must be at least max ( 1 , k ) .
 * beta single precision scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input .
 * C single precision complex array of dimensions ( ldc , n ) . If uplo = = ' U ' or ' u ' ,
 * the leading n x n triangular part of the array C must contain the
 * upper triangular part of the hermitian matrix C and the strictly
 * lower triangular part of C is not referenced . On exit , the upper
 * triangular part of C is overwritten by the upper triangular part of
 * the updated matrix . If uplo = = ' L ' or ' l ' , the leading n x n
 * triangular part of the array C must contain the lower triangular part
 * of the hermitian matrix C and the strictly upper triangular part of C
 * is not referenced . On exit , the lower triangular part of C is
 * overwritten by the lower triangular part of the updated matrix .
 * The imaginary parts of the diagonal elements need
 * not be set , they are assumed to be zero , and on exit they
 * are set to zero .
 * ldc leading dimension of C . Must be at least max ( 1 , n ) .
 * Output
 * C updated according to alpha * A * conjugate ( transpose ( B ) ) +
 * + conjugate ( alpha ) * B * conjugate ( transpose ( A ) ) + beta * C or
 * alpha * conjugate ( transpose ( A ) ) * B + conjugate ( alpha ) * conjugate ( transpose ( B ) ) * A
 * + beta * C .
 * Reference : http : / / www . netlib . org / blas / cher2k . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 or k < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCher2k ( char uplo , char trans , int n , int k , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , float beta , Pointer C , int ldc ) { } }

implementation: cublasCher2kNative ( uplo , trans , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCtrmm ( char side , char uplo , char transa , char diag , int m , int n ,
 * cuComplex alpha , const cuComplex * A , int lda , const cuComplex * B ,
 * int ldb )
 * performs one of the matrix - matrix operations
 * B = alpha * op ( A ) * B , or B = alpha * B * op ( A )
 * where alpha is a single - precision complex scalar , B is an m x n matrix composed
 * of single precision complex elements , and A is a unit or non - unit , upper or lower ,
 * triangular matrix composed of single precision complex elements . op ( A ) is one of
 * op ( A ) = A , op ( A ) = transpose ( A ) or op ( A ) = conjugate ( transpose ( A ) )
 * Matrices A and B are stored in column major format , and lda and ldb are
 * the leading dimensions of the two - dimensonials arrays that contain A and
 * B , respectively .
 * Input
 * side specifies whether op ( A ) multiplies B from the left or right .
 * If side = ' L ' or ' l ' , then B = alpha * op ( A ) * B . If side =
 * ' R ' or ' r ' , then B = alpha * B * op ( A ) .
 * uplo specifies whether the matrix A is an upper or lower triangular
 * matrix . If uplo = ' U ' or ' u ' , A is an upper triangular matrix .
 * If uplo = ' L ' or ' l ' , A is a lower triangular matrix .
 * transa specifies the form of op ( A ) to be used in the matrix
 * multiplication . If transa = ' N ' or ' n ' , then op ( A ) = A . If
 * transa = ' T ' or ' t ' , then op ( A ) = transpose ( A ) .
 * If transa = ' C ' or ' c ' , then op ( A ) = conjugate ( transpose ( A ) ) .
 * diag specifies whether or not A is unit triangular . If diag = ' U '
 * or ' u ' , A is assumed to be unit triangular . If diag = ' N ' or
 * ' n ' , A is not assumed to be unit triangular .
 * m the number of rows of matrix B . m must be at least zero .
 * n the number of columns of matrix B . n must be at least zero .
 * alpha single precision complex scalar multiplier applied to op ( A ) * B , or
 * B * op ( A ) , respectively . If alpha is zero no accesses are made
 * to matrix A , and no read accesses are made to matrix B .
 * A single precision complex array of dimensions ( lda , k ) . k = m if side =
 * ' L ' or ' l ' , k = n if side = ' R ' or ' r ' . If uplo = ' U ' or ' u '
 * the leading k x k upper triangular part of the array A must
 * contain the upper triangular matrix , and the strictly lower
 * triangular part of A is not referenced . If uplo = ' L ' or ' l '
 * the leading k x k lower triangular part of the array A must
 * contain the lower triangular matrix , and the strictly upper
 * triangular part of A is not referenced . When diag = ' U ' or ' u '
 * the diagonal elements of A are no referenced and are assumed
 * to be unity .
 * lda leading dimension of A . When side = ' L ' or ' l ' , it must be at
 * least max ( 1 , m ) and at least max ( 1 , n ) otherwise
 * B single precision complex array of dimensions ( ldb , n ) . On entry , the
 * leading m x n part of the array contains the matrix B . It is
 * overwritten with the transformed matrix on exit .
 * ldb leading dimension of B . It must be at least max ( 1 , m ) .
 * Output
 * B updated according to B = alpha * op ( A ) * B or B = alpha * B * op ( A )
 * Reference : http : / / www . netlib . org / blas / ctrmm . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if m or n < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCtrmm ( char side , char uplo , char transa , char diag , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb ) { } }

implementation: cublasCtrmmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCtrsm ( char side , char uplo , char transa , char diag , int m , int n ,
 * cuComplex alpha , const cuComplex * A , int lda ,
 * cuComplex * B , int ldb )
 * solves one of the matrix equations
 * op ( A ) * X = alpha * B , or X * op ( A ) = alpha * B ,
 * where alpha is a single precision complex scalar , and X and B are m x n matrices
 * that are composed of single precision complex elements . A is a unit or non - unit ,
 * upper or lower triangular matrix , and op ( A ) is one of
 * op ( A ) = A or op ( A ) = transpose ( A ) or op ( A ) = conj ( A ' ) .
 * The result matrix X overwrites input matrix B ; that is , on exit the result
 * is stored in B . Matrices A and B are stored in column major format , and
 * lda and ldb are the leading dimensions of the two - dimensonials arrays that
 * contain A and B , respectively .
 * Input
 * side specifies whether op ( A ) appears on the left or right of X as
 * follows : side = ' L ' or ' l ' indicates solve op ( A ) * X = alpha * B .
 * side = ' R ' or ' r ' indicates solve X * op ( A ) = alpha * B .
 * uplo specifies whether the matrix A is an upper or lower triangular
 * matrix as follows : uplo = ' U ' or ' u ' indicates A is an upper
 * triangular matrix . uplo = ' L ' or ' l ' indicates A is a lower
 * triangular matrix .
 * transa specifies the form of op ( A ) to be used in matrix multiplication
 * as follows : If transa = ' N ' or ' N ' , then op ( A ) = A . If transa =
 * ' T ' , ' t ' , ' C ' , or ' c ' , then op ( A ) = transpose ( A ) .
 * diag specifies whether or not A is a unit triangular matrix like so :
 * if diag = ' U ' or ' u ' , A is assumed to be unit triangular . If
 * diag = ' N ' or ' n ' , then A is not assumed to be unit triangular .
 * m specifies the number of rows of B . m must be at least zero .
 * n specifies the number of columns of B . n must be at least zero .
 * alpha is a single precision complex scalar to be multiplied with B . When alpha is
 * zero , then A is not referenced and B need not be set before entry .
 * A is a single precision complex array of dimensions ( lda , k ) , where k is
 * m when side = ' L ' or ' l ' , and is n when side = ' R ' or ' r ' . If
 * uplo = ' U ' or ' u ' , the leading k x k upper triangular part of
 * the array A must contain the upper triangular matrix and the
 * strictly lower triangular matrix of A is not referenced . When
 * uplo = ' L ' or ' l ' , the leading k x k lower triangular part of
 * the array A must contain the lower triangular matrix and the
 * strictly upper triangular part of A is not referenced . Note that
 * when diag = ' U ' or ' u ' , the diagonal elements of A are not
 * referenced , and are assumed to be unity .
 * lda is the leading dimension of the two dimensional array containing A .
 * When side = ' L ' or ' l ' then lda must be at least max ( 1 , m ) , when
 * side = ' R ' or ' r ' then lda must be at least max ( 1 , n ) .
 * B is a single precision complex array of dimensions ( ldb , n ) . ldb must be
 * at least max ( 1 , m ) . The leading m x n part of the array B must
 * contain the right - hand side matrix B . On exit B is overwritten
 * by the solution matrix X .
 * ldb is the leading dimension of the two dimensional array containing B .
 * ldb must be at least max ( 1 , m ) .
 * Output
 * B contains the solution matrix X satisfying op ( A ) * X = alpha * B ,
 * or X * op ( A ) = alpha * B
 * Reference : http : / / www . netlib . org / blas / ctrsm . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if m or n < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCtrsm ( char side , char uplo , char transa , char diag , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb ) { } }

implementation: cublasCtrsmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * double
 * cublasDasum ( int n , const double * x , int incx )
 * computes the sum of the absolute values of the elements of double
 * precision vector x ; that is , the result is the sum from i = 0 to n - 1 of
 * abs ( x [ 1 + i * incx ] ) .
 * Input
 * n number of elements in input vector
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns the double - precision sum of absolute values
 * ( 0 if n < = 0 or incx < = 0 , or if an error occurs )
 * Reference : http : / / www . netlib . org / blas / dasum . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static double cublasDasum ( int n , Pointer x , int incx ) { } }

implementation: double result = cublasDasumNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDaxpy ( int n , double alpha , const double * x , int incx , double * y ,
 * int incy )
 * multiplies double - precision vector x by double - precision scalar alpha
 * and adds the result to double - precision vector y ; that is , it overwrites
 * double - precision y with double - precision alpha * x + y . For i = 0 to n - 1,
 * it replaces y [ ly + i * incy ] with alpha * x [ lx + i * incx ] + y [ ly + i * incy ] ,
 * where lx = 1 if incx > = 0 , else lx = 1 + ( 1 - n ) * incx ; ly is defined in a
 * similar way using incy .
 * Input
 * n number of elements in input vectors
 * alpha double - precision scalar multiplier
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * y double - precision vector with n elements
 * incy storage spacing between elements of y
 * Output
 * y double - precision result ( unchanged if n < = 0)
 * Reference : http : / / www . netlib . org / blas / daxpy . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library was not initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDaxpy ( int n , double alpha , Pointer x , int incx , Pointer y , int incy ) { } }

implementation: cublasDaxpyNative ( n , alpha , x , incx , y , incy ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDcopy ( int n , const double * x , int incx , double * y , int incy )
 * copies the double - precision vector x to the double - precision vector y . For
 * i = 0 to n - 1 , copies x [ lx + i * incx ] to y [ ly + i * incy ] , where lx = 1 if
 * incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a similar
 * way using incy .
 * Input
 * n number of elements in input vectors
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * y double - precision vector with n elements
 * incy storage spacing between elements of y
 * Output
 * y contains double precision vector x
 * Reference : http : / / www . netlib . org / blas / dcopy . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDcopy ( int n , Pointer x , int incx , Pointer y , int incy ) { } }

implementation: cublasDcopyNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * double
 * cublasDdot ( int n , const double * x , int incx , const double * y , int incy )
 * computes the dot product of two double - precision vectors . It returns the
 * dot product of the double precision vectors x and y if successful , and
 * 0.0f otherwise . It computes the sum for i = 0 to n - 1 of x [ lx + i *
 * incx ] * y [ ly + i * incy ] , where lx = 1 if incx > = 0 , else lx = 1 + ( 1 - n )
 * * incx , and ly is defined in a similar way using incy .
 * Input
 * n number of elements in input vectors
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * y double - precision vector with n elements
 * incy storage spacing between elements of y
 * Output
 * returns double - precision dot product ( zero if n < = 0)
 * Reference : http : / / www . netlib . org / blas / ddot . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has nor been initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to execute on GPU
 * < / pre > */
public static double cublasDdot ( int n , Pointer x , int incx , Pointer y , int incy ) { } }

implementation: double result = cublasDdotNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * double
 * dnrm2 ( int n , const double * x , int incx )
 * computes the Euclidean norm of the double - precision n - vector x ( with
 * storage increment incx ) . This code uses a multiphase model of
 * accumulation to avoid intermediate underflow and overflow .
 * Input
 * n number of elements in input vector
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns Euclidian norm ( 0 if n < = 0 or incx < = 0 , or if an error occurs )
 * Reference : http : / / www . netlib . org / blas / dnrm2 . f
 * Reference : http : / / www . netlib . org / slatec / lin / dnrm2 . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static double cublasDnrm2 ( int n , Pointer x , int incx ) { } }

implementation: double result = cublasDnrm2Native ( n , x , incx ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDrot ( int n , double * x , int incx , double * y , int incy , double sc ,
 * double ss )
 * multiplies a 2x2 matrix ( sc ss ) with the 2xn matrix ( transpose ( x ) )
 * ( - ss sc ) ( transpose ( y ) )
 * The elements of x are in x [ lx + i * incx ] , i = 0 . . . n - 1 , where lx = 1 if
 * incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and similarly for y using ly and
 * incy .
 * Input
 * n number of elements in input vectors
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * y double - precision vector with n elements
 * incy storage spacing between elements of y
 * sc element of rotation matrix
 * ss element of rotation matrix
 * Output
 * x rotated vector x ( unchanged if n < = 0)
 * y rotated vector y ( unchanged if n < = 0)
 * Reference http : / / www . netlib . org / blas / drot . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDrot ( int n , Pointer x , int incx , Pointer y , int incy , double sc , double ss ) { } }

implementation: cublasDrotNative ( n , x , incx , y , incy , sc , ss ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDrotg ( double * host _ sa , double * host _ sb , double * host _ sc , double * host _ ss )
 * constructs the Givens tranformation
 * ( sc ss )
 * G = ( ) , sc ^ 2 + ss ^ 2 = 1,
 * ( - ss sc )
 * which zeros the second entry of the 2 - vector transpose ( sa , sb ) .
 * The quantity r = ( + / - ) sqrt ( sa ^ 2 + sb ^ 2 ) overwrites sa in storage . The
 * value of sb is overwritten by a value z which allows sc and ss to be
 * recovered by the following algorithm :
 * if z = 1 set sc = 0.0 and ss = 1.0
 * if abs ( z ) < 1 set sc = sqrt ( 1 - z ^ 2 ) and ss = z
 * if abs ( z ) > 1 set sc = 1 / z and ss = sqrt ( 1 - sc ^ 2)
 * The function drot ( n , x , incx , y , incy , sc , ss ) normally is called next
 * to apply the transformation to a 2 x n matrix .
 * Note that is function is provided for completeness and run exclusively
 * on the Host .
 * Input
 * sa double - precision scalar
 * sb double - precision scalar
 * Output
 * sa double - precision r
 * sb double - precision z
 * sc double - precision result
 * ss double - precision result
 * Reference : http : / / www . netlib . org / blas / drotg . f
 * This function does not set any error status .
 * < / pre > */
public static void cublasDrotg ( Pointer host_sa , Pointer host_sb , Pointer host_sc , Pointer host_ss ) { } }

implementation: cublasDrotgNative ( host_sa , host_sb , host_sc , host_ss ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDscal ( int n , double alpha , double * x , int incx )
 * replaces double - precision vector x with double - precision alpha * x . For
 * i = 0 to n - 1 , it replaces x [ lx + i * incx ] with alpha * x [ lx + i * incx ] ,
 * where lx = 1 if incx > = 0 , else lx = 1 + ( 1 - n ) * incx .
 * Input
 * n number of elements in input vector
 * alpha double - precision scalar multiplier
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * Output
 * x double - precision result ( unchanged if n < = 0 or incx < = 0)
 * Reference : http : / / www . netlib . org / blas / dscal . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library was not initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDscal ( int n , double alpha , Pointer x , int incx ) { } }

implementation: cublasDscalNative ( n , alpha , x , incx ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDswap ( int n , double * x , int incx , double * y , int incy )
 * interchanges the double - precision vector x with the double - precision vector y .
 * For i = 0 to n - 1 , interchanges x [ lx + i * incx ] with y [ ly + i * incy ] , where
 * lx = 1 if incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a
 * similar way using incy .
 * Input
 * n number of elements in input vectors
 * x double precision vector with n elements
 * incx storage spacing between elements of x
 * y double precision vector with n elements
 * incy storage spacing between elements of y
 * Output
 * x contains double precision vector y
 * y contains double precision vector x
 * Reference : http : / / www . netlib . org / blas / dswap . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDswap ( int n , Pointer x , int incx , Pointer y , int incy ) { } }

implementation: cublasDswapNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * int
 * idamax ( int n , const double * x , int incx )
 * finds the smallest index of the maximum magnitude element of double -
 * precision vector x ; that is , the result is the first i , i = 0 to n - 1,
 * that maximizes abs ( x [ 1 + i * incx ] ) ) .
 * Input
 * n number of elements in input vector
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns the smallest index ( 0 if n < = 0 or incx < = 0)
 * Reference : http : / / www . netlib . org / blas / idamax . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static int cublasIdamax ( int n , Pointer x , int incx ) { } }

implementation: int result = cublasIdamaxNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * int
 * idamin ( int n , const double * x , int incx )
 * finds the smallest index of the minimum magnitude element of double -
 * precision vector x ; that is , the result is the first i , i = 0 to n - 1,
 * that minimizes abs ( x [ 1 + i * incx ] ) ) .
 * Input
 * n number of elements in input vector
 * x double - precision vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns the smallest index ( 0 if n < = 0 or incx < = 0)
 * Reference : http : / / www . netlib . org / scilib / blass . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static int cublasIdamin ( int n , Pointer x , int incx ) { } }

implementation: int result = cublasIdaminNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * cublasDgemv ( char trans , int m , int n , double alpha , const double * A ,
 * int lda , const double * x , int incx , double beta , double * y ,
 * int incy )
 * performs one of the matrix - vector operations
 * y = alpha * op ( A ) * x + beta * y ,
 * where op ( A ) is one of
 * op ( A ) = A or op ( A ) = transpose ( A )
 * where alpha and beta are double precision scalars , x and y are double
 * precision vectors , and A is an m x n matrix consisting of double precision
 * elements . Matrix A is stored in column major format , and lda is the leading
 * dimension of the two - dimensional array in which A is stored .
 * Input
 * trans specifies op ( A ) . If transa = ' n ' or ' N ' , op ( A ) = A . If trans =
 * trans = ' t ' , ' T ' , ' c ' , or ' C ' , op ( A ) = transpose ( A )
 * m specifies the number of rows of the matrix A . m must be at least
 * zero .
 * n specifies the number of columns of the matrix A . n must be at least
 * zero .
 * alpha double precision scalar multiplier applied to op ( A ) .
 * A double precision array of dimensions ( lda , n ) if trans = ' n ' or
 * ' N ' ) , and of dimensions ( lda , m ) otherwise . lda must be at least
 * max ( 1 , m ) and at least max ( 1 , n ) otherwise .
 * lda leading dimension of two - dimensional array used to store matrix A
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) )
 * when trans = ' N ' or ' n ' and at least ( 1 + ( m - 1 ) * abs ( incx ) )
 * otherwise .
 * incx specifies the storage spacing between elements of x . incx must not
 * be zero .
 * beta double precision scalar multiplier applied to vector y . If beta
 * is zero , y is not read .
 * y double precision array of length at least ( 1 + ( m - 1 ) * abs ( incy ) )
 * when trans = ' N ' or ' n ' and at least ( 1 + ( n - 1 ) * abs ( incy ) )
 * otherwise .
 * incy specifies the storage spacing between elements of x . incx must not
 * be zero .
 * Output
 * y updated according to alpha * op ( A ) * x + beta * y
 * Reference : http : / / www . netlib . org / blas / dgemv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if m or n are < 0 , or if incx or incy = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDgemv ( char trans , int m , int n , double alpha , Pointer A , int lda , Pointer x , int incx , double beta , Pointer y , int incy ) { } }

implementation: cublasDgemvNative ( trans , m , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * cublasDger ( int m , int n , double alpha , const double * x , int incx ,
 * const double * y , int incy , double * A , int lda )
 * performs the symmetric rank 1 operation
 * A = alpha * x * transpose ( y ) + A ,
 * where alpha is a double precision scalar , x is an m element double
 * precision vector , y is an n element double precision vector , and A
 * is an m by n matrix consisting of double precision elements . Matrix A
 * is stored in column major format , and lda is the leading dimension of
 * the two - dimensional array used to store A .
 * Input
 * m specifies the number of rows of the matrix A . It must be at least
 * zero .
 * n specifies the number of columns of the matrix A . It must be at
 * least zero .
 * alpha double precision scalar multiplier applied to x * transpose ( y )
 * x double precision array of length at least ( 1 + ( m - 1 ) * abs ( incx ) )
 * incx specifies the storage spacing between elements of x . incx must not
 * be zero .
 * y double precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) )
 * incy specifies the storage spacing between elements of y . incy must not
 * be zero .
 * A double precision array of dimensions ( lda , n ) .
 * lda leading dimension of two - dimensional array used to store matrix A
 * Output
 * A updated according to A = alpha * x * transpose ( y ) + A
 * Reference : http : / / www . netlib . org / blas / dger . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , incx = = 0 , incy = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDger ( int m , int n , double alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

implementation: cublasDgerNative ( m , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDsyr ( char uplo , int n , double alpha , const double * x , int incx ,
 * double * A , int lda )
 * performs the symmetric rank 1 operation
 * A = alpha * x * transpose ( x ) + A ,
 * where alpha is a double precision scalar , x is an n element double
 * precision vector and A is an n x n symmetric matrix consisting of
 * double precision elements . Matrix A is stored in column major format ,
 * and lda is the leading dimension of the two - dimensional array
 * containing A .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or
 * the lower triangular part of array A . If uplo = ' U ' or ' u ' ,
 * then only the upper triangular part of A may be referenced .
 * If uplo = ' L ' or ' l ' , then only the lower triangular part of
 * A may be referenced .
 * n specifies the number of rows and columns of the matrix A . It
 * must be at least 0.
 * alpha double precision scalar multiplier applied to x * transpose ( x )
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) )
 * incx specifies the storage spacing between elements of x . incx must
 * not be zero .
 * A double precision array of dimensions ( lda , n ) . If uplo = ' U ' or
 * ' u ' , then A must contain the upper triangular part of a symmetric
 * matrix , and the strictly lower triangular part is not referenced .
 * If uplo = ' L ' or ' l ' , then A contains the lower triangular part
 * of a symmetric matrix , and the strictly upper triangular part is
 * not referenced .
 * lda leading dimension of the two - dimensional array containing A . lda
 * must be at least max ( 1 , n ) .
 * Output
 * A updated according to A = alpha * x * transpose ( x ) + A
 * Reference : http : / / www . netlib . org / blas / dsyr . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , or incx = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDsyr ( char uplo , int n , double alpha , Pointer x , int incx , Pointer A , int lda ) { } }

implementation: cublasDsyrNative ( uplo , n , alpha , x , incx , A , lda ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void cublasDsyr2 ( char uplo , int n , double alpha , const double * x , int incx ,
 * const double * y , int incy , double * A , int lda )
 * performs the symmetric rank 2 operation
 * A = alpha * x * transpose ( y ) + alpha * y * transpose ( x ) + A ,
 * where alpha is a double precision scalar , x and y are n element double
 * precision vector and A is an n by n symmetric matrix consisting of double
 * precision elements .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the lower
 * triangular part of array A . If uplo = = ' U ' or ' u ' , then only the
 * upper triangular part of A may be referenced and the lower triangular
 * part of A is inferred . If uplo = = ' L ' or ' l ' , then only the lower
 * triangular part of A may be referenced and the upper triangular part
 * of A is inferred .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha double precision scalar multiplier applied to x * transpose ( y ) +
 * y * transpose ( x ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * y double precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * incy storage spacing between elements of y . incy must not be zero .
 * A double precision array of dimensions ( lda , n ) . If uplo = = ' U ' or ' u ' ,
 * then A must contains the upper triangular part of a symmetric matrix ,
 * and the strictly lower triangular parts is not referenced . If uplo = =
 * ' L ' or ' l ' , then A contains the lower triangular part of a symmetric
 * matrix , and the strictly upper triangular part is not referenced .
 * lda leading dimension of A . It must be at least max ( 1 , n ) .
 * Output
 * A updated according to A = alpha * x * transpose ( y ) + alpha * y * transpose ( x ) + A
 * Reference : http : / / www . netlib . org / blas / dsyr2 . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , incx = = 0 , incy = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDsyr2 ( char uplo , int n , double alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

implementation: cublasDsyr2Native ( uplo , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDspr ( char uplo , int n , double alpha , const double * x , int incx ,
 * double * AP )
 * performs the symmetric rank 1 operation
 * A = alpha * x * transpose ( x ) + A ,
 * where alpha is a double precision scalar and x is an n element double
 * precision vector . A is a symmetric n x n matrix consisting of double
 * precision elements that is supplied in packed form .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the lower
 * triangular part of array AP . If uplo = = ' U ' or ' u ' , then the upper
 * triangular part of A is supplied in AP . If uplo = = ' L ' or ' l ' , then
 * the lower triangular part of A is supplied in AP .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha double precision scalar multiplier applied to x * transpose ( x ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * AP double precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i < = j , then A [ i , j ] is stored is AP [ i + ( j * ( j + 1 ) / 2 ) ] . If
 * uplo = = ' L ' or ' L ' , the array AP contains the lower triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i > = j , then A [ i , j ] is stored in AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] .
 * Output
 * A updated according to A = alpha * x * transpose ( x ) + A
 * Reference : http : / / www . netlib . org / blas / dspr . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , or incx = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDspr ( char uplo , int n , double alpha , Pointer x , int incx , Pointer AP ) { } }

implementation: cublasDsprNative ( uplo , n , alpha , x , incx , AP ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDspr2 ( char uplo , int n , double alpha , const double * x , int incx ,
 * const double * y , int incy , double * AP )
 * performs the symmetric rank 2 operation
 * A = alpha * x * transpose ( y ) + alpha * y * transpose ( x ) + A ,
 * where alpha is a double precision scalar , and x and y are n element double
 * precision vectors . A is a symmetric n x n matrix consisting of double
 * precision elements that is supplied in packed form .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the lower
 * triangular part of array A . If uplo = = ' U ' or ' u ' , then only the
 * upper triangular part of A may be referenced and the lower triangular
 * part of A is inferred . If uplo = = ' L ' or ' l ' , then only the lower
 * triangular part of A may be referenced and the upper triangular part
 * of A is inferred .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha double precision scalar multiplier applied to x * transpose ( y ) +
 * y * transpose ( x ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * y double precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * incy storage spacing between elements of y . incy must not be zero .
 * AP double precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i < = j , then A [ i , j ] is stored is AP [ i + ( j * ( j + 1 ) / 2 ) ] . If
 * uplo = = ' L ' or ' L ' , the array AP contains the lower triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i > = j , then A [ i , j ] is stored in AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] .
 * Output
 * A updated according to A = alpha * x * transpose ( y ) + alpha * y * transpose ( x ) + A
 * Reference : http : / / www . netlib . org / blas / dspr2 . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , incx = = 0 , incy = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDspr2 ( char uplo , int n , double alpha , Pointer x , int incx , Pointer y , int incy , Pointer AP ) { } }

implementation: cublasDspr2Native ( uplo , n , alpha , x , incx , y , incy , AP ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDtrsv ( char uplo , char trans , char diag , int n , const double * A ,
 * int lda , double * x , int incx )
 * solves a system of equations op ( A ) * x = b , where op ( A ) is either A or
 * transpose ( A ) . b and x are double precision vectors consisting of n
 * elements , and A is an n x n matrix composed of a unit or non - unit , upper
 * or lower triangular matrix . Matrix A is stored in column major format ,
 * and lda is the leading dimension of the two - dimensional array containing
 * No test for singularity or near - singularity is included in this function .
 * Such tests must be performed before calling this function .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the
 * lower triangular part of array A . If uplo = ' U ' or ' u ' , then only
 * the upper triangular part of A may be referenced . If uplo = ' L ' or
 * ' l ' , then only the lower triangular part of A may be referenced .
 * trans specifies op ( A ) . If transa = ' n ' or ' N ' , op ( A ) = A . If transa = ' t ' ,
 * ' T ' , ' c ' , or ' C ' , op ( A ) = transpose ( A )
 * diag specifies whether or not A is a unit triangular matrix like so :
 * if diag = ' U ' or ' u ' , A is assumed to be unit triangular . If
 * diag = ' N ' or ' n ' , then A is not assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . It
 * must be at least 0.
 * A is a double precision array of dimensions ( lda , n ) . If uplo = ' U '
 * or ' u ' , then A must contains the upper triangular part of a symmetric
 * matrix , and the strictly lower triangular parts is not referenced .
 * If uplo = ' L ' or ' l ' , then A contains the lower triangular part of
 * a symmetric matrix , and the strictly upper triangular part is not
 * referenced .
 * lda is the leading dimension of the two - dimensional array containing A .
 * lda must be at least max ( 1 , n ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the n element right - hand side vector b . On exit ,
 * it is overwritten with the solution vector x .
 * incx specifies the storage spacing between elements of x . incx must not
 * be zero .
 * Output
 * x updated to contain the solution vector x that solves op ( A ) * x = b .
 * Reference : http : / / www . netlib . org / blas / dtrsv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if incx = = 0 or if n < 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDtrsv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { } }

implementation: cublasDtrsvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDtrmv ( char uplo , char trans , char diag , int n , const double * A ,
 * int lda , double * x , int incx ) ;
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) =
 * = A , or op ( A ) = transpose ( A ) . x is an n - element single precision vector , and
 * A is an n x n , unit or non - unit , upper or lower , triangular matrix composed
 * of single precision elements .
 * Input
 * uplo specifies whether the matrix A is an upper or lower triangular
 * matrix . If uplo = ' U ' or ' u ' , then A is an upper triangular matrix .
 * If uplo = ' L ' or ' l ' , then A is a lower triangular matrix .
 * trans specifies op ( A ) . If transa = ' N ' or ' n ' , op ( A ) = A . If trans = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A )
 * diag specifies whether or not matrix A is unit triangular . If diag = ' U '
 * or ' u ' , A is assumed to be unit triangular . If diag = ' N ' or ' n ' , A
 * is not assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero .
 * A single precision array of dimension ( lda , n ) . If uplo = ' U ' or ' u ' ,
 * the leading n x n upper triangular part of the array A must contain
 * the upper triangular matrix and the strictly lower triangular part
 * of A is not referenced . If uplo = ' L ' or ' l ' , the leading n x n lower
 * triangular part of the array A must contain the lower triangular
 * matrix and the strictly upper triangular part of A is not referenced .
 * When diag = ' U ' or ' u ' , the diagonal elements of A are not referenced
 * either , but are are assumed to be unity .
 * lda is the leading dimension of A . It must be at least max ( 1 , n ) .
 * x single precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the source vector . On exit , x is overwritten
 * with the result vector .
 * incx specifies the storage spacing for elements of x . incx must not be
 * zero .
 * Output
 * x updated according to x = op ( A ) * x ,
 * Reference : http : / / www . netlib . org / blas / dtrmv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if incx = = 0 or if n < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDtrmv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { } }

implementation: cublasDtrmvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDtbmv ( char uplo , char trans , char diag , int n , int k , const double * A ,
 * int lda , double * x , int incx )
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) = A ,
 * or op ( A ) = transpose ( A ) . x is an n - element double precision vector , and A is
 * an n x n , unit or non - unit , upper or lower triangular band matrix composed
 * of double precision elements .
 * Input
 * uplo specifies whether the matrix A is an upper or lower triangular band
 * matrix . If uplo = = ' U ' or ' u ' , A is an upper triangular band matrix .
 * If uplo = = ' L ' or ' l ' , A is a lower triangular band matrix .
 * trans specifies op ( A ) . If transa = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A )
 * diag specifies whether or not matrix A is unit triangular . If diag = = ' U '
 * or ' u ' , A is assumed to be unit triangular . If diag = = ' N ' or ' n ' , A
 * is not assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero .
 * k specifies the number of super - or sub - diagonals . If uplo = = ' U ' or
 * ' u ' , k specifies the number of super - diagonals . If uplo = = ' L ' or
 * ' l ' , k specifies the number of sub - diagonals . k must at least be
 * zero .
 * A double precision array of dimension ( lda , n ) . If uplo = = ' U ' or ' u ' ,
 * the leading ( k + 1 ) x n part of the array A must contain the upper
 * triangular band matrix , supplied column by column , with the leading
 * diagonal of the matrix in row ( k + 1 ) of the array , the first
 * super - diagonal starting at position 2 in row k , and so on . The top
 * left k x k triangle of the array A is not referenced . If uplo = = ' L '
 * or ' l ' , the leading ( k + 1 ) x n part of the array A must constain the
 * lower triangular band matrix , supplied column by column , with the
 * leading diagonal of the matrix in row 1 of the array , the first
 * sub - diagonal startingat position 1 in row 2 , and so on . The bottom
 * right k x k triangle of the array is not referenced .
 * lda is the leading dimension of A . It must be at least ( k + 1 ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the source vector . On exit , x is overwritten
 * with the result vector .
 * incx specifies the storage spacing for elements of x . incx must not be
 * zero .
 * Output
 * x updated according to x = op ( A ) * x
 * Reference : http : / / www . netlib . org / blas / dtbmv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n or k < 0 , or if incx = = 0
 * CUBLAS _ STATUS _ ALLOC _ FAILED if function cannot allocate enough internal scratch vector memory
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDtbmv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { } }

implementation: cublasDtbmvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDtpmv ( char uplo , char trans , char diag , int n , const double * AP ,
 * double * x , int incx ) ;
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) = A ,
 * or op ( A ) = transpose ( A ) . x is an n element double precision vector , and A
 * is an n x n , unit or non - unit , upper or lower triangular matrix composed
 * of double precision elements .
 * Input
 * uplo specifies whether the matrix A is an upper or lower triangular
 * matrix . If uplo = = ' U ' or ' u ' , then A is an upper triangular matrix .
 * If uplo = = ' L ' or ' l ' , then A is a lower triangular matrix .
 * trans specifies op ( A ) . If transa = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A )
 * diag specifies whether or not matrix A is unit triangular . If diag = = ' U '
 * or ' u ' , A is assumed to be unit triangular . If diag = = ' N ' or ' n ' , A
 * is not assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero . In the current implementation n must not exceed 4070.
 * AP double precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i < = j , then A [ i , j ] is stored in AP [ i + ( j * ( j + 1 ) / 2 ) ] . If
 * uplo = = ' L ' or ' L ' , the array AP contains the lower triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i > = j , then A [ i , j ] is stored in AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the source vector . On exit , x is overwritten
 * with the result vector .
 * incx specifies the storage spacing for elements of x . incx must not be
 * zero .
 * Output
 * x updated according to x = op ( A ) * x ,
 * Reference : http : / / www . netlib . org / blas / dtpmv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if incx = = 0 or n < 0
 * CUBLAS _ STATUS _ ALLOC _ FAILED if function cannot allocate enough internal scratch vector memory
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDtpmv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { } }

implementation: cublasDtpmvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDtpsv ( char uplo , char trans , char diag , int n , const double * AP ,
 * double * X , int incx )
 * solves one of the systems of equations op ( A ) * x = b , where op ( A ) is either
 * op ( A ) = A or op ( A ) = transpose ( A ) . b and x are n element vectors , and A is
 * an n x n unit or non - unit , upper or lower triangular matrix . No test for
 * singularity or near - singularity is included in this routine . Such tests
 * must be performed before calling this routine .
 * Input
 * uplo specifies whether the matrix is an upper or lower triangular matrix
 * as follows : If uplo = = ' U ' or ' u ' , A is an upper triangluar matrix .
 * If uplo = = ' L ' or ' l ' , A is a lower triangular matrix .
 * trans specifies op ( A ) . If trans = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A ) .
 * diag specifies whether A is unit triangular . If diag = = ' U ' or ' u ' , A is
 * assumed to be unit triangular ; thas is , diagonal elements are not
 * read and are assumed to be unity . If diag = = ' N ' or ' n ' , A is not
 * assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero .
 * AP double precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If uplo
 * = = ' U ' or ' u ' , the array AP contains the upper triangular matrix A ,
 * packed sequentially , column by column ; that is , if i < = j , then
 * A [ i , j ] is stored is AP [ i + ( j * ( j + 1 ) / 2 ) ] . If uplo = = ' L ' or ' L ' , the
 * array AP contains the lower triangular matrix A , packed sequentially ,
 * column by column ; that is , if i > = j , then A [ i , j ] is stored in
 * AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] . When diag = ' U ' or ' u ' , the diagonal elements
 * of A are not referenced and are assumed to be unity .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . It must not be zero .
 * Output
 * x updated to contain the solution vector x that solves op ( A ) * x = b .
 * Reference : http : / / www . netlib . org / blas / dtpsv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if incx = = 0 or if n < 0 or n > 2035
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDtpsv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { } }

implementation: cublasDtpsvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void cublasDtbsv ( char uplo , char trans , char diag , int n , int k ,
 * const double * A , int lda , double * X , int incx )
 * solves one of the systems of equations op ( A ) * x = b , where op ( A ) is either
 * op ( A ) = A or op ( A ) = transpose ( A ) . b and x are n element vectors , and A is
 * an n x n unit or non - unit , upper or lower triangular band matrix with k + 1
 * diagonals . No test for singularity or near - singularity is included in this
 * function . Such tests must be performed before calling this function .
 * Input
 * uplo specifies whether the matrix is an upper or lower triangular band
 * matrix as follows : If uplo = = ' U ' or ' u ' , A is an upper triangular
 * band matrix . If uplo = = ' L ' or ' l ' , A is a lower triangular band
 * matrix .
 * trans specifies op ( A ) . If trans = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A ) .
 * diag specifies whether A is unit triangular . If diag = = ' U ' or ' u ' , A is
 * assumed to be unit triangular ; thas is , diagonal elements are not
 * read and are assumed to be unity . If diag = = ' N ' or ' n ' , A is not
 * assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero .
 * k specifies the number of super - or sub - diagonals . If uplo = = ' U ' or
 * ' u ' , k specifies the number of super - diagonals . If uplo = = ' L ' or
 * ' l ' , k specifies the number of sub - diagonals . k must at least be
 * zero .
 * A double precision array of dimension ( lda , n ) . If uplo = = ' U ' or ' u ' ,
 * the leading ( k + 1 ) x n part of the array A must contain the upper
 * triangular band matrix , supplied column by column , with the leading
 * diagonal of the matrix in row ( k + 1 ) of the array , the first super -
 * diagonal starting at position 2 in row k , and so on . The top left
 * k x k triangle of the array A is not referenced . If uplo = = ' L ' or
 * ' l ' , the leading ( k + 1 ) x n part of the array A must constain the
 * lower triangular band matrix , supplied column by column , with the
 * leading diagonal of the matrix in row 1 of the array , the first
 * sub - diagonal starting at position 1 in row 2 , and so on . The bottom
 * right k x k triangle of the array is not referenced .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . It must not be zero .
 * Output
 * x updated to contain the solution vector x that solves op ( A ) * x = b .
 * Reference : http : / / www . netlib . org / blas / dtbsv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if incx = = 0 , n < 0 or n > 2035
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDtbsv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { } }

implementation: cublasDtbsvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDsymv ( char uplo , int n , double alpha , const double * A , int lda ,
 * const double * x , int incx , double beta , double * y , int incy )
 * performs the matrix - vector operation
 * y = alpha * A * x + beta * y
 * Alpha and beta are double precision scalars , and x and y are double
 * precision vectors , each with n elements . A is a symmetric n x n matrix
 * consisting of double precision elements that is stored in either upper or
 * lower storage mode .
 * Input
 * uplo specifies whether the upper or lower triangular part of the array A
 * is to be referenced . If uplo = = ' U ' or ' u ' , the symmetric matrix A
 * is stored in upper storage mode , i . e . only the upper triangular part
 * of A is to be referenced while the lower triangular part of A is to
 * be inferred . If uplo = = ' L ' or ' l ' , the symmetric matrix A is stored
 * in lower storage mode , i . e . only the lower triangular part of A is
 * to be referenced while the upper triangular part of A is to be
 * inferred .
 * n specifies the number of rows and the number of columns of the
 * symmetric matrix A . n must be at least zero .
 * alpha double precision scalar multiplier applied to A * x .
 * A double precision array of dimensions ( lda , n ) . If uplo = = ' U ' or ' u ' ,
 * the leading n x n upper triangular part of the array A must contain
 * the upper triangular part of the symmetric matrix and the strictly
 * lower triangular part of A is not referenced . If uplo = = ' L ' or ' l ' ,
 * the leading n x n lower triangular part of the array A must contain
 * the lower triangular part of the symmetric matrix and the strictly
 * upper triangular part of A is not referenced .
 * lda leading dimension of A . It must be at least max ( 1 , n ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * beta double precision scalar multiplier applied to vector y .
 * y double precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * If beta is zero , y is not read .
 * incy storage spacing between elements of y . incy must not be zero .
 * Output
 * y updated according to y = alpha * A * x + beta * y
 * Reference : http : / / www . netlib . org / blas / dsymv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , or if incx or incy = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDsymv ( char uplo , int n , double alpha , Pointer A , int lda , Pointer x , int incx , double beta , Pointer y , int incy ) { } }

implementation: cublasDsymvNative ( uplo , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDsbmv ( char uplo , int n , int k , double alpha , const double * A , int lda ,
 * const double * x , int incx , double beta , double * y , int incy )
 * performs the matrix - vector operation
 * y : = alpha * A * x + beta * y
 * alpha and beta are double precision scalars . x and y are double precision
 * vectors with n elements . A is an n by n symmetric band matrix consisting
 * of double precision elements , with k super - diagonals and the same number
 * of subdiagonals .
 * Input
 * uplo specifies whether the upper or lower triangular part of the symmetric
 * band matrix A is being supplied . If uplo = = ' U ' or ' u ' , the upper
 * triangular part is being supplied . If uplo = = ' L ' or ' l ' , the lower
 * triangular part is being supplied .
 * n specifies the number of rows and the number of columns of the
 * symmetric matrix A . n must be at least zero .
 * k specifies the number of super - diagonals of matrix A . Since the matrix
 * is symmetric , this is also the number of sub - diagonals . k must be at
 * least zero .
 * alpha double precision scalar multiplier applied to A * x .
 * A double precision array of dimensions ( lda , n ) . When uplo = = ' U ' or
 * ' u ' , the leading ( k + 1 ) x n part of array A must contain the upper
 * triangular band of the symmetric matrix , supplied column by column ,
 * with the leading diagonal of the matrix in row ( k + 1 ) of the array ,
 * the first super - diagonal starting at position 2 in row k , and so on .
 * The top left k x k triangle of the array A is not referenced . When
 * uplo = = ' L ' or ' l ' , the leading ( k + 1 ) x n part of the array A must
 * contain the lower triangular band part of the symmetric matrix ,
 * supplied column by column , with the leading diagonal of the matrix in
 * row 1 of the array , the first sub - diagonal starting at position 1 in
 * row 2 , and so on . The bottom right k x k triangle of the array A is
 * not referenced .
 * lda leading dimension of A . lda must be at least ( k + 1 ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * beta double precision scalar multiplier applied to vector y . If beta is
 * zero , y is not read .
 * y double precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * If beta is zero , y is not read .
 * incy storage spacing between elements of y . incy must not be zero .
 * Output
 * y updated according to alpha * A * x + beta * y
 * Reference : http : / / www . netlib . org / blas / dsbmv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if k or n < 0 , or if incx or incy = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDsbmv ( char uplo , int n , int k , double alpha , Pointer A , int lda , Pointer x , int incx , double beta , Pointer y , int incy ) { } }

implementation: cublasDsbmvNative ( uplo , n , k , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDspmv ( char uplo , int n , double alpha , const double * AP , const double * x ,
 * int incx , double beta , double * y , int incy )
 * performs the matrix - vector operation
 * y = alpha * A * x + beta * y
 * Alpha and beta are double precision scalars , and x and y are double
 * precision vectors with n elements . A is a symmetric n x n matrix
 * consisting of double precision elements that is supplied in packed form .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the lower
 * triangular part of array AP . If uplo = = ' U ' or ' u ' , then the upper
 * triangular part of A is supplied in AP . If uplo = = ' L ' or ' l ' , then
 * the lower triangular part of A is supplied in AP .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha double precision scalar multiplier applied to A * x .
 * AP double precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i < = j , then A [ i , j ] is stored is AP [ i + ( j * ( j + 1 ) / 2 ) ] . If
 * uplo = = ' L ' or ' L ' , the array AP contains the lower triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i > = j , then A [ i , j ] is stored in AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * beta double precision scalar multiplier applied to vector y ;
 * y double precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * If beta is zero , y is not read .
 * incy storage spacing between elements of y . incy must not be zero .
 * Output
 * y updated according to y = alpha * A * x + beta * y
 * Reference : http : / / www . netlib . org / blas / dspmv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , or if incx or incy = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDspmv ( char uplo , int n , double alpha , Pointer AP , Pointer x , int incx , double beta , Pointer y , int incy ) { } }

implementation: cublasDspmvNative ( uplo , n , alpha , AP , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDtrsm ( char side , char uplo , char transa , char diag , int m , int n ,
 * double alpha , const double * A , int lda , double * B , int ldb )
 * solves one of the matrix equations
 * op ( A ) * X = alpha * B , or X * op ( A ) = alpha * B ,
 * where alpha is a double precision scalar , and X and B are m x n matrices
 * that are composed of double precision elements . A is a unit or non - unit ,
 * upper or lower triangular matrix , and op ( A ) is one of
 * op ( A ) = A or op ( A ) = transpose ( A )
 * The result matrix X overwrites input matrix B ; that is , on exit the result
 * is stored in B . Matrices A and B are stored in column major format , and
 * lda and ldb are the leading dimensions of the two - dimensonials arrays that
 * contain A and B , respectively .
 * Input
 * side specifies whether op ( A ) appears on the left or right of X as
 * follows : side = ' L ' or ' l ' indicates solve op ( A ) * X = alpha * B .
 * side = ' R ' or ' r ' indicates solve X * op ( A ) = alpha * B .
 * uplo specifies whether the matrix A is an upper or lower triangular
 * matrix as follows : uplo = ' U ' or ' u ' indicates A is an upper
 * triangular matrix . uplo = ' L ' or ' l ' indicates A is a lower
 * triangular matrix .
 * transa specifies the form of op ( A ) to be used in matrix multiplication
 * as follows : If transa = ' N ' or ' N ' , then op ( A ) = A . If transa =
 * ' T ' , ' t ' , ' C ' , or ' c ' , then op ( A ) = transpose ( A ) .
 * diag specifies whether or not A is a unit triangular matrix like so :
 * if diag = ' U ' or ' u ' , A is assumed to be unit triangular . If
 * diag = ' N ' or ' n ' , then A is not assumed to be unit triangular .
 * m specifies the number of rows of B . m must be at least zero .
 * n specifies the number of columns of B . n must be at least zero .
 * alpha is a double precision scalar to be multiplied with B . When alpha is
 * zero , then A is not referenced and B need not be set before entry .
 * A is a double precision array of dimensions ( lda , k ) , where k is
 * m when side = ' L ' or ' l ' , and is n when side = ' R ' or ' r ' . If
 * uplo = ' U ' or ' u ' , the leading k x k upper triangular part of
 * the array A must contain the upper triangular matrix and the
 * strictly lower triangular matrix of A is not referenced . When
 * uplo = ' L ' or ' l ' , the leading k x k lower triangular part of
 * the array A must contain the lower triangular matrix and the
 * strictly upper triangular part of A is not referenced . Note that
 * when diag = ' U ' or ' u ' , the diagonal elements of A are not
 * referenced , and are assumed to be unity .
 * lda is the leading dimension of the two dimensional array containing A .
 * When side = ' L ' or ' l ' then lda must be at least max ( 1 , m ) , when
 * side = ' R ' or ' r ' then lda must be at least max ( 1 , n ) .
 * B is a double precision array of dimensions ( ldb , n ) . ldb must be
 * at least max ( 1 , m ) . The leading m x n part of the array B must
 * contain the right - hand side matrix B . On exit B is overwritten
 * by the solution matrix X .
 * ldb is the leading dimension of the two dimensional array containing B .
 * ldb must be at least max ( 1 , m ) .
 * Output
 * B contains the solution matrix X satisfying op ( A ) * X = alpha * B ,
 * or X * op ( A ) = alpha * B
 * Reference : http : / / www . netlib . org / blas / dtrsm . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if m or n < 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDtrsm ( char side , char uplo , char transa , char diag , int m , int n , double alpha , Pointer A , int lda , Pointer B , int ldb ) { } }

implementation: cublasDtrsmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZtrsm ( char side , char uplo , char transa , char diag , int m , int n ,
 * cuDoubleComplex alpha , const cuDoubleComplex * A , int lda ,
 * cuDoubleComplex * B , int ldb )
 * solves one of the matrix equations
 * op ( A ) * X = alpha * B , or X * op ( A ) = alpha * B ,
 * where alpha is a double precision complex scalar , and X and B are m x n matrices
 * that are composed of double precision complex elements . A is a unit or non - unit ,
 * upper or lower triangular matrix , and op ( A ) is one of
 * op ( A ) = A or op ( A ) = transpose ( A ) or op ( A ) = conj ( A ' ) .
 * The result matrix X overwrites input matrix B ; that is , on exit the result
 * is stored in B . Matrices A and B are stored in column major format , and
 * lda and ldb are the leading dimensions of the two - dimensonials arrays that
 * contain A and B , respectively .
 * Input
 * side specifies whether op ( A ) appears on the left or right of X as
 * follows : side = ' L ' or ' l ' indicates solve op ( A ) * X = alpha * B .
 * side = ' R ' or ' r ' indicates solve X * op ( A ) = alpha * B .
 * uplo specifies whether the matrix A is an upper or lower triangular
 * matrix as follows : uplo = ' U ' or ' u ' indicates A is an upper
 * triangular matrix . uplo = ' L ' or ' l ' indicates A is a lower
 * triangular matrix .
 * transa specifies the form of op ( A ) to be used in matrix multiplication
 * as follows : If transa = ' N ' or ' N ' , then op ( A ) = A . If transa =
 * ' T ' , ' t ' , ' C ' , or ' c ' , then op ( A ) = transpose ( A ) .
 * diag specifies whether or not A is a unit triangular matrix like so :
 * if diag = ' U ' or ' u ' , A is assumed to be unit triangular . If
 * diag = ' N ' or ' n ' , then A is not assumed to be unit triangular .
 * m specifies the number of rows of B . m must be at least zero .
 * n specifies the number of columns of B . n must be at least zero .
 * alpha is a double precision complex scalar to be multiplied with B . When alpha is
 * zero , then A is not referenced and B need not be set before entry .
 * A is a double precision complex array of dimensions ( lda , k ) , where k is
 * m when side = ' L ' or ' l ' , and is n when side = ' R ' or ' r ' . If
 * uplo = ' U ' or ' u ' , the leading k x k upper triangular part of
 * the array A must contain the upper triangular matrix and the
 * strictly lower triangular matrix of A is not referenced . When
 * uplo = ' L ' or ' l ' , the leading k x k lower triangular part of
 * the array A must contain the lower triangular matrix and the
 * strictly upper triangular part of A is not referenced . Note that
 * when diag = ' U ' or ' u ' , the diagonal elements of A are not
 * referenced , and are assumed to be unity .
 * lda is the leading dimension of the two dimensional array containing A .
 * When side = ' L ' or ' l ' then lda must be at least max ( 1 , m ) , when
 * side = ' R ' or ' r ' then lda must be at least max ( 1 , n ) .
 * B is a double precision complex array of dimensions ( ldb , n ) . ldb must be
 * at least max ( 1 , m ) . The leading m x n part of the array B must
 * contain the right - hand side matrix B . On exit B is overwritten
 * by the solution matrix X .
 * ldb is the leading dimension of the two dimensional array containing B .
 * ldb must be at least max ( 1 , m ) .
 * Output
 * B contains the solution matrix X satisfying op ( A ) * X = alpha * B ,
 * or X * op ( A ) = alpha * B
 * Reference : http : / / www . netlib . org / blas / ztrsm . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if m or n < 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZtrsm ( char side , char uplo , char transa , char diag , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb ) { } }

implementation: cublasZtrsmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ;