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

implementation: float result = cublasSdotNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * float
 * cublasSnrm2 ( int n , const float * x , int incx )
 * computes the Euclidean norm of the single precision n - vector x ( with
 * storage increment incx ) . This code uses a multiphase model of
 * accumulation to avoid intermediate underflow and overflow .
 * Input
 * n number of elements in input vector
 * x single precision vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns Euclidian norm ( 0 if n < = 0 or incx < = 0 , or if an error occurs )
 * Reference : http : / / www . netlib . org / blas / snrm2 . f
 * Reference : http : / / www . netlib . org / slatec / lin / snrm2 . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static float cublasSnrm2 ( int n , Pointer x , int incx ) { } }

implementation: float result = cublasSnrm2Native ( n , x , incx ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSrot ( int n , float * x , int incx , float * y , int incy , float sc ,
 * float ss )
 * multiplies a 2x2 matrix ( sc ss ) with the 2xn matrix ( transpose ( x ) )
 * ( - ss sc ) ( transpose ( y ) )
 * The elements of x are in x [ lx + i * incx ] , i = 0 . . . n - 1 , where lx = 1 if
 * incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and similarly for y using ly and
 * incy .
 * Input
 * n number of elements in input vectors
 * x single precision vector with n elements
 * incx storage spacing between elements of x
 * y single precision vector with n elements
 * incy storage spacing between elements of y
 * sc element of rotation matrix
 * ss element of rotation matrix
 * Output
 * x rotated vector x ( unchanged if n < = 0)
 * y rotated vector y ( unchanged if n < = 0)
 * Reference http : / / www . netlib . org / blas / srot . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasSrot ( int n , Pointer x , int incx , Pointer y , int incy , float sc , float ss ) { } }

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


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

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


signature:
public class JCublas { /** * < pre >
 * void
 * sscal ( int n , float alpha , float * x , int incx )
 * replaces single precision vector x with single precision alpha * x . For i
 * = 0 to n - 1 , it replaces x [ ix + i * incx ] with alpha * x [ ix + i * incx ] ,
 * where ix = 1 if incx > = 0 , else ix = 1 + ( 1 - n ) * incx .
 * Input
 * n number of elements in input vectors
 * alpha single precision scalar multiplier
 * x single precision vector with n elements
 * incx storage spacing between elements of x
 * Output
 * x single precision result ( unchanged if n < = 0 or incx < = 0)
 * Reference : http : / / www . netlib . org / blas / sscal . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasSscal ( int n , float alpha , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSswap ( int n , float * x , int incx , float * y , int incy )
 * interchanges the single - precision vector x with the single - precision vector y .
 * For i = 0 to n - 1 , interchanges x [ lx + i * incx ] with y [ ly + i * incy ] , where
 * lx = 1 if incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a
 * similar way using incy .
 * Input
 * n number of elements in input vectors
 * x single precision vector with n elements
 * incx storage spacing between elements of x
 * y single precision vector with n elements
 * incy storage spacing between elements of y
 * Output
 * x contains single precision vector y
 * y contains single precision vector x
 * Reference : http : / / www . netlib . org / blas / sscal . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasSswap ( int n , Pointer x , int incx , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCaxpy ( int n , cuComplex alpha , const cuComplex * x , int incx ,
 * cuComplex * y , int incy )
 * multiplies single - complex vector x by single - complex scalar alpha and adds
 * the result to single - complex vector y ; that is , it overwrites single - complex
 * y with single - complex alpha * x + y . For i = 0 to n - 1 , it replaces
 * y [ ly + i * incy ] with alpha * x [ lx + i * incx ] + y [ ly + i * incy ] , where
 * lx = 0 if incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a
 * similar way using incy .
 * Input
 * n number of elements in input vectors
 * alpha single - complex scalar multiplier
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * y single - complex vector with n elements
 * incy storage spacing between elements of y
 * Output
 * y single - complex result ( unchanged if n < = 0)
 * Reference : http : / / www . netlib . org / blas / caxpy . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCaxpy ( int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCcopy ( int n , const cuComplex * x , int incx , cuComplex * y , int incy )
 * copies the single - complex vector x to the single - complex vector y . For
 * i = 0 to n - 1 , copies x [ lx + i * incx ] to y [ ly + i * incy ] , where lx = 1 if
 * incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a similar
 * way using incy .
 * Input
 * n number of elements in input vectors
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * y single - complex vector with n elements
 * incy storage spacing between elements of y
 * Output
 * y contains single complex vector x
 * Reference : http : / / www . netlib . org / blas / ccopy . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCcopy ( int n , Pointer x , int incx , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZcopy ( int n , const cuDoubleComplex * x , int incx , cuDoubleComplex * y , int incy )
 * copies the double - complex vector x to the double - complex vector y . For
 * i = 0 to n - 1 , copies x [ lx + i * incx ] to y [ ly + i * incy ] , where lx = 1 if
 * incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a similar
 * way using incy .
 * Input
 * n number of elements in input vectors
 * x double - complex vector with n elements
 * incx storage spacing between elements of x
 * y double - complex vector with n elements
 * incy storage spacing between elements of y
 * Output
 * y contains double complex vector x
 * Reference : http : / / www . netlib . org / blas / zcopy . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZcopy ( int n , Pointer x , int incx , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCscal ( int n , cuComplex alpha , cuComplex * x , int incx )
 * replaces single - complex vector x with single - complex alpha * x . For i
 * = 0 to n - 1 , it replaces x [ ix + i * incx ] with alpha * x [ ix + i * incx ] ,
 * where ix = 1 if incx > = 0 , else ix = 1 + ( 1 - n ) * incx .
 * Input
 * n number of elements in input vectors
 * alpha single - complex scalar multiplier
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * Output
 * x single - complex result ( unchanged if n < = 0 or incx < = 0)
 * Reference : http : / / www . netlib . org / blas / cscal . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCscal ( int n , cuComplex alpha , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCrotg ( cuComplex * host _ ca , cuComplex cb , float * host _ sc , cuComplex * host _ cs )
 * constructs the complex Givens tranformation
 * ( sc cs )
 * G = ( ) , sc ^ 2 + cabs ( cs ) ^ 2 = 1,
 * ( - cs sc )
 * which zeros the second entry of the complex 2 - vector transpose ( ca , cb ) .
 * The quantity ca / cabs ( ca ) * norm ( ca , cb ) overwrites ca in storage . The
 * function crot ( n , x , incx , y , incy , sc , cs ) is normally called next
 * to apply the transformation to a 2 x n matrix .
 * Note that is function is provided for completeness and run exclusively
 * on the Host .
 * Input
 * ca single - precision complex precision scalar
 * cb single - precision complex scalar
 * Output
 * ca single - precision complex ca / cabs ( ca ) * norm ( ca , cb )
 * sc single - precision cosine component of rotation matrix
 * cs single - precision complex sine component of rotation matrix
 * Reference : http : / / www . netlib . org / blas / crotg . f
 * This function does not set any error status .
 * < / pre > */
public static void cublasCrotg ( Pointer host_ca , cuComplex cb , Pointer host_sc , Pointer host_cs ) { } }

implementation: cublasCrotgNative ( host_ca , cb , host_sc , host_cs ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCrot ( int n , cuComplex * x , int incx , cuComplex * y , int incy , float sc ,
 * cuComplex cs )
 * multiplies a 2x2 matrix ( sc cs ) with the 2xn matrix ( transpose ( x ) )
 * ( - conj ( cs ) sc ) ( transpose ( y ) )
 * The elements of x are in x [ lx + i * incx ] , i = 0 . . . n - 1 , where lx = 1 if
 * incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and similarly for y using ly and
 * incy .
 * Input
 * n number of elements in input vectors
 * x single - precision complex vector with n elements
 * incx storage spacing between elements of x
 * y single - precision complex vector with n elements
 * incy storage spacing between elements of y
 * sc single - precision cosine component of rotation matrix
 * cs single - precision complex sine component of rotation matrix
 * Output
 * x rotated single - precision complex vector x ( unchanged if n < = 0)
 * y rotated single - precision complex vector y ( unchanged if n < = 0)
 * Reference : http : / / netlib . org / lapack / explore - html / crot . f . html
 * 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCrot ( int n , Pointer x , int incx , Pointer y , int incy , float c , cuComplex s ) { } }

implementation: cublasCrotNative ( n , x , incx , y , incy , c , s ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * csrot ( int n , cuComplex * x , int incx , cuCumplex * y , int incy , float c ,
 * float s )
 * multiplies a 2x2 rotation matrix ( c s ) with a 2xn matrix ( transpose ( x ) )
 * ( - s c ) ( transpose ( y ) )
 * The elements of x are in x [ lx + i * incx ] , i = 0 . . . n - 1 , where lx = 1 if
 * incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and similarly for y using ly and
 * incy .
 * Input
 * n number of elements in input vectors
 * x single - precision complex vector with n elements
 * incx storage spacing between elements of x
 * y single - precision complex vector with n elements
 * incy storage spacing between elements of y
 * c cosine component of rotation matrix
 * s sine component of rotation matrix
 * Output
 * x rotated vector x ( unchanged if n < = 0)
 * y rotated vector y ( unchanged if n < = 0)
 * Reference http : / / www . netlib . org / blas / csrot . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCsrot ( int n , Pointer x , int incx , Pointer y , int incy , float c , float s ) { } }

implementation: cublasCsrotNative ( n , x , incx , y , incy , c , s ) ; checkResultBLAS ( ) ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCsscal ( int n , float alpha , cuComplex * x , int incx )
 * replaces single - complex vector x with single - complex alpha * x . For i
 * = 0 to n - 1 , it replaces x [ ix + i * incx ] with alpha * x [ ix + i * incx ] ,
 * where ix = 1 if incx > = 0 , else ix = 1 + ( 1 - n ) * incx .
 * Input
 * n number of elements in input vectors
 * alpha single precision scalar multiplier
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * Output
 * x single - complex result ( unchanged if n < = 0 or incx < = 0)
 * Reference : http : / / www . netlib . org / blas / csscal . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCsscal ( int n , float alpha , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasCswap ( int n , const cuComplex * x , int incx , cuComplex * y , int incy )
 * interchanges the single - complex vector x with the single - complex vector y .
 * For i = 0 to n - 1 , interchanges x [ lx + i * incx ] with y [ ly + i * incy ] , where
 * lx = 1 if incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a
 * similar way using incy .
 * Input
 * n number of elements in input vectors
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * y single - complex vector with n elements
 * incy storage spacing between elements of y
 * Output
 * x contains - single complex vector y
 * y contains - single complex vector x
 * Reference : http : / / www . netlib . org / blas / cswap . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasCswap ( int n , Pointer x , int incx , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZswap ( int n , const cuDoubleComplex * x , int incx , cuDoubleComplex * y , int incy )
 * interchanges the double - complex vector x with the double - complex vector y .
 * For i = 0 to n - 1 , interchanges x [ lx + i * incx ] with y [ ly + i * incy ] , where
 * lx = 1 if incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a
 * similar way using incy .
 * Input
 * n number of elements in input vectors
 * x double - complex vector with n elements
 * incx storage spacing between elements of x
 * y double - complex vector with n elements
 * incy storage spacing between elements of y
 * Output
 * x contains - double complex vector y
 * y contains - double complex vector x
 * Reference : http : / / www . netlib . org / blas / zswap . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZswap ( int n , Pointer x , int incx , Pointer y , int incy ) { } }

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


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

implementation: cuComplex result = cublasCdotuNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ;


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

implementation: cuComplex result = cublasCdotcNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * int
 * cublasIcamax ( int n , const float * x , int incx )
 * finds the smallest index of the element having maximum absolute value
 * in single - complex vector x ; that is , the result is the first i , i = 0
 * to n - 1 that maximizes abs ( real ( x [ 1 + i * incx ] ) ) + abs ( imag ( x [ 1 + i * incx ] ) ) .
 * Input
 * n number of elements in input vector
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns the smallest index ( 0 if n < = 0 or incx < = 0)
 * Reference : http : / / www . netlib . org / blas / icamax . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static int cublasIcamax ( int n , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * int
 * cublasIcamin ( int n , const float * x , int incx )
 * finds the smallest index of the element having minimum absolute value
 * in single - complex vector x ; that is , the result is the first i , i = 0
 * to n - 1 that minimizes abs ( real ( x [ 1 + i * incx ] ) ) + abs ( imag ( x [ 1 + i * incx ] ) ) .
 * Input
 * n number of elements in input vector
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns the smallest index ( 0 if n < = 0 or incx < = 0)
 * Reference : see ICAMAX .
 * 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static int cublasIcamin ( int n , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * float
 * cublasScasum ( int n , const cuDouble * x , int incx )
 * takes the sum of the absolute values of a complex vector and returns a
 * single precision result . Note that this is not the L1 norm of the vector .
 * The result is the sum from 0 to n - 1 of abs ( real ( x [ ix + i * incx ] ) ) +
 * abs ( imag ( x ( ix + i * incx ) ) ) , where ix = 1 if incx < = 0 , else ix = 1 + ( 1 - n ) * incx .
 * Input
 * n number of elements in input vector
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns the single precision sum of absolute values of real and imaginary
 * parts ( 0 if n < = 0 or incx < = 0 , or if an error occurs )
 * Reference : http : / / www . netlib . org / blas / scasum . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static float cublasScasum ( int n , Pointer x , int incx ) { } }

implementation: float result = cublasScasumNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * float
 * cublasScnrm2 ( int n , const cuComplex * x , int incx )
 * computes the Euclidean norm of the single - complex n - vector x . This code
 * uses simple scaling to avoid intermediate underflow and overflow .
 * Input
 * n number of elements in input vector
 * x single - complex vector with n elements
 * incx storage spacing between elements of x
 * Output
 * returns Euclidian norm ( 0 if n < = 0 or incx < = 0 , or if an error occurs )
 * Reference : http : / / www . netlib . org / blas / scnrm2 . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static float cublasScnrm2 ( int n , Pointer x , int incx ) { } }

implementation: float result = cublasScnrm2Native ( n , x , incx ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZaxpy ( int n , cuDoubleComplex alpha , const cuDoubleComplex * x , int incx ,
 * cuDoubleComplex * y , int incy )
 * multiplies double - complex vector x by double - complex scalar alpha and adds
 * the result to double - complex vector y ; that is , it overwrites double - complex
 * y with double - complex alpha * x + y . For i = 0 to n - 1 , it replaces
 * y [ ly + i * incy ] with alpha * x [ lx + i * incx ] + y [ ly + i * incy ] , where
 * lx = 0 if incx > = 0 , else lx = 1 + ( 1 - n ) * incx , and ly is defined in a
 * similar way using incy .
 * Input
 * n number of elements in input vectors
 * alpha double - complex scalar multiplier
 * x double - complex vector with n elements
 * incx storage spacing between elements of x
 * y double - complex vector with n elements
 * incy storage spacing between elements of y
 * Output
 * y double - complex result ( unchanged if n < = 0)
 * Reference : http : / / www . netlib . org / blas / zaxpy . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZaxpy ( int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy ) { } }

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


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

implementation: cuDoubleComplex result = cublasZdotuNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ;


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

implementation: cuDoubleComplex result = cublasZdotcNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ;


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZscal ( int n , cuComplex alpha , cuComplex * x , int incx )
 * replaces double - complex vector x with double - complex alpha * x . For i
 * = 0 to n - 1 , it replaces x [ ix + i * incx ] with alpha * x [ ix + i * incx ] ,
 * where ix = 1 if incx > = 0 , else ix = 1 + ( 1 - n ) * incx .
 * Input
 * n number of elements in input vectors
 * alpha double - complex scalar multiplier
 * x double - complex vector with n elements
 * incx storage spacing between elements of x
 * Output
 * x double - complex result ( unchanged if n < = 0 or incx < = 0)
 * Reference : http : / / www . netlib . org / blas / zscal . 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 _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZscal ( int n , cuDoubleComplex alpha , Pointer x , int incx ) { } }

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


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

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


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

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZrotg ( cuDoubleComplex * host _ ca , cuDoubleComplex cb , double * host _ sc , double * host _ cs )
 * constructs the complex Givens tranformation
 * ( sc cs )
 * G = ( ) , sc ^ 2 + cabs ( cs ) ^ 2 = 1,
 * ( - cs sc )
 * which zeros the second entry of the complex 2 - vector transpose ( ca , cb ) .
 * The quantity ca / cabs ( ca ) * norm ( ca , cb ) overwrites ca in storage . The
 * function crot ( n , x , incx , y , incy , sc , cs ) is normally called next
 * to apply the transformation to a 2 x n matrix .
 * Note that is function is provided for completeness and run exclusively
 * on the Host .
 * Input
 * ca double - precision complex precision scalar
 * cb double - precision complex scalar
 * Output
 * ca double - precision complex ca / cabs ( ca ) * norm ( ca , cb )
 * sc double - precision cosine component of rotation matrix
 * cs double - precision complex sine component of rotation matrix
 * Reference : http : / / www . netlib . org / blas / zrotg . f
 * This function does not set any error status .
 * < / pre > */
