signature:
public class JCublas { /** * < pre >
 * void cublasZtbsv ( char uplo , char trans , char diag , int n , int k ,
 * const cuDoubleComplex * A , int lda , cuDoubleComplex * X , int incx )
 * solves one of the systems of equations op ( A ) * x = b , where op ( A ) is either
 * op ( A ) = A , op ( A ) = transpose ( A ) or op ( A ) = conjugate ( 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 ' , op ( A ) = transpose ( A ) . If trans = = ' C ' or ' c ' ,
 * op ( A ) = conjugate ( 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 complex 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 complex 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 / ztbsv . 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 > 1016
 * 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 cublasZtbsv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZhemv ( char uplo , int n , cuDoubleComplex alpha , const cuDoubleComplex * A , int lda ,
 * const cuDoubleComplex * x , int incx , cuDoubleComplex beta , cuDoubleComplex * y , int incy )
 * performs the matrix - vector operation
 * y = alpha * A * x + beta * y
 * Alpha and beta are double precision complex scalars , and x and y are double
 * precision complex vectors , each with n elements . A is a hermitian n x n matrix
 * consisting of double precision complex 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 hermitian 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 hermitian 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
 * hermitian matrix A . n must be at least zero .
 * alpha double precision complex scalar multiplier applied to A * x .
 * A double precision complex 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 hermitian 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 hermitian matrix and the strictly
 * upper triangular part of A 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 . It must be at least max ( 1 , n ) .
 * x double precision complex 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 complex scalar multiplier applied to vector y .
 * y double precision complex 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 / zhemv . 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 cublasZhemv ( char uplo , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZhpmv ( char uplo , int n , cuDoubleComplex alpha , const cuDoubleComplex * AP , const cuDoubleComplex * x ,
 * int incx , cuDoubleComplex beta , cuDoubleComplex * y , int incy )
 * performs the matrix - vector operation
 * y = alpha * A * x + beta * y
 * Alpha and beta are double precision complex scalars , and x and y are double
 * precision complex vectors with n elements . A is an hermitian n x n matrix
 * consisting of double precision complex 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 complex scalar multiplier applied to A * x .
 * AP double precision complex array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the hermitian 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 hermitian 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 ] .
 * The imaginary parts of the diagonal elements need not be set , they
 * are assumed to be zero .
 * x double precision complex 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 complex 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 / zhpmv . 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 cublasZhpmv ( char uplo , int n , cuDoubleComplex alpha , Pointer AP , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * cublasZgemv ( char trans , int m , int n , cuDoubleComplex alpha , const cuDoubleComplex * A , int lda ,
 * const cuDoubleComplex * x , int incx , cuDoubleComplex beta , cuDoubleComplex * 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 / zgemv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZgemv ( char trans , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZtpmv ( char uplo , char trans , char diag , int n , const cuDoubleComplex * AP ,
 * cuDoubleComplex * x , int incx ) ;
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) = A ,
 * op ( A ) = transpose ( A ) or op ( A ) = conjugate ( transpose ( A ) ) . x is an n element
 * double precision complex vector , and A is an n x n , unit or non - unit , upper
 * or lower triangular matrix composed of double precision complex 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 ' ,
 * or ' t ' , op ( A ) = transpose ( A ) . If trans = = ' C ' or ' c ' ,
 * op ( A ) = conjugate ( 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 complex 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 complex 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 / ztpmv . 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 cublasZtpmv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZtpsv ( char uplo , char trans , char diag , int n , const cuDoubleComplex * AP ,
 * cuDoubleComplex * X , int incx )
 * solves one of the systems of equations op ( A ) * x = b , where op ( A ) is either
 * op ( A ) = A , op ( A ) = transpose ( A ) or op ( A ) = conjugate ( transpose ) ) . b and
 * x are n element complex 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 '
 * or ' t ' , op ( A ) = transpose ( A ) . If trans = = ' C ' or ' c ' , op ( A ) =
 * conjugate ( 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 complex 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 complex 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 / ztpsv . 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 cublasZtpsv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * cublasCgemv ( char trans , int m , int n , cuComplex alpha , const cuComplex * A ,
 * int lda , const cuComplex * x , int incx , cuComplex beta , cuComplex * 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 ) or op ( A ) = conjugate ( transpose ( A ) )
 * where alpha and beta are single precision scalars , x and y are single
 * precision vectors , and A is an m x n matrix consisting of single 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 ' or ' T ' , op ( A ) = transpose ( A ) . If trans = ' c ' or ' C ' ,
 * op ( A ) = conjugate ( 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 single precision scalar multiplier applied to op ( A ) .
 * A single 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 single 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 single precision scalar multiplier applied to vector y . If beta
 * is zero , y is not read .
 * y single 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 y . incy must not
 * be zero .
 * Output
 * y updated according to alpha * op ( A ) * x + beta * y
 * Reference : http : / / www . netlib . org / blas / cgemv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCgemv ( char trans , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer x , int incx , cuComplex beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCgbmv ( char trans , int m , int n , int kl , int ku , cuComplex alpha ,
 * const cuComplex * A , int lda , const cuComplex * x , int incx , cuComplex beta ,
 * cuComplex * y , int incy ) ;
 * performs one of the matrix - vector operations
 * y = alpha * op ( A ) * x + beta * y , op ( A ) = A or op ( A ) = transpose ( A )
 * alpha and beta are single precision complex scalars . x and y are single precision
 * complex vectors . A is an m by n band matrix consisting of single precision complex elements
 * with kl sub - diagonals and ku super - diagonals .
 * Input
 * trans specifies op ( A ) . If trans = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * or ' t ' , op ( A ) = transpose ( A ) . If trans = = ' C ' or ' c ' ,
 * op ( A ) = conjugate ( 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 .
 * kl specifies the number of sub - diagonals of matrix A . It must be at
 * least zero .
 * ku specifies the number of super - diagonals of matrix A . It must be at
 * least zero .
 * alpha single precision complex scalar multiplier applied to op ( A ) .
 * A single precision complex array of dimensions ( lda , n ) . The leading
 * ( kl + ku + 1 ) x n part of the array A must contain the band matrix A ,
 * supplied column by column , with the leading diagonal of the matrix
 * in row ( ku + 1 ) of the array , the first super - diagonal starting at
 * position 2 in row ku , the first sub - diagonal starting at position 1
 * in row ( ku + 2 ) , and so on . Elements in the array A that do not
 * correspond to elements in the band matrix ( such as the top left
 * ku x ku triangle ) are not referenced .
 * lda leading dimension of A . lda must be at least ( kl + ku + 1 ) .
 * x single precision complex 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 increment for the elements of x . incx must not be zero .
 * beta single precision complex scalar multiplier applied to vector y . If beta is
 * zero , y is not read .
 * y single precision complex array of length at least ( 1 + ( m - 1 ) * abs ( incy ) ) when
 * trans = = ' N ' or ' n ' and at least ( 1 + ( n - 1 ) * abs ( incy ) ) otherwise . If
 * beta is zero , y is not read .
 * incy On entry , incy specifies the increment for the elements of y . incy
 * must not be zero .
 * Output
 * y updated according to y = alpha * op ( A ) * x + beta * y
 * Reference : http : / / www . netlib . org / blas / cgbmv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCgbmv ( char trans , int m , int n , int kl , int ku , cuComplex alpha , Pointer A , int lda , Pointer x , int incx , cuComplex beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasChemv ( char uplo , int n , cuComplex alpha , const cuComplex * A , int lda ,
 * const cuComplex * x , int incx , cuComplex beta , cuComplex * y , int incy )
 * performs the matrix - vector operation
 * y = alpha * A * x + beta * y
 * Alpha and beta are single precision complex scalars , and x and y are single
 * precision complex vectors , each with n elements . A is a hermitian n x n matrix
 * consisting of single precision complex 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 hermitian 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 hermitian 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
 * hermitian matrix A . n must be at least zero .
 * alpha single precision complex scalar multiplier applied to A * x .
 * A single precision complex 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 hermitian 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 hermitian matrix and the strictly
 * upper triangular part of A 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 . It must be at least max ( 1 , n ) .
 * x single precision complex array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * beta single precision complex scalar multiplier applied to vector y .
 * y single precision complex 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 / chemv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasChemv ( char uplo , int n , cuComplex alpha , Pointer A , int lda , Pointer x , int incx , cuComplex beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasChbmv ( char uplo , int n , int k , cuComplex alpha , const cuComplex * A , int lda ,
 * const cuComplex * x , int incx , cuComplex beta , cuComplex * y , int incy )
 * performs the matrix - vector operation
 * y : = alpha * A * x + beta * y
 * alpha and beta are single precision complex scalars . x and y are single precision
 * complex vectors with n elements . A is an n by n hermitian band matrix consisting
 * of single precision complex elements , with k super - diagonals and the same number
 * of subdiagonals .
 * Input
 * uplo specifies whether the upper or lower triangular part of the hermitian
 * 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
 * hermitian matrix A . n must be at least zero .
 * k specifies the number of super - diagonals of matrix A . Since the matrix
 * is hermitian , this is also the number of sub - diagonals . k must be at
 * least zero .
 * alpha single precision complex scalar multiplier applied to A * x .
 * A single precision complex 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 hermitian 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 hermitian 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 . The imaginary parts of the diagonal elements need
 * not be set , they are assumed to be zero .
 * lda leading dimension of A . lda must be at least ( k + 1 ) .
 * x single precision complex array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * beta single precision complex scalar multiplier applied to vector y . If beta is
 * zero , y is not read .
 * y single precision complex 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 / chbmv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasChbmv ( char uplo , int n , int k , cuComplex alpha , Pointer A , int lda , Pointer x , int incx , cuComplex beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * cublasCtrmv ( char uplo , char trans , char diag , int n , const cuComplex * A ,
 * int lda , cuComplex * x , int incx ) ;
 * performs one of the matrix - vector operations x = op ( A ) * x ,
 * where op ( A ) = A , or op ( A ) = transpose ( A ) or op ( A ) = conjugate ( transpose ( A ) ) .
 * x is an n - element signle precision complex vector , and
 * A is an n x n , unit or non - unit , upper or lower , triangular matrix composed
 * of single precision complex 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 trans = ' n ' or ' N ' , op ( A ) = A . If trans = ' t ' or
 * ' T ' , op ( A ) = transpose ( A ) . If trans = ' c ' or ' C ' , op ( A ) =
 * conjugate ( 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 / ctrmv . 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 cublasCtrmv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCtbmv ( char uplo , char trans , char diag , int n , int k , const cuComplex * A ,
 * int lda , cuComplex * x , int incx )
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) = A ,
 * op ( A ) = transpose ( A ) or op ( A ) = conjugate ( transpose ( A ) ) . x is an n - element
 * single precision complex vector , and A is an n x n , unit or non - unit , upper
 * or lower triangular band matrix composed of single precision complex 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 ' ,
 * or ' t ' , op ( A ) = transpose ( A ) . If trans = = ' C ' or ' c ' ,
 * op ( A ) = conjugate ( 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 single precision complex 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 single precision complex 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 / ctbmv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCtbmv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCtpmv ( char uplo , char trans , char diag , int n , const cuComplex * AP ,
 * cuComplex * x , int incx ) ;
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) = A ,
 * op ( A ) = transpose ( A ) or op ( A ) = conjugate ( transpose ( A ) ) . x is an n element
 * single precision complex vector , and A is an n x n , unit or non - unit , upper
 * or lower triangular matrix composed of single precision complex 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 ' ,
 * or ' t ' , op ( A ) = transpose ( A ) . If trans = = ' C ' or ' c ' ,
 * op ( A ) = conjugate ( 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 single precision complex 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 single precision complex 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 / ctpmv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCtpmv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCtrsv ( char uplo , char trans , char diag , int n , const cuComplex * A ,
 * int lda , cuComplex * x , int incx )
 * solves a system of equations op ( A ) * x = b , where op ( A ) is either A ,
 * transpose ( A ) or conjugate ( transpose ( A ) ) . b and x are single precision
 * complex 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 A .
 * 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 single precision complex 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 single precision complex 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 / ctrsv . 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 cublasCtrsv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void cublasCtbsv ( char uplo , char trans , char diag , int n , int k ,
 * const cuComplex * A , int lda , cuComplex * X , int incx )
 * solves one of the systems of equations op ( A ) * x = b , where op ( A ) is either
 * op ( A ) = A , op ( A ) = transpose ( A ) or op ( A ) = conjugate ( 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 ' , op ( A ) = transpose ( A ) . If trans = = ' C ' or ' c ' ,
 * op ( A ) = conjugate ( 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 single precision complex 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 single precision complex 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 / ctbsv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCtbsv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCtpsv ( char uplo , char trans , char diag , int n , const cuComplex * AP ,
 * cuComplex * X , int incx )
 * solves one of the systems of equations op ( A ) * x = b , where op ( A ) is either
 * op ( A ) = A , op ( A ) = transpose ( A ) or op ( A ) = conjugate ( transpose ) ) . b and
 * x are n element complex 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 '
 * or ' t ' , op ( A ) = transpose ( A ) . If trans = = ' C ' or ' c ' , op ( A ) =
 * conjugate ( 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 single precision complex 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 single precision complex 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 / ctpsv . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCtpsv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * cublasCgeru ( int m , int n , cuComplex alpha , const cuComplex * x , int incx ,
 * const cuComplex * y , int incy , cuComplex * A , int lda )
 * performs the symmetric rank 1 operation
 * A = alpha * x * transpose ( y ) + A ,
 * where alpha is a single precision complex scalar , x is an m element single
 * precision complex vector , y is an n element single precision complex vector , and A
 * is an m by n matrix consisting of single precision complex 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 single precision complex scalar multiplier applied to x * transpose ( y )
 * x single precision complex 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 single precision complex 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 single precision complex 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 / cgeru . 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 < 0 , n < 0 , incx = = 0 , incy = = 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCgeru ( int m , int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * cublasCgerc ( int m , int n , cuComplex alpha , const cuComplex * x , int incx ,
 * const cuComplex * y , int incy , cuComplex * A , int lda )
 * performs the symmetric rank 1 operation
 * A = alpha * x * conjugate ( transpose ( y ) ) + A ,
 * where alpha is a single precision complex scalar , x is an m element single
 * precision complex vector , y is an n element single precision complex vector , and A
 * is an m by n matrix consisting of single precision complex 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 single precision complex scalar multiplier applied to x * transpose ( y )
 * x single precision complex 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 single precision complex 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 single precision complex 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 * conjugate ( transpose ( y ) ) + A
 * Reference : http : / / www . netlib . org / blas / cgerc . 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 < 0 , n < 0 , incx = = 0 , incy = = 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCgerc ( int m , int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCher ( char uplo , int n , float alpha , const cuComplex * x , int incx ,
 * cuComplex * A , int lda )
 * performs the hermitian rank 1 operation
 * A = alpha * x * conjugate ( transpose ( x ) ) + A ,
 * where alpha is a single precision real scalar , x is an n element single
 * precision complex vector and A is an n x n hermitian matrix consisting of
 * single precision complex 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 single precision real scalar multiplier applied to
 * x * conjugate ( transpose ( x ) )
 * x single precision complex 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 single precision complex array of dimensions ( lda , n ) . If uplo = ' U ' or
 * ' u ' , then A must contain the upper triangular part of a hermitian
 * matrix , and the strictly lower triangular part is not referenced .
 * If uplo = ' L ' or ' l ' , then A contains the lower triangular part
 * of a 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 , and on exit they
 * are set to zero .
 * 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 * conjugate ( transpose ( x ) ) + A
 * Reference : http : / / www . netlib . org / blas / cher . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCher ( char uplo , int n , float alpha , Pointer x , int incx , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasChpr ( char uplo , int n , float alpha , const cuComplex * x , int incx ,
 * cuComplex * AP )
 * performs the hermitian rank 1 operation
 * A = alpha * x * conjugate ( transpose ( x ) ) + A ,
 * where alpha is a single precision real scalar and x is an n element single
 * precision complex vector . A is a hermitian n x n matrix consisting of single
 * precision complex 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 single precision real scalar multiplier applied to x * conjugate ( transpose ( x ) ) .
 * x single precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * AP single precision complex array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the hermitian 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 hermitian 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 ] .
 * 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 .
 * Output
 * A updated according to A = alpha * x * conjugate ( transpose ( x ) ) + A
 * Reference : http : / / www . netlib . org / blas / chpr . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasChpr ( char uplo , int n , float alpha , Pointer x , int incx , Pointer AP ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasChpr2 ( char uplo , int n , cuComplex alpha , const cuComplex * x , int incx ,
 * const cuComplex * y , int incy , cuComplex * AP )
 * performs the hermitian rank 2 operation
 * A = alpha * x * conjugate ( transpose ( y ) ) + conjugate ( alpha ) * y * conjugate ( transpose ( x ) ) + A ,
 * where alpha is a single precision complex scalar , and x and y are n element single
 * precision complex vectors . A is a hermitian n x n matrix consisting of single
 * precision complex 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 single precision complex scalar multiplier applied to x * conjugate ( transpose ( y ) ) +
 * y * conjugate ( transpose ( x ) ) .
 * x single precision complex array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * y single precision complex array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * incy storage spacing between elements of y . incy must not be zero .
 * AP single precision complex array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the hermitian 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 hermitian 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 ] .
 * 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 .
 * Output
 * A updated according to A = alpha * x * conjugate ( transpose ( y ) )
 * + conjugate ( alpha ) * y * conjugate ( transpose ( x ) ) + A
 * Reference : http : / / www . netlib . org / blas / chpr2 . 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 cublasChpr2 ( char uplo , int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer AP ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void cublasCher2 ( char uplo , int n , cuComplex alpha , const cuComplex * x , int incx ,
 * const cuComplex * y , int incy , cuComplex * A , int lda )
 * performs the hermitian rank 2 operation
 * A = alpha * x * conjugate ( transpose ( y ) ) + conjugate ( alpha ) * y * conjugate ( transpose ( x ) ) + A ,
 * where alpha is a single precision complex scalar , x and y are n element single
 * precision complex vector and A is an n by n hermitian matrix consisting of single
 * precision complex 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 single precision complex scalar multiplier applied to x * conjugate ( transpose ( y ) ) +
 * y * conjugate ( transpose ( x ) ) .
 * x single precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * y single precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * incy storage spacing between elements of y . incy must not be zero .
 * A single precision complex array of dimensions ( lda , n ) . If uplo = = ' U ' or ' u ' ,
 * then A must contains the upper triangular part of a hermitian matrix ,
 * and the strictly lower triangular parts is not referenced . If uplo = =
 * ' L ' or ' l ' , then A contains the lower triangular part of a 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 , and on exit they are set to zero .
 * lda leading dimension of A . It must be at least max ( 1 , n ) .
 * Output
 * A updated according to A = alpha * x * conjugate ( transpose ( y ) )
 * + conjugate ( alpha ) * y * conjugate ( transpose ( x ) ) + A
 * Reference : http : / / www . netlib . org / blas / cher2 . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCher2 ( char uplo , int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSgemm ( char transa , char transb , int m , int n , int k , float alpha ,
 * const float * A , int lda , const float * B , int ldb , float beta ,
 * float * C , int ldc )
 * computes the product of matrix A and matrix B , multiplies the result
 * by a scalar alpha , and adds the sum to the product of matrix C and
 * scalar beta . sgemm ( ) performs one of the matrix - matrix operations :
 * C = alpha * op ( A ) * op ( B ) + beta * C ,
 * where op ( X ) is one of
 * op ( X ) = X or op ( X ) = transpose ( X )
 * alpha and beta are single precision scalars , and A , B and C are
 * matrices consisting of single precision elements , with op ( A ) an m x k
 * matrix , op ( B ) a k x n matrix , and C an m x n matrix . Matrices A , B ,
 * and C are stored in column major format , and lda , ldb , and ldc are
 * the leading dimensions of the two - dimensional arrays containing A ,
 * B , and C .
 * Input
 * transa specifies op ( A ) . If transa = ' n ' or ' N ' , op ( A ) = A . If
 * transa = ' t ' , ' T ' , ' c ' , or ' C ' , op ( A ) = transpose ( A )
 * transb specifies op ( B ) . If transb = ' n ' or ' N ' , op ( B ) = B . If
 * transb = ' t ' , ' T ' , ' c ' , or ' C ' , op ( B ) = transpose ( B )
 * m number of rows of matrix op ( A ) and rows of matrix C
 * n number of columns of matrix op ( B ) and number of columns of C
 * k number of columns of matrix op ( A ) and number of rows of op ( B )
 * alpha single precision scalar multiplier applied to op ( A ) op ( B )
 * A single precision array of dimensions ( lda , k ) if transa =
 * ' n ' or ' N ' ) , and of dimensions ( lda , m ) otherwise . When transa =
 * ' N ' or ' n ' then lda must be at least max ( 1 , m ) , otherwise lda
 * must be at least max ( 1 , k ) .
 * lda leading dimension of two - dimensional array used to store matrix A
 * B single precision array of dimensions ( ldb , n ) if transb =
 * ' n ' or ' N ' ) , and of dimensions ( ldb , k ) otherwise . When transb =
 * ' N ' or ' n ' then ldb must be at least max ( 1 , k ) , otherwise ldb
 * must be at least max ( 1 , n ) .
 * ldb leading dimension of two - dimensional array used to store matrix B
 * beta single precision scalar multiplier applied to C . If 0 , C does
 * not have to be a valid input
 * C single precision array of dimensions ( ldc , n ) . ldc must be at
 * least max ( 1 , m ) .
 * ldc leading dimension of two - dimensional array used to store matrix C
 * Output
 * C updated based on C = alpha * op ( A ) * op ( B ) + beta * C
 * Reference : http : / / www . netlib . org / blas / sgemm . 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 any of m , n , or k are < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasSgemm ( char transa , char transb , int m , int n , int k , float alpha , Pointer A , int lda , Pointer B , int ldb , float beta , Pointer C , int ldc ) { } }

implementation: cublasSgemmNative ( transa , transb , m , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSsymm ( char side , char uplo , int m , int n , float alpha ,
 * const float * A , int lda , const float * B , int ldb ,
 * float beta , float * 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 scalars , A is a symmetric matrix
 * consisting of single precision elements and stored in either lower or upper
 * storage mode , and B and C are m x n matrices consisting of single precision
 * elements .
 * Input
 * side specifies whether the symmetric 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 symmetric matrix A 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 .
 * m specifies the number of rows of the matrix C , and the number of rows
 * of matrix B . It also specifies the dimensions of symmetric 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 symmetric
 * matrix A when side = = ' R ' or ' r ' . n must be at least zero .
 * alpha single precision scalar multiplier applied to A * B , or B * A
 * A single precision 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 symmetric matrix ,
 * such that when uplo = = ' U ' or ' u ' , the leading m x m part stores the
 * upper triangular part of the symmetric 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
 * symmetric 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 symmetric matrix , such that when uplo = = ' U ' or ' u ' ,
 * the leading n x n part stores the upper triangular part of the
 * symmetric 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 symmetric matrix and the
 * strictly upper triangular part is not referenced .
 * 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 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 scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input
 * C single precision 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 / ssymm . 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 cublasSsymm ( char side , char uplo , int m , int n , float alpha , Pointer A , int lda , Pointer B , int ldb , float beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSsyrk ( char uplo , char trans , int n , int k , float alpha ,
 * const float * A , int lda , float beta , float * 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 scalars . C is an n x n symmetric matrix
 * consisting of single precision elements and stored in either lower or
 * upper storage mode . A is a matrix consisting of single precision 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 scalar multiplier applied to A * transpose ( A ) or
 * transpose ( A ) * A .
 * A single precision 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 izs zero , C
 * does not have to be a valid input
 * C single precision 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 / ssyrk . 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 cublasSsyrk ( char uplo , char trans , int n , int k , float alpha , Pointer A , int lda , float beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSsyr2k ( char uplo , char trans , int n , int k , float alpha ,
 * const float * A , int lda , const float * B , int ldb ,
 * float beta , float * 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 scalars . C is an n x n symmetric matrix
 * consisting of single precision elements and stored in either lower or upper
 * storage mode . A and B are matrices consisting of single precision 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 scalar multiplier .
 * A single precision 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 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 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 / ssyr2k . 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 cublasSsyr2k ( char uplo , char trans , int n , int k , float alpha , Pointer A , int lda , Pointer B , int ldb , float beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasStrmm ( char side , char uplo , char transa , char diag , int m , int n ,
 * float alpha , const float * A , int lda , const float * 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 scalar , B is an m x n matrix composed
 * of single precision elements , and A is a unit or non - unit , upper or lower ,
 * triangular matrix composed of single precision elements . op ( A ) is one of
 * op ( A ) = A or op ( A ) = 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 ' , ' t ' , ' C ' , or ' c ' , then op ( A ) = 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 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 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 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 / strmm . 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 cublasStrmm ( char side , char uplo , char transa , char diag , int m , int n , float alpha , Pointer A , int lda , Pointer B , int ldb ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasStrsm ( char side , char uplo , char transa , char diag , int m , int n ,
 * float alpha , const float * A , int lda , float * 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 scalar , and X and B are m x n matrices
 * that are composed of single 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 single 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 single 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 single 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 / strsm . 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 cublasStrsm ( char side , char uplo , char transa , char diag , int m , int n , float alpha , Pointer A , int lda , Pointer B , int ldb ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void cublasCgemm ( char transa , char transb , int m , 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 matrix - matrix operations
 * C = alpha * op ( A ) * op ( B ) + beta * C ,
 * where op ( X ) is one of
 * op ( X ) = X or op ( X ) = transpose or op ( X ) = conjg ( transpose ( X ) )
 * alpha and beta are single - complex scalars , and A , B and C are matrices
 * consisting of single - complex elements , with op ( A ) an m x k matrix , op ( B )
 * a k x n matrix and C an m x n matrix .
 * Input
 * transa specifies op ( A ) . If transa = = ' N ' or ' n ' , op ( A ) = A . If transa = =
 * ' T ' or ' t ' , op ( A ) = transpose ( A ) . If transa = = ' C ' or ' c ' , op ( A ) =
 * conjg ( transpose ( A ) ) .
 * transb specifies op ( B ) . If transa = = ' N ' or ' n ' , op ( B ) = B . If transb = =
 * ' T ' or ' t ' , op ( B ) = transpose ( B ) . If transb = = ' C ' or ' c ' , op ( B ) =
 * conjg ( transpose ( B ) ) .
 * m number of rows of matrix op ( A ) and rows of matrix C . It must be at
 * least zero .
 * n number of columns of matrix op ( B ) and number of columns of C . It
 * must be at least zero .
 * k number of columns of matrix op ( A ) and number of rows of op ( B ) . It
 * must be at least zero .
 * alpha single - complex scalar multiplier applied to op ( A ) op ( B )
 * A single - complex array of dimensions ( lda , k ) if transa = = ' N ' or
 * ' n ' ) , and of dimensions ( lda , m ) otherwise .
 * lda leading dimension of A . When transa = = ' N ' or ' n ' , it must be at
 * least max ( 1 , m ) and at least max ( 1 , k ) otherwise .
 * B single - complex array of dimensions ( ldb , n ) if transb = = ' N ' or ' n ' ,
 * and of dimensions ( ldb , k ) otherwise
 * ldb leading dimension of B . When transb = = ' N ' or ' n ' , it must be at
 * least max ( 1 , k ) and at least max ( 1 , n ) otherwise .
 * beta single - complex scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input .
 * C single precision array of dimensions ( ldc , n )
 * ldc leading dimension of C . Must be at least max ( 1 , m ) .
 * Output
 * C updated according to C = alpha * op ( A ) * op ( B ) + beta * C
 * Reference : http : / / www . netlib . org / blas / cgemm . 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 any of m , n , or k are < 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCgemm ( char transa , char transb , int m , int n , int k , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuComplex beta , Pointer C , int ldc ) { } }

implementation: cublasCgemmNative ( transa , transb , m , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCsymm ( 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 symmetric 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 symmetric 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 symmetric matrix A 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 .
 * m specifies the number of rows of the matrix C , and the number of rows
 * of matrix B . It also specifies the dimensions of symmetric 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 symmetric
 * matrix A when side = = ' R ' or ' r ' . n must be at least zero .
 * alpha single precision scalar multiplier applied to A * B , or B * A
 * A single precision 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 symmetric matrix ,
 * such that when uplo = = ' U ' or ' u ' , the leading m x m part stores the
 * upper triangular part of the symmetric 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
 * symmetric 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 symmetric matrix , such that when uplo = = ' U ' or ' u ' ,
 * the leading n x n part stores the upper triangular part of the
 * symmetric 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 symmetric matrix and the
 * strictly upper triangular part is not referenced .
 * 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 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 scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input
 * C single precision 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 / csymm . 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 cublasCsymm ( 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: cublasCsymmNative ( side , uplo , m , n , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ;