signature:
public class JCublas { /** * < pre >
 * void
 * cublasDtrmm ( char side , char uplo , char transa , char diag , int m , int n ,
 * double alpha , const double * A , int lda , const double * 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 double - precision scalar , B is an m x n matrix composed
 * of double precision elements , and A is a unit or non - unit , upper or lower ,
 * triangular matrix composed of double 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 double 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 double 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 double 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 / dtrmm . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if m or n < 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDtrmm ( char side , char uplo , char transa , char diag , int m , int n , double alpha , Pointer A , int lda , Pointer B , int ldb ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDsymm ( char side , char uplo , int m , int n , double alpha ,
 * const double * A , int lda , const double * B , int ldb ,
 * double beta , double * 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 double precision scalars , A is a symmetric matrix
 * consisting of double precision elements and stored in either lower or upper
 * storage mode , and B and C are m x n matrices consisting of double 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 double precision scalar multiplier applied to A * B , or B * A
 * A double 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 double 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 double precision scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input
 * C double 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 / dsymm . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDsymm ( char side , char uplo , int m , int n , double alpha , Pointer A , int lda , Pointer B , int ldb , double beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZsymm ( char side , char uplo , int m , int n , cuDoubleComplex alpha ,
 * const cuDoubleComplex * A , int lda , const cuDoubleComplex * B , int ldb ,
 * cuDoubleComplex beta , cuDoubleComplex * 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 double precision complex scalars , A is a symmetric matrix
 * consisting of double precision complex elements and stored in either lower or upper
 * storage mode , and B and C are m x n matrices consisting of double 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 double precision scalar multiplier applied to A * B , or B * A
 * A double 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 double 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 double precision scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input
 * C double 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 / zsymm . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZsymm ( char side , char uplo , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuDoubleComplex beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDsyrk ( char uplo , char trans , int n , int k , double alpha ,
 * const double * A , int lda , double beta , double * 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 double precision scalars . C is an n x n symmetric matrix
 * consisting of double precision elements and stored in either lower or
 * upper storage mode . A is a matrix consisting of double 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 double precision scalar multiplier applied to A * transpose ( A ) or
 * transpose ( A ) * A .
 * A double 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 double precision scalar multiplier applied to C . If beta izs zero , C
 * does not have to be a valid input
 * C double 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 / dsyrk . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDsyrk ( char uplo , char trans , int n , int k , double alpha , Pointer A , int lda , double beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZsyrk ( char uplo , char trans , int n , int k , cuDoubleComplex alpha ,
 * const cuDoubleComplex * A , int lda , cuDoubleComplex beta , cuDoubleComplex * 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 double precision complex scalars . C is an n x n symmetric matrix
 * consisting of double precision complex elements and stored in either lower or
 * upper storage mode . A is a matrix consisting of double precision complex elements
 * with dimension of n x k in the first case , and k x n in the second case .
 * Input
 * uplo specifies whether the symmetric matrix C is stored in upper or lower
 * storage mode as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the symmetric matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the symmetric matrix is to be referenced ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * trans specifies the operation to be performed . If trans = = ' N ' or ' n ' , C =
 * alpha * transpose ( A ) + beta * C . If trans = = ' T ' , ' t ' , ' C ' , or ' c ' ,
 * C = transpose ( A ) * A + beta * C .
 * n specifies the number of rows and the number columns of matrix C . If
 * trans = = ' N ' or ' n ' , n specifies the number of rows of matrix A . If
 * trans = = ' T ' , ' t ' , ' C ' , or ' c ' , n specifies the columns of matrix A .
 * n must be at least zero .
 * k If trans = = ' N ' or ' n ' , k specifies the number of rows of matrix A .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , k specifies the number of rows of
 * matrix A . k must be at least zero .
 * alpha double precision complex scalar multiplier applied to A * transpose ( A ) or
 * transpose ( A ) * A .
 * A double precision complex array of dimensions ( lda , ka ) , where ka is k when
 * trans = = ' N ' or ' n ' , and is n otherwise . When trans = = ' N ' or ' n ' ,
 * the leading n x k part of array A must contain the matrix A ,
 * otherwise the leading k x n part of the array must contains the
 * matrix A .
 * lda leading dimension of A . When trans = = ' N ' or ' n ' then lda must be at
 * least max ( 1 , n ) . Otherwise lda must be at least max ( 1 , k ) .
 * beta double precision complex scalar multiplier applied to C . If beta izs zero , C
 * does not have to be a valid input
 * C double precision complex array of dimensions ( ldc , n ) . If uplo = ' U ' or ' u ' ,
 * the leading n x n triangular part of the array C must contain the
 * upper triangular part of the symmetric matrix C and the strictly
 * lower triangular part of C is not referenced . On exit , the upper
 * triangular part of C is overwritten by the upper triangular part of
 * the updated matrix . If uplo = ' L ' or ' l ' , the leading n x n
 * triangular part of the array C must contain the lower triangular part
 * of the symmetric matrix C and the strictly upper triangular part of C
 * is not referenced . On exit , the lower triangular part of C is
 * overwritten by the lower triangular part of the updated matrix .
 * ldc leading dimension of C . It must be at least max ( 1 , n ) .
 * Output
 * C updated according to C = alpha * A * transpose ( A ) + beta * C , or C =
 * alpha * transpose ( A ) * A + beta * C
 * Reference : http : / / www . netlib . org / blas / zsyrk . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZsyrk ( char uplo , char trans , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , cuDoubleComplex beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZsyr2k ( char uplo , char trans , int n , int k , cuDoubleComplex alpha ,
 * const cuDoubleComplex * A , int lda , const cuDoubleComplex * B , int ldb ,
 * cuDoubleComplex beta , cuDoubleComplex * 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 double precision complex scalars . C is an n x n symmetric matrix
 * consisting of double precision complex elements and stored in either lower or upper
 * storage mode . A and B are matrices consisting of double precision complex elements
 * with dimension of n x k in the first case , and k x n in the second case .
 * Input
 * uplo specifies whether the symmetric matrix C is stored in upper or lower
 * storage mode , as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the symmetric matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the symmetric matrix is to be references ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * trans specifies the operation to be performed . If trans = = ' N ' or ' n ' ,
 * C = alpha * A * transpose ( B ) + alpha * B * transpose ( A ) + beta * C ,
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , C = alpha * transpose ( A ) * B +
 * alpha * transpose ( B ) * A + beta * C .
 * n specifies the number of rows and the number columns of matrix C . If
 * trans = = ' N ' or ' n ' , n specifies the number of rows of matrix A . If
 * trans = = ' T ' , ' t ' , ' C ' , or ' c ' , n specifies the columns of matrix A .
 * n must be at least zero .
 * k If trans = = ' N ' or ' n ' , k specifies the number of rows of matrix A .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , k specifies the number of rows of
 * matrix A . k must be at least zero .
 * alpha double precision scalar multiplier .
 * A double 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 double 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 double precision scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input .
 * C double 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 / zsyr2k . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZsyr2k ( char uplo , char trans , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuDoubleComplex beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZher2k ( char uplo , char trans , int n , int k , cuDoubleComplex alpha ,
 * const cuDoubleComplex * A , int lda , const cuDoubleComplex * B , int ldb ,
 * double beta , cuDoubleComplex * C , int ldc )
 * performs one of the hermitian rank 2k operations
 * C = alpha * A * conjugate ( transpose ( B ) )
 * + conjugate ( alpha ) * B * conjugate ( transpose ( A ) )
 * + beta * C ,
 * or
 * C = alpha * conjugate ( transpose ( A ) ) * B
 * + conjugate ( alpha ) * conjugate ( transpose ( B ) ) * A
 * + beta * C .
 * Alpha is double precision complex scalar whereas Beta is a double precision real scalar .
 * C is an n x n hermitian matrix consisting of double precision complex elements and
 * stored in either lower or upper storage mode . A and B are matrices consisting of
 * double precision complex elements with dimension of n x k in the first case ,
 * and k x n in the second case .
 * Input
 * uplo specifies whether the hermitian matrix C is stored in upper or lower
 * storage mode , as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the hermitian matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the hermitian matrix is to be references ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * trans specifies the operation to be performed . If trans = = ' N ' or ' n ' ,
 * C = alpha * A * conjugate ( transpose ( B ) )
 * + conjugate ( alpha ) * B * conjugate ( transpose ( A ) )
 * + beta * C .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' ,
 * C = alpha * conjugate ( transpose ( A ) ) * B
 * + conjugate ( alpha ) * conjugate ( transpose ( B ) ) * A
 * + beta * C .
 * n specifies the number of rows and the number columns of matrix C . If
 * trans = = ' N ' or ' n ' , n specifies the number of rows of matrix A . If
 * trans = = ' T ' , ' t ' , ' C ' , or ' c ' , n specifies the columns of matrix A .
 * n must be at least zero .
 * k If trans = = ' N ' or ' n ' , k specifies the number of rows of matrix A .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , k specifies the number of rows of
 * matrix A . k must be at least zero .
 * alpha double precision scalar multiplier .
 * A double 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 double 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 double precision scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input .
 * C double 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 hermitian matrix C and the strictly
 * lower triangular part of C is not referenced . On exit , the upper
 * triangular part of C is overwritten by the upper triangular part of
 * the updated matrix . If uplo = = ' L ' or ' l ' , the leading n x n
 * triangular part of the array C must contain the lower triangular part
 * of the hermitian matrix C and the strictly upper triangular part of C
 * is not referenced . On exit , the lower triangular part of C is
 * overwritten by the lower triangular part of the updated matrix .
 * The imaginary parts of the diagonal elements need
 * not be set , they are assumed to be zero , and on exit they
 * are set to zero .
 * ldc leading dimension of C . Must be at least max ( 1 , n ) .
 * Output
 * C updated according to alpha * A * conjugate ( transpose ( B ) ) +
 * + conjugate ( alpha ) * B * conjugate ( transpose ( A ) ) + beta * C or
 * alpha * conjugate ( transpose ( A ) ) * B + conjugate ( alpha ) * conjugate ( transpose ( B ) ) * A
 * + beta * C .
 * Reference : http : / / www . netlib . org / blas / zher2k . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZher2k ( char uplo , char trans , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , double beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZher ( char uplo , int n , double alpha , const cuDoubleComplex * x , int incx ,
 * cuDoubleComplex * A , int lda )
 * performs the hermitian rank 1 operation
 * A = alpha * x * conjugate ( transpose ( x ) + A ,
 * where alpha is a double precision real scalar , x is an n element double
 * precision complex vector and A is an n x n hermitian matrix consisting of
 * double 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 double precision real scalar multiplier applied to
 * x * conjugate ( transpose ( x ) )
 * x double 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 double 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 / zher . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , or incx = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZher ( char uplo , int n , double alpha , Pointer x , int incx , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZhpr ( char uplo , int n , double alpha , const cuDoubleComplex * x , int incx ,
 * cuDoubleComplex * AP )
 * performs the hermitian rank 1 operation
 * A = alpha * x * conjugate ( transpose ( x ) ) + A ,
 * where alpha is a double precision real scalar and x is an n element double
 * precision complex vector . A is a 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 real scalar multiplier applied to x * conjugate ( transpose ( x ) ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * AP double precision 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 / zhpr . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if n < 0 , or incx = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZhpr ( char uplo , int n , double alpha , Pointer x , int incx , Pointer AP ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZhpr2 ( char uplo , int n , cuDoubleComplex alpha , const cuDoubleComplex * x , int incx ,
 * const cuDoubleComplex * y , int incy , cuDoubleComplex * AP )
 * performs the hermitian rank 2 operation
 * A = alpha * x * conjugate ( transpose ( y ) ) + conjugate ( alpha ) * y * conjugate ( transpose ( x ) ) + A ,
 * where alpha is a double precision complex scalar , and x and y are n element double
 * precision complex vectors . A is a 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 A . If uplo = = ' U ' or ' u ' , then only the
 * upper triangular part of A may be referenced and the lower triangular
 * part of A is inferred . If uplo = = ' L ' or ' l ' , then only the lower
 * triangular part of A may be referenced and the upper triangular part
 * of A is inferred .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha double precision complex scalar multiplier applied to x * conjugate ( transpose ( y ) ) +
 * y * conjugate ( transpose ( x ) ) .
 * 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 .
 * y double 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 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 , 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 / zhpr2 . 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 cublasZhpr2 ( char uplo , int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer AP ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void cublasZher2 ( char uplo , int n , cuDoubleComplex alpha , const cuDoubleComplex * x , int incx ,
 * const cuDoubleComplex * y , int incy , cuDoubleComplex * 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 double precision complex scalar , x and y are n element double
 * precision complex vector and A is an n by n hermitian matrix consisting of double
 * 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 double precision complex scalar multiplier applied to x * conjugate ( transpose ( y ) ) +
 * y * conjugate ( transpose ( x ) ) .
 * x double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * incx storage spacing between elements of x . incx must not be zero .
 * y double precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * incy storage spacing between elements of y . incy must not be zero .
 * A double precision 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 / zher2 . 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 cublasZher2 ( char uplo , int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasDsyr2k ( char uplo , char trans , int n , int k , double alpha ,
 * const double * A , int lda , const double * B , int ldb ,
 * double beta , double * 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 double precision scalars . C is an n x n symmetric matrix
 * consisting of double precision elements and stored in either lower or upper
 * storage mode . A and B are matrices consisting of double 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 double precision scalar multiplier .
 * A double 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 double 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 double precision scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input .
 * C double 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 / dsyr2k . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasDsyr2k ( char uplo , char trans , int n , int k , double alpha , Pointer A , int lda , Pointer B , int ldb , double beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void cublasZgemm ( char transa , char transb , int m , int n , int k ,
 * cuDoubleComplex alpha , const cuDoubleComplex * A , int lda ,
 * const cuDoubleComplex * B , int ldb , cuDoubleComplex beta ,
 * cuDoubleComplex * C , int ldc )
 * zgemm performs one of the matrix - matrix operations
 * C = alpha * op ( A ) * op ( B ) + beta * C ,
 * where op ( X ) is one of
 * op ( X ) = X or op ( X ) = transpose or op ( X ) = conjg ( transpose ( X ) )
 * alpha and beta are double - complex scalars , and A , B and C are matrices
 * consisting of double - 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 double - complex scalar multiplier applied to op ( A ) op ( B )
 * A double - 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 double - 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 double - complex scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input .
 * C double 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 / zgemm . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZgemm ( char transa , char transb , int m , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuDoubleComplex beta , Pointer C , int ldc ) { } }

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


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

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


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

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


signature:
public class JCublas { /** * < pre >
 * cublasZgerc ( int m , int n , cuDoubleComplex alpha , const cuDoubleComplex * x , int incx ,
 * const cuDoubleComplex * y , int incy , cuDoubleComplex * A , int lda )
 * performs the symmetric rank 1 operation
 * A = alpha * x * conjugate ( transpose ( y ) ) + A ,
 * where alpha is a double precision complex scalar , x is an m element double
 * precision complex vector , y is an n element double precision complex vector , and A
 * is an m by n matrix consisting of double 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 double precision complex scalar multiplier applied to x * conjugate ( transpose ( y ) )
 * x double precision array of length at least ( 1 + ( m - 1 ) * abs ( incx ) )
 * incx specifies the storage spacing between elements of x . incx must not
 * be zero .
 * y double precision 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 double 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 / zgerc . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZgerc ( int m , int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZherk ( char uplo , char trans , int n , int k , double alpha ,
 * const cuDoubleComplex * A , int lda , double beta , cuDoubleComplex * C , int ldc )
 * performs one of the hermitian rank k operations
 * C = alpha * A * conjugate ( transpose ( A ) ) + beta * C , or
 * C = alpha * conjugate ( transpose ( A ) ) * A + beta * C .
 * Alpha and beta are double precision scalars . C is an n x n hermitian matrix
 * consisting of double precision complex elements and stored in either lower or
 * upper storage mode . A is a matrix consisting of double precision complex elements
 * with dimension of n x k in the first case , and k x n in the second case .
 * Input
 * uplo specifies whether the hermitian matrix C is stored in upper or lower
 * storage mode as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the hermitian matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the hermitian matrix is to be referenced ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * trans specifies the operation to be performed . If trans = = ' N ' or ' n ' , C =
 * alpha * A * conjugate ( transpose ( A ) ) + beta * C . If trans = = ' T ' , ' t ' , ' C ' , or ' c ' ,
 * C = alpha * conjugate ( transpose ( A ) ) * A + beta * C .
 * n specifies the number of rows and the number columns of matrix C . If
 * trans = = ' N ' or ' n ' , n specifies the number of rows of matrix A . If
 * trans = = ' T ' , ' t ' , ' C ' , or ' c ' , n specifies the columns of matrix A .
 * n must be at least zero .
 * k If trans = = ' N ' or ' n ' , k specifies the number of columns of matrix A .
 * If trans = = ' T ' , ' t ' , ' C ' , or ' c ' , k specifies the number of rows of
 * matrix A . k must be at least zero .
 * alpha double precision scalar multiplier applied to A * conjugate ( transpose ( A ) ) or
 * conjugate ( transpose ( A ) ) * A .
 * A double precision complex array of dimensions ( lda , ka ) , where ka is k when
 * trans = = ' N ' or ' n ' , and is n otherwise . When trans = = ' N ' or ' n ' ,
 * the leading n x k part of array A must contain the matrix A ,
 * otherwise the leading k x n part of the array must contains the
 * matrix A .
 * lda leading dimension of A . When trans = = ' N ' or ' n ' then lda must be at
 * least max ( 1 , n ) . Otherwise lda must be at least max ( 1 , k ) .
 * beta double precision scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input
 * C double precision complex array of dimensions ( ldc , n ) . If uplo = ' U ' or ' u ' ,
 * the leading n x n triangular part of the array C must contain the
 * upper triangular part of the hermitian matrix C and the strictly
 * lower triangular part of C is not referenced . On exit , the upper
 * triangular part of C is overwritten by the upper triangular part of
 * the updated matrix . If uplo = ' L ' or ' l ' , the leading n x n
 * triangular part of the array C must contain the lower triangular part
 * of the hermitian matrix C and the strictly upper triangular part of C
 * is not referenced . On exit , the lower triangular part of C is
 * overwritten by the lower triangular part of the updated matrix .
 * The imaginary parts of the diagonal elements need
 * not be set , they are assumed to be zero , and on exit they
 * are set to zero .
 * ldc leading dimension of C . It must be at least max ( 1 , n ) .
 * Output
 * C updated according to C = alpha * A * conjugate ( transpose ( A ) ) + beta * C , or C =
 * alpha * conjugate ( transpose ( A ) ) * A + beta * C
 * Reference : http : / / www . netlib . org / blas / zherk . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZherk ( char uplo , char trans , int n , int k , double alpha , Pointer A , int lda , double beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZhemm ( char side , char uplo , int m , int n , cuDoubleComplex alpha ,
 * const cuDoubleComplex * A , int lda , const cuDoubleComplex * B , int ldb ,
 * cuDoubleComplex beta , cuDoubleComplex * 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 double precision complex scalars , A is a hermitian matrix
 * consisting of double precision complex elements and stored in either lower or upper
 * storage mode , and B and C are m x n matrices consisting of double precision
 * complex elements .
 * Input
 * side specifies whether the hermitian matrix A appears on the left side
 * hand side or right hand side of matrix B , as follows . If side = = ' L '
 * or ' l ' , then C = alpha * A * B + beta * C . If side = ' R ' or ' r ' ,
 * then C = alpha * B * A + beta * C .
 * uplo specifies whether the hermitian matrix A is stored in upper or lower
 * storage mode , as follows . If uplo = = ' U ' or ' u ' , only the upper
 * triangular part of the hermitian matrix is to be referenced , and the
 * elements of the strictly lower triangular part are to be infered from
 * those in the upper triangular part . If uplo = = ' L ' or ' l ' , only the
 * lower triangular part of the hermitian matrix is to be referenced ,
 * and the elements of the strictly upper triangular part are to be
 * infered from those in the lower triangular part .
 * m specifies the number of rows of the matrix C , and the number of rows
 * of matrix B . It also specifies the dimensions of hermitian matrix A
 * when side = = ' L ' or ' l ' . m must be at least zero .
 * n specifies the number of columns of the matrix C , and the number of
 * columns of matrix B . It also specifies the dimensions of hermitian
 * matrix A when side = = ' R ' or ' r ' . n must be at least zero .
 * alpha double precision scalar multiplier applied to A * B , or B * A
 * A double precision complex array of dimensions ( lda , ka ) , where ka is m when
 * side = = ' L ' or ' l ' and is n otherwise . If side = = ' L ' or ' l ' the
 * leading m x m part of array A must contain the hermitian matrix ,
 * such that when uplo = = ' U ' or ' u ' , the leading m x m part stores the
 * upper triangular part of the hermitian matrix , and the strictly lower
 * triangular part of A is not referenced , and when uplo = = ' U ' or ' u ' ,
 * the leading m x m part stores the lower triangular part of the
 * hermitian matrix and the strictly upper triangular part is not
 * referenced . If side = = ' R ' or ' r ' the leading n x n part of array A
 * must contain the hermitian matrix , such that when uplo = = ' U ' or ' u ' ,
 * the leading n x n part stores the upper triangular part of the
 * hermitian matrix and the strictly lower triangular part of A is not
 * referenced , and when uplo = = ' U ' or ' u ' , the leading n x n part
 * stores the lower triangular part of the hermitian matrix and the
 * strictly upper triangular part is not referenced . The imaginary parts
 * of the diagonal elements need not be set , they are assumed to be zero .
 * lda leading dimension of A . When side = = ' L ' or ' l ' , it must be at least
 * max ( 1 , m ) and at least max ( 1 , n ) otherwise .
 * B double precision complex array of dimensions ( ldb , n ) . On entry , the leading
 * m x n part of the array contains the matrix B .
 * ldb leading dimension of B . It must be at least max ( 1 , m ) .
 * beta double precision complex scalar multiplier applied to C . If beta is zero , C
 * does not have to be a valid input
 * C double precision complex array of dimensions ( ldc , n )
 * ldc leading dimension of C . Must be at least max ( 1 , m )
 * Output
 * C updated according to C = alpha * A * B + beta * C , or C = alpha *
 * B * A + beta * C
 * Reference : http : / / www . netlib . org / blas / zhemm . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZhemm ( char side , char uplo , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuDoubleComplex beta , Pointer C , int ldc ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZtrsv ( char uplo , char trans , char diag , int n , const cuDoubleComplex * A ,
 * int lda , cuDoubleComplex * 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 double 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 double 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 double 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 / ztrsv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if incx = = 0 or if n < 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZtrsv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZhbmv ( char uplo , int n , int k , 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 . x and y are double precision
 * complex vectors with n elements . A is an n by n hermitian band matrix consisting
 * of double 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 double precision complex scalar multiplier applied to A * x .
 * A double 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 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 . If beta is
 * zero , y is not read .
 * 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 alpha * A * x + beta * y
 * Reference : http : / / www . netlib . org / blas / zhbmv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * CUBLAS _ STATUS _ NOT _ INITIALIZED if CUBLAS library has not been initialized
 * CUBLAS _ STATUS _ INVALID _ VALUE if k or n < 0 , or if incx or incy = = 0
 * CUBLAS _ STATUS _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZhbmv ( char uplo , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { } }

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


signature:
public class Ending { /** * tiek pieņemts , ka izsaucošā funkcija nodrošina , ka vārds tiešām beidzas ar šo galotni . */
public String stem ( String word ) throws WrongEndingException { } }

implementation: if ( ! word . endsWith ( ending ) ) throw new WrongEndingException ( "Gļuks - vārds (" + word + ") nebeidzas ar norādīto galotni (" + ending + ")" ) ; return word . substring ( 0 , word . length ( ) - ending . length ( ) ) ;


signature:
public class Ending { /** * Returned Lexemes shouldn ' t be modified to avoid changing recognition of other words !
 * Not cloned due to performance and memory usage concerns . */
public ArrayList < Lexeme > getEndingLexemes ( String celms ) { } }

implementation: return paradigm . getLexemesByStem ( ) . get ( stemID - 1 ) . get ( celms ) ;


signature:
public class Statistics { /** * Add one occurrence of one lexeme .
 * @ param lexemeIdlexeme identifier . */
public void addLexeme ( int lexemeId ) { } }

implementation: int count = 1 ; if ( lexemeFrequency . get ( lexemeId ) != null ) count = lexemeFrequency . get ( lexemeId ) + 1 ; lexemeFrequency . put ( lexemeId , count ) ;


signature:
public class Statistics { /** * Add one occurrence of one ending .
 * @ param endingIdending identifier . */
public void addEnding ( int endingId ) { } }

implementation: int count = 1 ; if ( endingFrequency . get ( endingId ) != null ) count = endingFrequency . get ( endingId ) + 1 ; endingFrequency . put ( endingId , count ) ;


signature:
public class Statistics { /** * Convert frequency data in XML format .
 * @ param streamoutput stream . */
public void toXML ( Writer stream ) throws IOException { } }

implementation: stream . write ( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" ) ; stream . write ( "<Statistika>\n" ) ; stream . write ( "<Galotņu_biežums\n" ) ; for ( Entry < Integer , Integer > tuple : endingFrequency . entrySet ( ) ) { stream . write ( " Galotne_" + tuple . getKey ( ) . toString ( ) + "=\"" + tuple . getValue ( ) . toString ( ) + "\"" ) ; } stream . write ( "/>\n" ) ; stream . write ( "<Leksēmu_biežums\n" ) ; for ( Entry < Integer , Integer > tuple : lexemeFrequency . entrySet ( ) ) { stream . write ( " Leksēma_" + tuple . getKey ( ) . toString ( ) + "=\"" + tuple . getValue ( ) . toString ( ) + "\"" ) ; } stream . write ( "/>\n" ) ; stream . write ( "</Statistika>\n" ) ; stream . flush ( ) ;


signature:
public class Statistics { /** * Cumulative frequency estimate for given wordform .
 * @ param wordformwordform to describe .
 * @ returnlexeme frequency + ending frequency . */
public double getEstimate ( AttributeValues wordform ) { } }

implementation: double estimate = 0.1 ; String endingIdStr = wordform . getValue ( AttributeNames . i_EndingID ) ; int endingId = ( endingIdStr == null ) ? - 1 : Integer . parseInt ( endingIdStr ) ; if ( endingFrequency . get ( endingId ) != null ) estimate += endingFrequency . get ( endingId ) ; String lexemeIdStr = wordform . getValue ( AttributeNames . i_LexemeID ) ; int lexemeId = ( lexemeIdStr == null ) ? - 1 : Integer . parseInt ( lexemeIdStr ) ; if ( lexemeFrequency . get ( lexemeId ) != null ) estimate += lexemeFrequency . get ( lexemeId ) * lexemeWeight ; return estimate ;


signature:
public class Splitting { /** * Determine if given char is a whitespace char ( space , tab , newline ) . */
public static boolean isSpace ( char c ) { } }

implementation: return Character . isWhitespace ( c ) || Character . isISOControl ( c ) || c == '\u00A0' || c == '\uFEFF' || c == '\u2029' || c == '\u200B' ;


signature:
public class Splitting { /** * Tokenizes the string ( sentence ? ) and runs morphoanalysis on each word . */
public static LinkedList < Word > tokenize ( Analyzer morphoAnalyzer , String chunk ) { } }

implementation:
LinkedList < Word > tokens = new LinkedList < Word > ( ) ; if ( chunk == null ) return tokens ; Trie automats = morphoAnalyzer . automats ; // bug fix - pievienota beigās whitespace
String str = chunk + " " ; // workaround dubultapostrofu izvirtībai
str = str . replaceAll ( "''" , "\u200B''" ) ; // FIXME mēs te mazliet izčakarējam accumulatedWhitespace on Offsetus
// workaround teikuma beigu saīsinājumiem utt
str = str . replaceAll ( "([\\p{L}\\d])\\.(\\p{Z})*$" , "$1\u200B.$2" ) ; // FIXME mēs te mazliet izčakarējam accumulatedWhitespace un offsetus
// str = str . replaceAll ( " ( [ \ \ d ] ) \ \ . ( \ \ p { Z } ) * $ " , " $ 1 \ u200B . $ 2 " ) ; / / FIXME mēs te mazliet izčakarējam accumulatedWhitespace un offsetus
// te tiek ciklā doti visi tekstā esošie vārdi uz morfoanalīzi .
int progress = 0 ; boolean inApostrophes = false ; Status statuss = Status . IN_SPACE ; StringBuilder accumulatedWhitespace = new StringBuilder ( ) ; int lastGoodEnd = 0 ; boolean canEndInNextStep = false ; for ( int i = 0 ; i < str . length ( ) ; i ++ ) { switch ( statuss ) { case IN_SPACE : if ( ! Splitting . isSpace ( str . charAt ( i ) ) ) { if ( str . charAt ( i ) == '\'' ) inApostrophes = true ; automats . reset ( ) ; // atjauno automāta stāvokli
automats . findNextBranch ( str . charAt ( i ) ) ; // atrod pirmo derīgo zaru
if ( automats . status ( ) > 0 ) { // pārbauda vai automātā atrada meklēto simbolu
// ja atrada
statuss = Status . IN_WORD ; progress = i ; // pārbauda vai ar to var arī virkne beigties
canEndInNextStep = ( automats . status ( ) == 2 ) ; } else { // ja neatrada , pievieno vienu simbolu un mēģina vēl
tokens . add ( formToken ( morphoAnalyzer , str , i , i + 1 , accumulatedWhitespace ) ) ; } } else { accumulatedWhitespace . append ( str . charAt ( i ) ) ; } break ; case IN_WORD : // pārbauda vai ir atrastas potenciālās beigas
if ( canEndInNextStep == true && ( Splitting . isSeparator ( str . charAt ( i ) ) || ! Character . isLetter ( ( i > 0 ? str . charAt ( i - 1 ) : 0 ) ) ) ) { lastGoodEnd = i ; if ( str . charAt ( i ) == '\'' && inApostrophes ) { tokens . add ( formToken ( morphoAnalyzer , str , progress , i , accumulatedWhitespace ) ) ; accumulatedWhitespace = new StringBuilder ( ) ; tokens . add ( formToken ( morphoAnalyzer , str , i , i + 1 , accumulatedWhitespace ) ) ; inApostrophes = false ; statuss = Status . IN_SPACE ; break ; } } canEndInNextStep = false ; // mēģina atrast nākamo simbolu automātā
if ( automats . findNext ( str . charAt ( i ) ) > 0 ) { // ja atrada
// pārbauda vai ar to var arī virkne beigties
if ( automats . status ( ) == 2 ) canEndInNextStep = true ; } else { // ja neatrada , pārbauda vai automāta darbības laikā tika atrasta potenciālā beigu pozīcija
if ( lastGoodEnd > progress ) { tokens . add ( formToken ( morphoAnalyzer , str , progress , lastGoodEnd , accumulatedWhitespace ) ) ; i = lastGoodEnd - 1 ; statuss = Status . IN_SPACE ; accumulatedWhitespace = new StringBuilder ( ) ; } else { i = progress ; // mēgina atrast nākamo derīgo zaru
automats . nextBranch ( ) ; automats . findNextBranch ( str . charAt ( i ) ) ; if ( automats . status ( ) > 0 ) { // pārbauda vai atrada meklēto simbolu
// pārbauda vai ar to var arī virkne beigties
if ( automats . status ( ) == 2 ) canEndInNextStep = true ; } else { // ja neatrada , pievieno simbolu rezultātam un pēc tam dosies meklēt jauno sākumu
// vispār šis ir fishy . FIXME
tokens . add ( formToken ( morphoAnalyzer , str , i , i + 1 , accumulatedWhitespace ) ) ; statuss = Status . IN_SPACE ; accumulatedWhitespace = new StringBuilder ( ) ; } } } break ; } } // for i . .
if ( statuss == Status . IN_WORD ) { tokens . add ( formToken ( morphoAnalyzer , str , progress , str . length ( ) , accumulatedWhitespace ) ) ; } return tokens ;


signature:
public class Splitting { /** * Tokenizes some text ( usually a sentence )
 * @ param morphoAnalyzer
 * @ param chunk
 * @ param bruteSplit
 * @ return */
public static LinkedList < Word > tokenize ( Analyzer morphoAnalyzer , String chunk , boolean bruteSplit ) { } }

implementation: if ( bruteSplit ) { LinkedList < Word > tokens = new LinkedList < Word > ( ) ; if ( chunk == null ) return tokens ; String [ ] parts_of_string = chunk . trim ( ) . split ( " " ) ; for ( String part : parts_of_string ) { if ( part . length ( ) > 0 ) tokens . add ( ( morphoAnalyzer == null ) ? new Word ( part ) : morphoAnalyzer . analyze ( part ) ) ; } return tokens ; } else { return tokenize ( morphoAnalyzer , chunk ) ; }


signature:
public class Splitting { /** * Tokenizes a paragraph , and splits it into sentences .
 * @ param morphoAnalyzer
 * @ param paragraph
 * @ return */
public static LinkedList < LinkedList < Word > > tokenizeSentences ( Analyzer morphoAnalyzer , String paragraph , int lengthCap ) { } }

implementation:
LinkedList < LinkedList < Word > > result = new LinkedList < LinkedList < Word > > ( ) ; List < Word > tokens = Splitting . tokenize ( morphoAnalyzer , paragraph ) ; LinkedList < Word > sentence = new LinkedList < Word > ( ) ; for ( Word word : tokens ) { // Teikumu beigas iekšā tiešajā runā - pievelkam pēdiņu klāt
if ( sentence . size ( ) == 0 ) { if ( ( word . isRecognized ( ) && word . getBestWordform ( ) . getTag ( ) . equalsIgnoreCase ( "zq" ) ) || word . getToken ( ) . equals ( ")" ) ) { // Pārbaudam vai iepriekšējā teikuma beigās ir punkts
if ( ! result . isEmpty ( ) && ! result . getLast ( ) . isEmpty ( ) ) { String prevtoken = result . getLast ( ) . getLast ( ) . getToken ( ) ; if ( prevtoken . equals ( "." ) || prevtoken . equals ( "!" ) || prevtoken . equals ( "?" ) || prevtoken . equals ( "\"" ) ) { result . getLast ( ) . add ( word ) ; continue ; } } } } sentence . add ( word ) ; if ( Splitting . isChunkCloser ( word ) || // does this token look like end of sentence
( sentence . size ( ) >= lengthCap - 5 && ( word . hasAttribute ( AttributeNames . i_PartOfSpeech , AttributeNames . v_Punctuation ) || word . getToken ( ) . startsWith ( "<" ) ) ) || sentence . size ( ) > lengthCap ) { // hard limit
result . add ( sentence ) ; sentence = new LinkedList < Word > ( ) ; } } if ( ! sentence . isEmpty ( ) ) result . add ( sentence ) ; return result ;


signature:
public class Wordform { /** * / * public String getDemo ( ) {
 * return this . getValue ( " LocījumuDemo " ) ;
 * TODO : apskatīt kur lieto un vai vajag */
public void shortDescription ( PrintWriter stream ) { } }

implementation: stream . printf ( "%s :\t%s : %s  #%d\n" , token , getTag ( ) , getValue ( AttributeNames . i_Lemma ) , lexeme . getID ( ) ) ; // FIXME - nečeko , vai leksēma nav null


signature:
public class Wordform { /** * For debugging purposes only . */
public void longDescription ( PrintStream out ) { } }

implementation: out . println ( this . token + ":" ) ; for ( String s : this . attributes . keySet ( ) ) { out . println ( s + "\t" + attributes . get ( s ) ) ; }


signature:
public class MarkupConverter { /** * Check if attribute - value structure has attribute matching given
 * attributeValue and if so then set corresponding position in the tag . */
private static void verifyAndSetKamolsAttribute ( AttributeValues avs , StringBuilder tag , int index , char tagValue , String attribute , String attributeValue ) { } }

implementation: if ( avs . isMatchingStrong ( attribute , attributeValue ) ) tag . setCharAt ( index , tagValue ) ;


signature:
public class MarkupConverter { /** * Convert internal attribute - value structure to SemTi - Kamols tag . */
public static String toKamolsMarkup ( AttributeValues avs ) { } }

implementation:
StringBuilder res = toKamolsMarkup ( avs , defaulti ) ; if ( res . length ( ) < 1 ) return res . toString ( ) ; // if ( res . charAt ( 0 ) = = ' v ' & & res . charAt ( 1 ) = = ' _ ' ) res . setCharAt ( 1 , ' m ' ) ; PP 2012.12.07 - nezinu kāpēc tas te ir , bet tas čakarē tagošanu ( jo tagsvm . . . . neatbilst nevienam varēt vai būt verbam )
// if ( res . charAt ( 0 ) = = ' p ' & & res . charAt ( 6 ) = = ' _ ' ) res . setCharAt ( 6 , ' n ' ) ;
// if ( res . charAt ( 0 ) = = ' v ' & & res . charAt ( 3 ) ! = ' p ' & & res . charAt ( 10 ) = = ' _ ' ) res . setCharAt ( 10 , ' n ' ) ;
return res . toString ( ) ;