public static void cublasZrotg ( Pointer host_ca , cuDoubleComplex cb , Pointer host_sc , Pointer host_cs ) { } }

implementation: cublasZrotgNative ( host_ca , cb , host_sc , host_cs ) ; checkResultBLAS ( ) ;


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

implementation: cublasZrotNative ( n , x , incx , y , incy , sc , cs ) ; checkResultBLAS ( ) ;


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

implementation: cublasZdrotNative ( n , x , incx , y , incy , c , s ) ; checkResultBLAS ( ) ;


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

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


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

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


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

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSgbmv ( char trans , int m , int n , int kl , int ku , float alpha ,
 * const float * A , int lda , const float * x , int incx , float beta ,
 * float * 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 scalars . x and y are single precision
 * vectors . A is an m by n band matrix consisting of single precision 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 ' ,
 * ' 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 .
 * 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 scalar multiplier applied to op ( A ) .
 * A single precision 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 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 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 . 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 * op ( A ) * x + beta * y
 * Reference : http : / / www . netlib . org / blas / sgbmv . 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 , kl , or ku < 0 ; if incx or incy = = 0
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasSgbmv ( char trans , int m , int n , int kl , int ku , float alpha , Pointer A , int lda , Pointer x , int incx , float beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * cublasSgemv ( char trans , int m , int n , float alpha , const float * A , int lda ,
 * const float * x , int incx , float beta , float * 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 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 ' , ' 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 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 x . incx must not
 * be zero .
 * Output
 * y updated according to alpha * op ( A ) * x + beta * y
 * Reference : http : / / www . netlib . org / blas / sgemv . 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 cublasSgemv ( char trans , int m , int n , float alpha , Pointer A , int lda , Pointer x , int incx , float beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * cublasSger ( int m , int n , float alpha , const float * x , int incx ,
 * const float * y , int incy , float * A , int lda )
 * performs the symmetric rank 1 operation
 * A = alpha * x * transpose ( y ) + A ,
 * where alpha is a single precision scalar , x is an m element single
 * precision vector , y is an n element single precision vector , and A
 * is an m by 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 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 scalar multiplier applied to x * transpose ( y )
 * x single 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 single precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) )
 * incy specifies the storage spacing between elements of y . incy must not
 * be zero .
 * A single precision array of dimensions ( lda , n ) .
 * lda leading dimension of two - dimensional array used to store matrix A
 * Output
 * A updated according to A = alpha * x * transpose ( y ) + A
 * Reference : http : / / www . netlib . org / blas / sger . 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 cublasSger ( int m , int n , float alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSsbmv ( char uplo , int n , int k , float alpha , const float * A , int lda ,
 * const float * x , int incx , float beta , float * y , int incy )
 * performs the matrix - vector operation
 * y : = alpha * A * x + beta * y
 * alpha and beta are single precision scalars . x and y are single precision
 * vectors with n elements . A is an n x n symmetric band matrix consisting
 * of single precision elements , with k super - diagonals and the same number
 * of sub - diagonals .
 * Input
 * uplo specifies whether the upper or lower triangular part of the symmetric
 * band matrix A is being supplied . If uplo = = ' U ' or ' u ' , the upper
 * triangular part is being supplied . If uplo = = ' L ' or ' l ' , the lower
 * triangular part is being supplied .
 * n specifies the number of rows and the number of columns of the
 * symmetric matrix A . n must be at least zero .
 * k specifies the number of super - diagonals of matrix A . Since the matrix
 * is symmetric , this is also the number of sub - diagonals . k must be at
 * least zero .
 * alpha single precision scalar multiplier applied to A * x .
 * A single precision array of dimensions ( lda , n ) . When uplo = = ' U ' or
 * ' u ' , the leading ( k + 1 ) x n part of array A must contain the upper
 * triangular band of the symmetric matrix , supplied column by column ,
 * with the leading diagonal of the matrix in row ( k + 1 ) of the array ,
 * the first super - diagonal starting at position 2 in row k , and so on .
 * The top left k x k triangle of the array A is not referenced . When
 * uplo = = ' L ' or ' l ' , the leading ( k + 1 ) x n part of the array A must
 * contain the lower triangular band part of the symmetric matrix ,
 * supplied column by column , with the leading diagonal of the matrix in
 * row 1 of the array , the first sub - diagonal starting at position 1 in
 * row 2 , and so on . The bottom right k x k triangle of the array A is
 * not referenced .
 * lda leading dimension of A . lda must be at least ( k + 1 ) .
 * x single precision 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 scalar multiplier applied to vector y . If beta is
 * zero , y is not read .
 * y single precision array of length at least ( 1 + ( n - 1 ) * abs ( incy ) ) .
 * If beta is zero , y is not read .
 * incy storage spacing between elements of y . incy must not be zero .
 * Output
 * y updated according to alpha * A * x + beta * y
 * Reference : http : / / www . netlib . org / blas / ssbmv . f
 * Error status for this function can be retrieved via cublasGetError ( ) .
 * Error Status
 * 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 cublasSsbmv ( char uplo , int n , int k , float alpha , Pointer A , int lda , Pointer x , int incx , float beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSspmv ( char uplo , int n , float alpha , const float * AP , const float * x ,
 * int incx , float beta , float * y , int incy )
 * performs the matrix - vector operation
 * y = alpha * A * x + beta * y
 * Alpha and beta are single precision scalars , and x and y are single
 * precision vectors with n elements . A is a symmetric n x n matrix
 * consisting of single precision elements that is supplied in packed form .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the lower
 * triangular part of array AP . If uplo = = ' U ' or ' u ' , then the upper
 * triangular part of A is supplied in AP . If uplo = = ' L ' or ' l ' , then
 * the lower triangular part of A is supplied in AP .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha single precision scalar multiplier applied to A * x .
 * AP single precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i < = j , then A [ i , j ] is stored is AP [ i + ( j * ( j + 1 ) / 2 ) ] . If
 * uplo = = ' L ' or ' L ' , the array AP contains the lower triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i > = j , then A [ i , j ] is stored in AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] .
 * x single precision 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 scalar multiplier applied to vector y ;
 * y single 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 / sspmv . 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 cublasSspmv ( char uplo , int n , float alpha , Pointer AP , Pointer x , int incx , float beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSspr ( char uplo , int n , float alpha , const float * x , int incx ,
 * float * AP )
 * performs the symmetric rank 1 operation
 * A = alpha * x * transpose ( x ) + A ,
 * where alpha is a single precision scalar and x is an n element single
 * precision vector . A is a symmetric n x n matrix consisting of single
 * precision elements that is supplied in packed form .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the lower
 * triangular part of array AP . If uplo = = ' U ' or ' u ' , then the upper
 * triangular part of A is supplied in AP . If uplo = = ' L ' or ' l ' , then
 * the lower triangular part of A is supplied in AP .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha single precision scalar multiplier applied to x * 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 array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i < = j , then A [ i , j ] is stored is AP [ i + ( j * ( j + 1 ) / 2 ) ] . If
 * uplo = = ' L ' or ' L ' , the array AP contains the lower triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i > = j , then A [ i , j ] is stored in AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] .
 * Output
 * A updated according to A = alpha * x * transpose ( x ) + A
 * Reference : http : / / www . netlib . org / blas / sspr . 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 cublasSspr ( char uplo , int n , float alpha , Pointer x , int incx , Pointer AP ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSspr2 ( char uplo , int n , float alpha , const float * x , int incx ,
 * const float * y , int incy , float * AP )
 * performs the symmetric rank 2 operation
 * A = alpha * x * transpose ( y ) + alpha * y * transpose ( x ) + A ,
 * where alpha is a single precision scalar , and x and y are n element single
 * precision vectors . A is a symmetric n x n matrix consisting of single
 * precision elements that is supplied in packed form .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the lower
 * triangular part of array A . If uplo = = ' U ' or ' u ' , then only the
 * upper triangular part of A may be referenced and the lower triangular
 * part of A is inferred . If uplo = = ' L ' or ' l ' , then only the lower
 * triangular part of A may be referenced and the upper triangular part
 * of A is inferred .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha single precision scalar multiplier applied to x * transpose ( y ) +
 * y * 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 .
 * AP single precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i < = j , then A [ i , j ] is stored is AP [ i + ( j * ( j + 1 ) / 2 ) ] . If
 * uplo = = ' L ' or ' L ' , the array AP contains the lower triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i > = j , then A [ i , j ] is stored in AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] .
 * Output
 * A updated according to A = alpha * x * transpose ( y ) + alpha * y * transpose ( x ) + A
 * Reference : http : / / www . netlib . org / blas / sspr2 . 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 cublasSspr2 ( char uplo , int n , float alpha , Pointer x , int incx , Pointer y , int incy , Pointer AP ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSsymv ( char uplo , int n , float alpha , const float * A , int lda ,
 * const float * x , int incx , float beta , float * y , int incy )
 * performs the matrix - vector operation
 * y = alpha * A * x + beta * y
 * Alpha and beta are single precision scalars , and x and y are single
 * precision vectors , each with n elements . A is a symmetric n x n matrix
 * consisting of single precision elements that is stored in either upper or
 * lower storage mode .
 * Input
 * uplo specifies whether the upper or lower triangular part of the array A
 * is to be referenced . If uplo = = ' U ' or ' u ' , the symmetric matrix A
 * is stored in upper storage mode , i . e . only the upper triangular part
 * of A is to be referenced while the lower triangular part of A is to
 * be inferred . If uplo = = ' L ' or ' l ' , the symmetric matrix A is stored
 * in lower storage mode , i . e . only the lower triangular part of A is
 * to be referenced while the upper triangular part of A is to be
 * inferred .
 * n specifies the number of rows and the number of columns of the
 * symmetric matrix A . n must be at least zero .
 * alpha single precision scalar multiplier applied to A * x .
 * A single precision array of dimensions ( lda , n ) . If uplo = = ' U ' or ' u ' ,
 * the leading n x n upper triangular part of the array A must contain
 * the upper triangular part of the symmetric matrix and the strictly
 * lower triangular part of A is not referenced . If uplo = = ' L ' or ' l ' ,
 * the leading n x n lower triangular part of the array A must contain
 * the lower triangular part of the symmetric matrix and the strictly
 * upper triangular part of A is not referenced .
 * lda leading dimension of A . It must be at least max ( 1 , n ) .
 * x single precision 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 scalar multiplier applied to vector y .
 * y single 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 / ssymv . 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 cublasSsymv ( char uplo , int n , float alpha , Pointer A , int lda , Pointer x , int incx , float beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSsyr ( char uplo , int n , float alpha , const float * x , int incx ,
 * float * A , int lda )
 * performs the symmetric rank 1 operation
 * A = alpha * x * transpose ( x ) + A ,
 * where alpha is a single precision scalar , x is an n element single
 * precision vector and A is an n x n symmetric 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
 * 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 scalar multiplier applied to x * transpose ( x )
 * x single precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) )
 * incx specifies the storage spacing between elements of x . incx must
 * not be zero .
 * A single precision array of dimensions ( lda , n ) . If uplo = ' U ' or
 * ' u ' , then A must contain the upper triangular part of a symmetric
 * matrix , and the strictly lower triangular part is not referenced .
 * If uplo = ' L ' or ' l ' , then A contains the lower triangular part
 * of a symmetric matrix , and the strictly upper triangular part is
 * not referenced .
 * lda leading dimension of the two - dimensional array containing A . lda
 * must be at least max ( 1 , n ) .
 * Output
 * A updated according to A = alpha * x * transpose ( x ) + A
 * Reference : http : / / www . netlib . org / blas / ssyr . 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 cublasSsyr ( char uplo , int n , float alpha , Pointer x , int incx , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasSsyr2 ( char uplo , int n , float alpha , const float * x , int incx ,
 * const float * y , int incy , float * A , int lda )
 * performs the symmetric rank 2 operation
 * A = alpha * x * transpose ( y ) + alpha * y * transpose ( x ) + A ,
 * where alpha is a single precision scalar , x and y are n element single
 * precision vector and A is an n by n symmetric matrix consisting of single
 * precision elements .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the lower
 * triangular part of array A . If uplo = = ' U ' or ' u ' , then only the
 * upper triangular part of A may be referenced and the lower triangular
 * part of A is inferred . If uplo = = ' L ' or ' l ' , then only the lower
 * triangular part of A may be referenced and the upper triangular part
 * of A is inferred .
 * n specifies the number of rows and columns of the matrix A . It must be
 * at least zero .
 * alpha single precision scalar multiplier applied to x * transpose ( y ) +
 * y * 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 array of dimensions ( lda , n ) . If uplo = = ' U ' or ' u ' ,
 * then A must contains the upper triangular part of a symmetric matrix ,
 * and the strictly lower triangular parts is not referenced . If uplo = =
 * ' L ' or ' l ' , then A contains the lower triangular part of a symmetric
 * matrix , and the strictly upper triangular part is not referenced .
 * lda leading dimension of A . It must be at least max ( 1 , n ) .
 * Output
 * A updated according to A = alpha * x * transpose ( y ) + alpha * y * transpose ( x ) + A
 * Reference : http : / / www . netlib . org / blas / ssyr2 . 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 cublasSsyr2 ( char uplo , int n , float alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasStbmv ( char uplo , char trans , char diag , int n , int k , const float * A ,
 * int lda , float * x , int incx )
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) = A
 * or op ( A ) = transpose ( A ) . x is an n - element single precision vector , and A is
 * an n x n , unit or non - unit upper or lower triangular band matrix consisting
 * of single precision elements .
 * Input
 * uplo specifies whether the matrix A is an upper or lower triangular band
 * matrix . If uplo = = ' U ' or ' u ' , A is an upper triangular band matrix .
 * If uplo = = ' L ' or ' l ' , A is a lower triangular band matrix .
 * trans specifies op ( A ) . If transa = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A ) .
 * diag specifies whether or not matrix A is unit triangular . If diag = = ' U '
 * or ' u ' , A is assumed to be unit triangular . If diag = = ' N ' or ' n ' , A
 * is not assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero . In the current implementation n must not exceed 4070.
 * 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 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 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 / stbmv . 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 , k < 0 , or 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 cublasStbmv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void cublasStbsv ( char uplo , char trans , char diag , int n , int k ,
 * const float * A , int lda , float * X , int incx )
 * solves one of the systems of equations op ( A ) * x = b , where op ( A ) is either
 * op ( A ) = A or op ( A ) = transpose ( A ) . b and x are n - element vectors , and A is
 * an n x n unit or non - unit , upper or lower triangular band matrix with k + 1
 * diagonals . No test for singularity or near - singularity is included in this
 * function . Such tests must be performed before calling this function .
 * Input
 * uplo specifies whether the matrix is an upper or lower triangular band
 * matrix as follows : If uplo = = ' U ' or ' u ' , A is an upper triangular
 * band matrix . If uplo = = ' L ' or ' l ' , A is a lower triangular band
 * matrix .
 * trans specifies op ( A ) . If trans = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A ) .
 * diag specifies whether A is unit triangular . If diag = = ' U ' or ' u ' , A is
 * assumed to be unit triangular ; thas is , diagonal elements are not
 * read and are assumed to be unity . If diag = = ' N ' or ' n ' , A is not
 * assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero .
 * k specifies the number of super - or sub - diagonals . If uplo = = ' U ' or
 * ' u ' , k specifies the number of super - diagonals . If uplo = = ' L ' or
 * ' l ' , k specifies the number of sub - diagonals . k must be at least
 * zero .
 * A single precision array of dimension ( lda , n ) . If uplo = = ' U ' or ' u ' ,
 * the leading ( k + 1 ) x n part of the array A must contain the upper
 * triangular band matrix , supplied column by column , with the leading
 * diagonal of the matrix in row ( k + 1 ) of the array , the first super -
 * diagonal starting at position 2 in row k , and so on . The top left
 * k x k triangle of the array A is not referenced . If uplo = = ' L ' or
 * ' l ' , the leading ( k + 1 ) x n part of the array A must constain the
 * lower triangular band matrix , supplied column by column , with the
 * leading diagonal of the matrix in row 1 of the array , the first
 * sub - diagonal starting at position 1 in row 2 , and so on . The bottom
 * right k x k triangle of the array is not referenced .
 * x single precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the n - element right - hand side vector b . On exit ,
 * it is overwritten with the solution vector x .
 * incx 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 / stbsv . 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 > 4070
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasStbsv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasStpmv ( char uplo , char trans , char diag , int n , const float * AP ,
 * float * x , int incx ) ;
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) = A ,
 * or op ( A ) = transpose ( A ) . x is an n element single precision vector , and A
 * is an n x n , unit or non - unit , upper or lower triangular matrix composed
 * of single precision elements .
 * Input
 * uplo specifies whether the matrix A is an upper or lower triangular
 * matrix . If uplo = = ' U ' or ' u ' , then A is an upper triangular matrix .
 * If uplo = = ' L ' or ' l ' , then A is a lower triangular matrix .
 * trans specifies op ( A ) . If transa = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A )
 * diag specifies whether or not matrix A is unit triangular . If diag = = ' U '
 * or ' u ' , A is assumed to be unit triangular . If diag = = ' N ' or ' n ' , A
 * is not assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero .
 * AP single precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If
 * uplo = = ' U ' or ' u ' , the array AP contains the upper triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i < = j , then A [ i , j ] is stored in AP [ i + ( j * ( j + 1 ) / 2 ) ] . If
 * uplo = = ' L ' or ' L ' , the array AP contains the lower triangular part
 * of the symmetric matrix A , packed sequentially , column by column ;
 * that is , if i > = j , then A [ i , j ] is stored in AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] .
 * x 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 / stpmv . 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 _ 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 cublasStpmv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasStpsv ( char uplo , char trans , char diag , int n , const float * AP ,
 * float * X , int incx )
 * solves one of the systems of equations op ( A ) * x = b , where op ( A ) is either
 * op ( A ) = A or op ( A ) = transpose ( A ) . b and x are n element vectors , and A is
 * an n x n unit or non - unit , upper or lower triangular matrix . No test for
 * singularity or near - singularity is included in this function . Such tests
 * must be performed before calling this function .
 * Input
 * uplo specifies whether the matrix is an upper or lower triangular matrix
 * as follows : If uplo = = ' U ' or ' u ' , A is an upper triangluar matrix .
 * If uplo = = ' L ' or ' l ' , A is a lower triangular matrix .
 * trans specifies op ( A ) . If trans = = ' N ' or ' n ' , op ( A ) = A . If trans = = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A ) .
 * diag specifies whether A is unit triangular . If diag = = ' U ' or ' u ' , A is
 * assumed to be unit triangular ; thas is , diagonal elements are not
 * read and are assumed to be unity . If diag = = ' N ' or ' n ' , A is not
 * assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero . In the current implementation n must not exceed 4070.
 * AP single precision array with at least ( ( n * ( n + 1 ) ) / 2 ) elements . If uplo
 * = = ' U ' or ' u ' , the array AP contains the upper triangular matrix A ,
 * packed sequentially , column by column ; that is , if i < = j , then
 * A [ i , j ] is stored is AP [ i + ( j * ( j + 1 ) / 2 ) ] . If uplo = = ' L ' or ' L ' , the
 * array AP contains the lower triangular matrix A , packed sequentially ,
 * column by column ; that is , if i > = j , then A [ i , j ] is stored in
 * AP [ i + ( ( 2 * n - j + 1 ) * j ) / 2 ] . When diag = ' U ' or ' u ' , the diagonal elements
 * of A are not referenced and are assumed to be unity .
 * x single precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the n - element right - hand side vector b . On exit ,
 * it is overwritten with the solution vector x .
 * incx 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 / stpsv . 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 > 4070
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasStpsv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasStrmv ( char uplo , char trans , char diag , int n , const float * A ,
 * int lda , float * x , int incx ) ;
 * performs one of the matrix - vector operations x = op ( A ) * x , where op ( A ) =
 * = A , or op ( A ) = transpose ( A ) . x is an n - element single precision vector , and
 * A is an n x n , unit or non - unit , upper or lower , triangular matrix composed
 * of single precision elements .
 * Input
 * uplo specifies whether the matrix A is an upper or lower triangular
 * matrix . If uplo = ' U ' or ' u ' , then A is an upper triangular matrix .
 * If uplo = ' L ' or ' l ' , then A is a lower triangular matrix .
 * trans specifies op ( A ) . If transa = ' N ' or ' n ' , op ( A ) = A . If trans = ' T ' ,
 * ' t ' , ' C ' , or ' c ' , op ( A ) = transpose ( A )
 * diag specifies whether or not matrix A is unit triangular . If diag = ' U '
 * or ' u ' , A is assumed to be unit triangular . If diag = ' N ' or ' n ' , A
 * is not assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . n must be
 * at least zero .
 * A single precision array of dimension ( lda , n ) . If uplo = ' U ' or ' u ' ,
 * the leading n x n upper triangular part of the array A must contain
 * the upper triangular matrix and the strictly lower triangular part
 * of A is not referenced . If uplo = ' L ' or ' l ' , the leading n x n lower
 * triangular part of the array A must contain the lower triangular
 * matrix and the strictly upper triangular part of A is not referenced .
 * When diag = ' U ' or ' u ' , the diagonal elements of A are not referenced
 * either , but are are assumed to be unity .
 * lda is the leading dimension of A . It must be at least max ( 1 , n ) .
 * x single precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the source vector . On exit , x is overwritten
 * with the result vector .
 * incx specifies the storage spacing for elements of x . incx must not be
 * zero .
 * Output
 * x updated according to x = op ( A ) * x ,
 * Reference : http : / / www . netlib . org / blas / strmv . 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 cublasStrmv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasStrsv ( char uplo , char trans , char diag , int n , const float * A ,
 * int lda , float * x , int incx )
 * solves a system of equations op ( A ) * x = b , where op ( A ) is either A or
 * transpose ( A ) . b and x are single precision vectors consisting of n
 * elements , and A is an n x n matrix composed of a unit or non - unit , upper
 * or lower triangular matrix . Matrix A is stored in column major format ,
 * and lda is the leading dimension of the two - dimensional array containing
 * No test for singularity or near - singularity is included in this function .
 * Such tests must be performed before calling this function .
 * Input
 * uplo specifies whether the matrix data is stored in the upper or the
 * lower triangular part of array A . If uplo = ' U ' or ' u ' , then only
 * the upper triangular part of A may be referenced . If uplo = ' L ' or
 * ' l ' , then only the lower triangular part of A may be referenced .
 * trans specifies op ( A ) . If transa = ' n ' or ' N ' , op ( A ) = A . If transa = ' t ' ,
 * ' T ' , ' c ' , or ' C ' , op ( A ) = transpose ( A )
 * diag specifies whether or not A is a unit triangular matrix like so :
 * if diag = ' U ' or ' u ' , A is assumed to be unit triangular . If
 * diag = ' N ' or ' n ' , then A is not assumed to be unit triangular .
 * n specifies the number of rows and columns of the matrix A . It
 * must be at least 0.
 * A is a single precision array of dimensions ( lda , n ) . If uplo = ' U '
 * or ' u ' , then A must contains the upper triangular part of a symmetric
 * matrix , and the strictly lower triangular parts is not referenced .
 * If uplo = ' L ' or ' l ' , then A contains the lower triangular part of
 * a symmetric matrix , and the strictly upper triangular part is not
 * referenced .
 * lda is the leading dimension of the two - dimensional array containing A .
 * lda must be at least max ( 1 , n ) .
 * x single precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the n element right - hand side vector b . On exit ,
 * it is overwritten with the solution vector x .
 * incx specifies the storage spacing between elements of x . incx must not
 * be zero .
 * Output
 * x updated to contain the solution vector x that solves op ( A ) * x = b .
 * Reference : http : / / www . netlib . org / blas / strsv . 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 cublasStrsv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZtrmv ( char uplo , char trans , char diag , int n , const cuDoubleComplex * A ,
 * int lda , cuDoubleComplex * 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 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 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 double 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 double precision array of length at least ( 1 + ( n - 1 ) * abs ( incx ) ) .
 * On entry , x contains the source vector . On exit , x is overwritten
 * with the result vector .
 * incx specifies the storage spacing for elements of x . incx must not be
 * zero .
 * Output
 * x updated according to x = op ( A ) * x ,
 * Reference : http : / / www . netlib . org / blas / ztrmv . 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 cublasZtrmv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZgbmv ( char trans , int m , int n , int kl , int ku , 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 , op ( A ) = A or op ( A ) = transpose ( A )
 * alpha and beta are double precision complex scalars . x and y are double precision
 * complex vectors . A is an m by n band matrix consisting of double 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 double precision complex scalar multiplier applied to op ( A ) .
 * A double 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 double 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 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 + ( 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 / zgbmv . 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 cublasZgbmv ( char trans , int m , int n , int kl , int ku , cuDoubleComplex alpha , Pointer A , int lda , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { } }

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


signature:
public class JCublas { /** * < pre >
 * void
 * cublasZtbmv ( char uplo , char trans , char diag , int n , int k , const cuDoubleComplex * A ,
 * int lda , 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 band matrix composed of double 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 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 startingat position 1 in row 2 , and so on . The bottom
 * right k x k triangle of the array is not referenced .
 * lda is the leading dimension of A . It must be at least ( k + 1 ) .
 * x double precision 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 / ztbmv . 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 _ ARCH _ MISMATCH if invoked on device without DP support
 * CUBLAS _ STATUS _ EXECUTION _ FAILED if function failed to launch on GPU
 * < / pre > */
public static void cublasZtbmv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { } }

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