Input: <pre > cublasStatus_t cublasSetMatrixAsync ( int rows int cols int elemSize const void * A int lda void * B int ldb cudaStream_t stream ) [CODESPLIT] public static int cublasSetMatrixAsync ( int rows , int cols , int elemSize , Pointer A , int lda , Pointer B , int ldb , cudaStream_t stream ) { return checkResult ( cublasSetMatrixAsyncNative ( rows , cols , elemSize , A , lda , B , ldb , stream ) ) ; }


Input: <pre > cublasStatus_t cublasGetMatrixAsync ( int rows int cols int elemSize const void * A int lda void * B int ldb cudaStream_t stream ) [CODESPLIT] public static int cublasGetMatrixAsync ( int rows , int cols , int elemSize , Pointer A , int lda , Pointer B , int ldb , cudaStream_t stream ) { return checkResult ( cublasGetMatrixAsyncNative ( rows , cols , elemSize , A , lda , B , ldb , stream ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasSnrm2 ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasSnrm2Native ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDnrm2 ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasDnrm2Native ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasScnrm2 ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasScnrm2Native ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDznrm2 ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasDznrm2Native ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDotEx ( cublasHandle handle , int n , Pointer x , int xType , int incx , Pointer y , int yType , int incy , Pointer result , int resultType , int executionType ) { return checkResult ( cublasDotExNative ( handle , n , x , xType , incx , y , yType , incy , result , resultType , executionType ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDdot ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer result ) /** host or device pointer */ { return checkResult ( cublasDdotNative ( handle , n , x , incx , y , incy , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasCdotu ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer result ) /** host or device pointer */ { return checkResult ( cublasCdotuNative ( handle , n , x , incx , y , incy , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasCdotc ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer result ) /** host or device pointer */ { return checkResult ( cublasCdotcNative ( handle , n , x , incx , y , incy , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasZdotu ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer result ) /** host or device pointer */ { return checkResult ( cublasZdotuNative ( handle , n , x , incx , y , incy , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasZdotc ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer result ) /** host or device pointer */ { return checkResult ( cublasZdotcNative ( handle , n , x , incx , y , incy , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasScalEx ( cublasHandle handle , int n , Pointer alpha , /** host or device pointer */ int alphaType , Pointer x , int xType , int incx , int executionType ) { return checkResult ( cublasScalExNative ( handle , n , alpha , alphaType , x , xType , incx , executionType ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasIdamax ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasIdamaxNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasIcamax ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasIcamaxNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasIzamax ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasIzamaxNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasIsamin ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasIsaminNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasIdamin ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasIdaminNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasIcamin ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasIcaminNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasIzamin ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasIzaminNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasSasum ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasSasumNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDasum ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasDasumNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasScasum ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasScasumNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDzasum ( cublasHandle handle , int n , Pointer x , int incx , Pointer result ) /** host or device pointer */ { return checkResult ( cublasDzasumNative ( handle , n , x , incx , result ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasSrot ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasSrotNative ( handle , n , x , incx , y , incy , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDrot ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasDrotNative ( handle , n , x , incx , y , incy , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasCrot ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasCrotNative ( handle , n , x , incx , y , incy , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasCsrot ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasCsrotNative ( handle , n , x , incx , y , incy , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasZrot ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasZrotNative ( handle , n , x , incx , y , incy , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasZdrot ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasZdrotNative ( handle , n , x , incx , y , incy , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasSrotg ( cublasHandle handle , Pointer a , /** host or device pointer */ Pointer b , /** host or device pointer */ Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasSrotgNative ( handle , a , b , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDrotg ( cublasHandle handle , Pointer a , /** host or device pointer */ Pointer b , /** host or device pointer */ Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasDrotgNative ( handle , a , b , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasCrotg ( cublasHandle handle , Pointer a , /** host or device pointer */ Pointer b , /** host or device pointer */ Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasCrotgNative ( handle , a , b , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasZrotg ( cublasHandle handle , Pointer a , /** host or device pointer */ Pointer b , /** host or device pointer */ Pointer c , /** host or device pointer */ Pointer s ) /** host or device pointer */ { return checkResult ( cublasZrotgNative ( handle , a , b , c , s ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasSrotm ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer param ) /** host or device pointer */ { return checkResult ( cublasSrotmNative ( handle , n , x , incx , y , incy , param ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDrotm ( cublasHandle handle , int n , Pointer x , int incx , Pointer y , int incy , Pointer param ) /** host or device pointer */ { return checkResult ( cublasDrotmNative ( handle , n , x , incx , y , incy , param ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasSrotmg ( cublasHandle handle , Pointer d1 , /** host or device pointer */ Pointer d2 , /** host or device pointer */ Pointer x1 , /** host or device pointer */ Pointer y1 , /** host or device pointer */ Pointer param ) /** host or device pointer */ { return checkResult ( cublasSrotmgNative ( handle , d1 , d2 , x1 , y1 , param ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasDrotmg ( cublasHandle handle , Pointer d1 , /** host or device pointer */ Pointer d2 , /** host or device pointer */ Pointer x1 , /** host or device pointer */ Pointer y1 , /** host or device pointer */ Pointer param ) /** host or device pointer */ { return checkResult ( cublasDrotmgNative ( handle , d1 , d2 , x1 , y1 , param ) ) ; }


Input: host or device pointer [CODESPLIT] public static int cublasSgemv ( cublasHandle handle , int trans , int m , int n , Pointer alpha , /** host or device pointer */ Pointer A , int lda , Pointer x , int incx , Pointer beta , /** host or device pointer */ Pointer y , int incy ) { return checkResult ( cublasSgemvNative ( handle , trans , m , n , alpha , A , lda , x , incx , beta , y , incy ) ) ; }


Input: Obtain the current CUBLAS status by calling cublasGetErrorNative and store the result as the lastResult . If the obtained result code is not cublasStatus . CUBLAS_STATUS_SUCCESS and exceptions have been enabled an CudaException will be thrown . [CODESPLIT] private static void checkResultBLAS ( ) { if ( exceptionsEnabled ) { lastResult = cublasGetErrorNative ( ) ; if ( lastResult != cublasStatus . CUBLAS_STATUS_SUCCESS ) { throw new CudaException ( cublasStatus . stringFor ( lastResult ) ) ; } } }


Input: Wrapper for CUBLAS function . <br / > <br / > cublasStatus cublasAlloc ( int n int elemSize void ** devicePtr ) <br / > <br / > creates an object in GPU memory space capable of holding an array of n elements where each element requires elemSize bytes of storage . If the function call is successful a pointer to the object in GPU memory space is placed in devicePtr . Note that this is a device pointer that cannot be dereferenced in host code . <br / > <br / > Return Values<br / > ------------- <br / > CUBLAS_STATUS_NOT_INITIALIZED if CUBLAS library has not been initialized<br / > CUBLAS_STATUS_INVALID_VALUE if n < = 0 or elemSize < = 0<br / > CUBLAS_STATUS_ALLOC_FAILED if the object could not be allocated due to lack of resources . <br / > CUBLAS_STATUS_SUCCESS if storage was successfully allocated<br / > [CODESPLIT] public static int cublasAlloc ( int n , int elemSize , Pointer ptr ) { return checkResult ( cublasAllocNative ( n , elemSize , ptr ) ) ; }


Input: Extended wrapper for arrays of cuComplex values . Note that this method only exists for convenience and compatibility with native C code . It is much more efficient to provide a Pointer to a float array containing the complex numbers where each pair of consecutive numbers in the array describes the real - and imaginary part of one complex number . [CODESPLIT] public static int cublasSetVector ( int n , cuComplex x [ ] , int offsetx , int incx , Pointer y , int incy ) { ByteBuffer byteBufferx = ByteBuffer . allocateDirect ( x . length * 4 * 2 ) ; byteBufferx . order ( ByteOrder . nativeOrder ( ) ) ; FloatBuffer floatBufferx = byteBufferx . asFloatBuffer ( ) ; int indexx = offsetx ; for ( int i = 0 ; i < n ; i ++ , indexx += incx ) { floatBufferx . put ( indexx * 2 + 0 , x [ indexx ] . x ) ; floatBufferx . put ( indexx * 2 + 1 , x [ indexx ] . y ) ; } return checkResult ( cublasSetVectorNative ( n , 8 , Pointer . to ( floatBufferx ) . withByteOffset ( offsetx * 4 * 2 ) , incx , y , incy ) ) ; }


Input: Extended wrapper for arrays of cuComplex values . Note that this method only exists for convenience and compatibility with native C code . It is much more efficient to provide a Pointer to a float array that may store the complex numbers where each pair of consecutive numbers in the array describes the real - and imaginary part of one complex number . [CODESPLIT] public static int cublasGetVector ( int n , Pointer x , int incx , cuComplex y [ ] , int offsety , int incy ) { ByteBuffer byteBuffery = ByteBuffer . allocateDirect ( y . length * 4 * 2 ) ; byteBuffery . order ( ByteOrder . nativeOrder ( ) ) ; FloatBuffer floatBuffery = byteBuffery . asFloatBuffer ( ) ; int status = cublasGetVectorNative ( n , 8 , x , incx , Pointer . to ( floatBuffery ) . withByteOffset ( offsety * 4 * 2 ) , incy ) ; if ( status == cublasStatus . CUBLAS_STATUS_SUCCESS ) { floatBuffery . rewind ( ) ; int indexy = offsety ; for ( int i = 0 ; i < n ; i ++ , indexy += incy ) { y [ indexy ] . x = floatBuffery . get ( indexy * 2 + 0 ) ; y [ indexy ] . y = floatBuffery . get ( indexy * 2 + 1 ) ; } } return checkResult ( status ) ; }


Input: Extended wrapper for arrays of cuComplex values . Note that this method only exists for convenience and compatibility with native C code . It is much more efficient to provide a Pointer to a float array containing the complex numbers where each pair of consecutive numbers in the array describes the real - and imaginary part of one complex number . [CODESPLIT] public static int cublasSetMatrix ( int rows , int cols , cuComplex A [ ] , int offsetA , int lda , Pointer B , int ldb ) { ByteBuffer byteBufferA = ByteBuffer . allocateDirect ( A . length * 4 * 2 ) ; byteBufferA . order ( ByteOrder . nativeOrder ( ) ) ; FloatBuffer floatBufferA = byteBufferA . asFloatBuffer ( ) ; for ( int i = 0 ; i < A . length ; i ++ ) { floatBufferA . put ( A [ i ] . x ) ; floatBufferA . put ( A [ i ] . y ) ; } return checkResult ( cublasSetMatrixNative ( rows , cols , 8 , Pointer . to ( floatBufferA ) . withByteOffset ( offsetA * 4 * 2 ) , lda , B , ldb ) ) ; }


Input: Extended wrapper for arrays of cuComplex values . Note that this method only exists for convenience and compatibility with native C code . It is much more efficient to provide a Pointer to a float array that may store the complex numbers where each pair of consecutive numbers in the array describes the real - and imaginary part of one complex number . [CODESPLIT] public static int cublasGetMatrix ( int rows , int cols , Pointer A , int lda , cuComplex B [ ] , int offsetB , int ldb ) { ByteBuffer byteBufferB = ByteBuffer . allocateDirect ( B . length * 4 * 2 ) ; byteBufferB . order ( ByteOrder . nativeOrder ( ) ) ; FloatBuffer floatBufferB = byteBufferB . asFloatBuffer ( ) ; int status = cublasGetMatrixNative ( rows , cols , 8 , A , lda , Pointer . to ( floatBufferB ) . withByteOffset ( offsetB * 4 * 2 ) , ldb ) ; if ( status == cublasStatus . CUBLAS_STATUS_SUCCESS ) { floatBufferB . rewind ( ) ; for ( int c = 0 ; c < cols ; c ++ ) { for ( int r = 0 ; r < rows ; r ++ ) { int index = c * ldb + r + offsetB ; B [ index ] . x = floatBufferB . get ( index * 2 + 0 ) ; B [ index ] . y = floatBufferB . get ( index * 2 + 1 ) ; } } } return checkResult ( status ) ; }


Input: Extended wrapper for arrays of cuDoubleComplex values . Note that this method only exists for convenience and compatibility with native C code . It is much more efficient to provide a Pointer to a double array containing the complex numbers where each pair of consecutive numbers in the array describes the real - and imaginary part of one complex number . [CODESPLIT] public static int cublasSetVector ( int n , cuDoubleComplex x [ ] , int offsetx , int incx , Pointer y , int incy ) { ByteBuffer byteBufferx = ByteBuffer . allocateDirect ( x . length * 8 * 2 ) ; byteBufferx . order ( ByteOrder . nativeOrder ( ) ) ; DoubleBuffer doubleBufferx = byteBufferx . asDoubleBuffer ( ) ; int indexx = offsetx ; for ( int i = 0 ; i < n ; i ++ , indexx += incx ) { doubleBufferx . put ( indexx * 2 + 0 , x [ indexx ] . x ) ; doubleBufferx . put ( indexx * 2 + 1 , x [ indexx ] . y ) ; } return checkResult ( cublasSetVectorNative ( n , 16 , Pointer . to ( doubleBufferx ) . withByteOffset ( offsetx * 8 * 2 ) , incx , y , incy ) ) ; }


Input: Extended wrapper for arrays of cuDoubleComplex values . Note that this method only exists for convenience and compatibility with native C code . It is much more efficient to provide a Pointer to a double array that may store the complex numbers where each pair of consecutive numbers in the array describes the real - and imaginary part of one complex number . [CODESPLIT] public static int cublasGetVector ( int n , Pointer x , int incx , cuDoubleComplex y [ ] , int offsety , int incy ) { ByteBuffer byteBuffery = ByteBuffer . allocateDirect ( y . length * 8 * 2 ) ; byteBuffery . order ( ByteOrder . nativeOrder ( ) ) ; DoubleBuffer doubleBuffery = byteBuffery . asDoubleBuffer ( ) ; int status = cublasGetVectorNative ( n , 16 , x , incx , Pointer . to ( doubleBuffery ) . withByteOffset ( offsety * 8 * 2 ) , incy ) ; if ( status == cublasStatus . CUBLAS_STATUS_SUCCESS ) { doubleBuffery . rewind ( ) ; int indexy = offsety ; for ( int i = 0 ; i < n ; i ++ , indexy += incy ) { y [ indexy ] . x = doubleBuffery . get ( indexy * 2 + 0 ) ; y [ indexy ] . y = doubleBuffery . get ( indexy * 2 + 1 ) ; } } return checkResult ( status ) ; }


Input: Extended wrapper for arrays of cuDoubleComplex values . Note that this method only exists for convenience and compatibility with native C code . It is much more efficient to provide a Pointer to a double array containing the complex numbers where each pair of consecutive numbers in the array describes the real - and imaginary part of one complex number . [CODESPLIT] public static int cublasSetMatrix ( int rows , int cols , cuDoubleComplex A [ ] , int offsetA , int lda , Pointer B , int ldb ) { ByteBuffer byteBufferA = ByteBuffer . allocateDirect ( A . length * 8 * 2 ) ; byteBufferA . order ( ByteOrder . nativeOrder ( ) ) ; DoubleBuffer doubleBufferA = byteBufferA . asDoubleBuffer ( ) ; for ( int i = 0 ; i < A . length ; i ++ ) { doubleBufferA . put ( A [ i ] . x ) ; doubleBufferA . put ( A [ i ] . y ) ; } return checkResult ( cublasSetMatrixNative ( rows , cols , 16 , Pointer . to ( doubleBufferA ) . withByteOffset ( offsetA * 8 * 2 ) , lda , B , ldb ) ) ; }


Input: Extended wrapper for arrays of cuDoubleComplex values . Note that this method only exists for convenience and compatibility with native C code . It is much more efficient to provide a Pointer to a double array that may store the complex numbers where each pair of consecutive numbers in the array describes the real - and imaginary part of one complex number . [CODESPLIT] public static int cublasGetMatrix ( int rows , int cols , Pointer A , int lda , cuDoubleComplex B [ ] , int offsetB , int ldb ) { ByteBuffer byteBufferB = ByteBuffer . allocateDirect ( B . length * 8 * 2 ) ; byteBufferB . order ( ByteOrder . nativeOrder ( ) ) ; DoubleBuffer doubleBufferB = byteBufferB . asDoubleBuffer ( ) ; int status = cublasGetMatrixNative ( rows , cols , 16 , A , lda , Pointer . to ( doubleBufferB ) . withByteOffset ( offsetB * 8 * 2 ) , ldb ) ; if ( status == cublasStatus . CUBLAS_STATUS_SUCCESS ) { doubleBufferB . rewind ( ) ; for ( int c = 0 ; c < cols ; c ++ ) { for ( int r = 0 ; r < rows ; r ++ ) { int index = c * ldb + r + offsetB ; B [ index ] . x = doubleBufferB . get ( index * 2 + 0 ) ; B [ index ] . y = doubleBufferB . get ( index * 2 + 1 ) ; } } } return checkResult ( status ) ; }


Input: Wrapper for CUBLAS function . <pre > void cublasSrotm ( int n float * x int incx float * y int incy const float * sparam ) [CODESPLIT] public static void cublasSrotm ( int n , Pointer x , int incx , Pointer y , int incy , float sparam [ ] ) { cublasSrotmNative ( n , x , incx , y , incy , sparam ) ; checkResultBLAS ( ) ; }


Input: Wrapper for CUBLAS function . <pre > void cublasSrotmg ( float * psd1 float * psd2 float * psx1 const float * psy1 float * sparam ) [CODESPLIT] public static void cublasSrotmg ( float sd1 [ ] , float sd2 [ ] , float sx1 [ ] , float sy1 , float sparam [ ] ) { cublasSrotmgNative ( sd1 , sd2 , sx1 , sy1 , sparam ) ; checkResultBLAS ( ) ; }


Input: Wrapper for CUBLAS function . <pre > void cublasDrotm ( int n double * x int incx double * y int incy const double * sparam ) [CODESPLIT] public static void cublasDrotm ( int n , Pointer x , int incx , Pointer y , int incy , double sparam [ ] ) { cublasDrotmNative ( n , x , incx , y , incy , sparam ) ; checkResultBLAS ( ) ; }


Input: Wrapper for CUBLAS function . <pre > void cublasDrotmg ( double * psd1 double * psd2 double * psx1 const double * psy1 double * sparam ) [CODESPLIT] public static void cublasDrotmg ( double sd1 [ ] , double sd2 [ ] , double sx1 [ ] , double sy1 , double sparam [ ] ) { cublasDrotmgNative ( sd1 , sd2 , sx1 , sy1 , sparam ) ; checkResultBLAS ( ) ; }


Input: <pre > int cublasIsamax ( int n const float * x int incx ) [CODESPLIT] public static int cublasIsamax ( int n , Pointer x , int incx ) { int result = cublasIsamaxNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > int cublasIsamin ( int n const float * x int incx ) [CODESPLIT] public static int cublasIsamin ( int n , Pointer x , int incx ) { int result = cublasIsaminNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > float cublasSasum ( int n const float * x int incx ) [CODESPLIT] public static float cublasSasum ( int n , Pointer x , int incx ) { float result = cublasSasumNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > void cublasSaxpy ( int n float alpha const float * x int incx float * y int incy ) [CODESPLIT] public static void cublasSaxpy ( int n , float alpha , Pointer x , int incx , Pointer y , int incy ) { cublasSaxpyNative ( n , alpha , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasScopy ( int n const float * x int incx float * y int incy ) [CODESPLIT] public static void cublasScopy ( int n , Pointer x , int incx , Pointer y , int incy ) { cublasScopyNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > float cublasSdot ( int n const float * x int incx const float * y int incy ) [CODESPLIT] public static float cublasSdot ( int n , Pointer x , int incx , Pointer y , int incy ) { float result = cublasSdotNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > float cublasSnrm2 ( int n const float * x int incx ) [CODESPLIT] public static float cublasSnrm2 ( int n , Pointer x , int incx ) { float result = cublasSnrm2Native ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > void cublasSrot ( int n float * x int incx float * y int incy float sc float ss ) [CODESPLIT] public static void cublasSrot ( int n , Pointer x , int incx , Pointer y , int incy , float sc , float ss ) { cublasSrotNative ( n , x , incx , y , incy , sc , ss ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSrotg ( float * host_sa float * host_sb float * host_sc float * host_ss ) [CODESPLIT] public static void cublasSrotg ( Pointer host_sa , Pointer host_sb , Pointer host_sc , Pointer host_ss ) { cublasSrotgNative ( host_sa , host_sb , host_sc , host_ss ) ; checkResultBLAS ( ) ; }


Input: <pre > void sscal ( int n float alpha float * x int incx ) [CODESPLIT] public static void cublasSscal ( int n , float alpha , Pointer x , int incx ) { cublasSscalNative ( n , alpha , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSswap ( int n float * x int incx float * y int incy ) [CODESPLIT] public static void cublasSswap ( int n , Pointer x , int incx , Pointer y , int incy ) { cublasSswapNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCaxpy ( int n cuComplex alpha const cuComplex * x int incx cuComplex * y int incy ) [CODESPLIT] public static void cublasCaxpy ( int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy ) { cublasCaxpyNative ( n , alpha , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCcopy ( int n const cuComplex * x int incx cuComplex * y int incy ) [CODESPLIT] public static void cublasCcopy ( int n , Pointer x , int incx , Pointer y , int incy ) { cublasCcopyNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZcopy ( int n const cuDoubleComplex * x int incx cuDoubleComplex * y int incy ) [CODESPLIT] public static void cublasZcopy ( int n , Pointer x , int incx , Pointer y , int incy ) { cublasZcopyNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCscal ( int n cuComplex alpha cuComplex * x int incx ) [CODESPLIT] public static void cublasCscal ( int n , cuComplex alpha , Pointer x , int incx ) { cublasCscalNative ( n , alpha , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCrotg ( cuComplex * host_ca cuComplex cb float * host_sc cuComplex * host_cs ) [CODESPLIT] public static void cublasCrotg ( Pointer host_ca , cuComplex cb , Pointer host_sc , Pointer host_cs ) { cublasCrotgNative ( host_ca , cb , host_sc , host_cs ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCrot ( int n cuComplex * x int incx cuComplex * y int incy float sc cuComplex cs ) [CODESPLIT] public static void cublasCrot ( int n , Pointer x , int incx , Pointer y , int incy , float c , cuComplex s ) { cublasCrotNative ( n , x , incx , y , incy , c , s ) ; checkResultBLAS ( ) ; }


Input: <pre > void csrot ( int n cuComplex * x int incx cuCumplex * y int incy float c float s ) [CODESPLIT] public static void cublasCsrot ( int n , Pointer x , int incx , Pointer y , int incy , float c , float s ) { cublasCsrotNative ( n , x , incx , y , incy , c , s ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCsscal ( int n float alpha cuComplex * x int incx ) [CODESPLIT] public static void cublasCsscal ( int n , float alpha , Pointer x , int incx ) { cublasCsscalNative ( n , alpha , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCswap ( int n const cuComplex * x int incx cuComplex * y int incy ) [CODESPLIT] public static void cublasCswap ( int n , Pointer x , int incx , Pointer y , int incy ) { cublasCswapNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZswap ( int n const cuDoubleComplex * x int incx cuDoubleComplex * y int incy ) [CODESPLIT] public static void cublasZswap ( int n , Pointer x , int incx , Pointer y , int incy ) { cublasZswapNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > cuComplex cdotu ( int n const cuComplex * x int incx const cuComplex * y int incy ) [CODESPLIT] public static cuComplex cublasCdotu ( int n , Pointer x , int incx , Pointer y , int incy ) { cuComplex result = cublasCdotuNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > cuComplex cublasCdotc ( int n const cuComplex * x int incx const cuComplex * y int incy ) [CODESPLIT] public static cuComplex cublasCdotc ( int n , Pointer x , int incx , Pointer y , int incy ) { cuComplex result = cublasCdotcNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > int cublasIcamax ( int n const float * x int incx ) [CODESPLIT] public static int cublasIcamax ( int n , Pointer x , int incx ) { int result = cublasIcamaxNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > int cublasIcamin ( int n const float * x int incx ) [CODESPLIT] public static int cublasIcamin ( int n , Pointer x , int incx ) { int result = cublasIcaminNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > float cublasScasum ( int n const cuDouble * x int incx ) [CODESPLIT] public static float cublasScasum ( int n , Pointer x , int incx ) { float result = cublasScasumNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > float cublasScnrm2 ( int n const cuComplex * x int incx ) [CODESPLIT] public static float cublasScnrm2 ( int n , Pointer x , int incx ) { float result = cublasScnrm2Native ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > void cublasZaxpy ( int n cuDoubleComplex alpha const cuDoubleComplex * x int incx cuDoubleComplex * y int incy ) [CODESPLIT] public static void cublasZaxpy ( int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy ) { cublasZaxpyNative ( n , alpha , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > cuDoubleComplex zdotu ( int n const cuDoubleComplex * x int incx const cuDoubleComplex * y int incy ) [CODESPLIT] public static cuDoubleComplex cublasZdotu ( int n , Pointer x , int incx , Pointer y , int incy ) { cuDoubleComplex result = cublasZdotuNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > cuDoubleComplex cublasZdotc ( int n const cuDoubleComplex * x int incx const cuDoubleComplex * y int incy ) [CODESPLIT] public static cuDoubleComplex cublasZdotc ( int n , Pointer x , int incx , Pointer y , int incy ) { cuDoubleComplex result = cublasZdotcNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > void cublasZscal ( int n cuComplex alpha cuComplex * x int incx ) [CODESPLIT] public static void cublasZscal ( int n , cuDoubleComplex alpha , Pointer x , int incx ) { cublasZscalNative ( n , alpha , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZdscal ( int n double alpha cuDoubleComplex * x int incx ) [CODESPLIT] public static void cublasZdscal ( int n , double alpha , Pointer x , int incx ) { cublasZdscalNative ( n , alpha , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > double cublasDznrm2 ( int n const cuDoubleComplex * x int incx ) [CODESPLIT] public static double cublasDznrm2 ( int n , Pointer x , int incx ) { double result = cublasDznrm2Native ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > void cublasZrotg ( cuDoubleComplex * host_ca cuDoubleComplex cb double * host_sc double * host_cs ) [CODESPLIT] public static void cublasZrotg ( Pointer host_ca , cuDoubleComplex cb , Pointer host_sc , Pointer host_cs ) { cublasZrotgNative ( host_ca , cb , host_sc , host_cs ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasZrot ( int n cuDoubleComplex * x int incx cuDoubleComplex * y int incy double sc cuDoubleComplex cs ) [CODESPLIT] public static void cublasZrot ( int n , Pointer x , int incx , Pointer y , int incy , double sc , cuDoubleComplex cs ) { cublasZrotNative ( n , x , incx , y , incy , sc , cs ) ; checkResultBLAS ( ) ; }


Input: <pre > void zdrot ( int n cuDoubleComplex * x int incx cuCumplex * y int incy double c double s ) [CODESPLIT] public static void cublasZdrot ( int n , Pointer x , int incx , Pointer y , int incy , double c , double s ) { cublasZdrotNative ( n , x , incx , y , incy , c , s ) ; checkResultBLAS ( ) ; }


Input: <pre > int cublasIzamax ( int n const double * x int incx ) [CODESPLIT] public static int cublasIzamax ( int n , Pointer x , int incx ) { int result = cublasIzamaxNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > int cublasIzamin ( int n const cuDoubleComplex * x int incx ) [CODESPLIT] public static int cublasIzamin ( int n , Pointer x , int incx ) { int result = cublasIzaminNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > double cublasDzasum ( int n const cuDoubleComplex * x int incx ) [CODESPLIT] public static double cublasDzasum ( int n , Pointer x , int incx ) { double result = cublasDzasumNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <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 ) [CODESPLIT] 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 ) { cublasSgbmvNative ( trans , m , n , kl , ku , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <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 ) [CODESPLIT] 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 ) { cublasSgemvNative ( trans , m , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasSger ( int m int n float alpha const float * x int incx const float * y int incy float * A int lda ) [CODESPLIT] public static void cublasSger ( int m , int n , float alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasSgerNative ( m , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <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 ) [CODESPLIT] 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 ) { cublasSsbmvNative ( uplo , n , k , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSspmv ( char uplo int n float alpha const float * AP const float * x int incx float beta float * y int incy ) [CODESPLIT] public static void cublasSspmv ( char uplo , int n , float alpha , Pointer AP , Pointer x , int incx , float beta , Pointer y , int incy ) { cublasSspmvNative ( uplo , n , alpha , AP , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSspr ( char uplo int n float alpha const float * x int incx float * AP ) [CODESPLIT] public static void cublasSspr ( char uplo , int n , float alpha , Pointer x , int incx , Pointer AP ) { cublasSsprNative ( uplo , n , alpha , x , incx , AP ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSspr2 ( char uplo int n float alpha const float * x int incx const float * y int incy float * AP ) [CODESPLIT] public static void cublasSspr2 ( char uplo , int n , float alpha , Pointer x , int incx , Pointer y , int incy , Pointer AP ) { cublasSspr2Native ( uplo , n , alpha , x , incx , y , incy , AP ) ; checkResultBLAS ( ) ; }


Input: <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 ) [CODESPLIT] public static void cublasSsymv ( char uplo , int n , float alpha , Pointer A , int lda , Pointer x , int incx , float beta , Pointer y , int incy ) { cublasSsymvNative ( uplo , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSsyr ( char uplo int n float alpha const float * x int incx float * A int lda ) [CODESPLIT] public static void cublasSsyr ( char uplo , int n , float alpha , Pointer x , int incx , Pointer A , int lda ) { cublasSsyrNative ( uplo , n , alpha , x , incx , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSsyr2 ( char uplo int n float alpha const float * x int incx const float * y int incy float * A int lda ) [CODESPLIT] public static void cublasSsyr2 ( char uplo , int n , float alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasSsyr2Native ( uplo , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasStbmv ( char uplo char trans char diag int n int k const float * A int lda float * x int incx ) [CODESPLIT] public static void cublasStbmv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { cublasStbmvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasStbsv ( char uplo char trans char diag int n int k const float * A int lda float * X int incx ) [CODESPLIT] public static void cublasStbsv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { cublasStbsvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasStpmv ( char uplo char trans char diag int n const float * AP float * x int incx ) ; [CODESPLIT] public static void cublasStpmv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { cublasStpmvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasStpsv ( char uplo char trans char diag int n const float * AP float * X int incx ) [CODESPLIT] public static void cublasStpsv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { cublasStpsvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasStrmv ( char uplo char trans char diag int n const float * A int lda float * x int incx ) ; [CODESPLIT] public static void cublasStrmv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { cublasStrmvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasStrsv ( char uplo char trans char diag int n const float * A int lda float * x int incx ) [CODESPLIT] public static void cublasStrsv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { cublasStrsvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZtrmv ( char uplo char trans char diag int n const cuDoubleComplex * A int lda cuDoubleComplex * x int incx ) ; [CODESPLIT] public static void cublasZtrmv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { cublasZtrmvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <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 ) ; [CODESPLIT] 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 ) { cublasZgbmvNative ( trans , m , n , kl , ku , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZtbmv ( char uplo char trans char diag int n int k const cuDoubleComplex * A int lda cuDoubleComplex * x int incx ) [CODESPLIT] public static void cublasZtbmv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { cublasZtbmvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZtbsv ( char uplo char trans char diag int n int k const cuDoubleComplex * A int lda cuDoubleComplex * X int incx ) [CODESPLIT] public static void cublasZtbsv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { cublasZtbsvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZhemv ( char uplo int n cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * x int incx cuDoubleComplex beta cuDoubleComplex * y int incy ) [CODESPLIT] public static void cublasZhemv ( char uplo , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { cublasZhemvNative ( uplo , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZhpmv ( char uplo int n cuDoubleComplex alpha const cuDoubleComplex * AP const cuDoubleComplex * x int incx cuDoubleComplex beta cuDoubleComplex * y int incy ) [CODESPLIT] public static void cublasZhpmv ( char uplo , int n , cuDoubleComplex alpha , Pointer AP , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { cublasZhpmvNative ( uplo , n , alpha , AP , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasZgemv ( char trans int m int n cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * x int incx cuDoubleComplex beta cuDoubleComplex * y int incy ) [CODESPLIT] public static void cublasZgemv ( char trans , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { cublasZgemvNative ( trans , m , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZtpmv ( char uplo char trans char diag int n const cuDoubleComplex * AP cuDoubleComplex * x int incx ) ; [CODESPLIT] public static void cublasZtpmv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { cublasZtpmvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZtpsv ( char uplo char trans char diag int n const cuDoubleComplex * AP cuDoubleComplex * X int incx ) [CODESPLIT] public static void cublasZtpsv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { cublasZtpsvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasCgemv ( char trans int m int n cuComplex alpha const cuComplex * A int lda const cuComplex * x int incx cuComplex beta cuComplex * y int incy ) [CODESPLIT] public static void cublasCgemv ( char trans , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer x , int incx , cuComplex beta , Pointer y , int incy ) { cublasCgemvNative ( trans , m , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCgbmv ( char trans int m int n int kl int ku cuComplex alpha const cuComplex * A int lda const cuComplex * x int incx cuComplex beta cuComplex * y int incy ) ; [CODESPLIT] public static void cublasCgbmv ( char trans , int m , int n , int kl , int ku , cuComplex alpha , Pointer A , int lda , Pointer x , int incx , cuComplex beta , Pointer y , int incy ) { cublasCgbmvNative ( trans , m , n , kl , ku , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasChemv ( char uplo int n cuComplex alpha const cuComplex * A int lda const cuComplex * x int incx cuComplex beta cuComplex * y int incy ) [CODESPLIT] public static void cublasChemv ( char uplo , int n , cuComplex alpha , Pointer A , int lda , Pointer x , int incx , cuComplex beta , Pointer y , int incy ) { cublasChemvNative ( uplo , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasChbmv ( char uplo int n int k cuComplex alpha const cuComplex * A int lda const cuComplex * x int incx cuComplex beta cuComplex * y int incy ) [CODESPLIT] public static void cublasChbmv ( char uplo , int n , int k , cuComplex alpha , Pointer A , int lda , Pointer x , int incx , cuComplex beta , Pointer y , int incy ) { cublasChbmvNative ( uplo , n , k , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > [CODESPLIT] public static void cublasCtrmv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { cublasCtrmvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCtbmv ( char uplo char trans char diag int n int k const cuComplex * A int lda cuComplex * x int incx ) [CODESPLIT] public static void cublasCtbmv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { cublasCtbmvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCtpmv ( char uplo char trans char diag int n const cuComplex * AP cuComplex * x int incx ) ; [CODESPLIT] public static void cublasCtpmv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { cublasCtpmvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCtrsv ( char uplo char trans char diag int n const cuComplex * A int lda cuComplex * x int incx ) [CODESPLIT] public static void cublasCtrsv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { cublasCtrsvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCtbsv ( char uplo char trans char diag int n int k const cuComplex * A int lda cuComplex * X int incx ) [CODESPLIT] public static void cublasCtbsv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { cublasCtbsvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCtpsv ( char uplo char trans char diag int n const cuComplex * AP cuComplex * X int incx ) [CODESPLIT] public static void cublasCtpsv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { cublasCtpsvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasCgeru ( int m int n cuComplex alpha const cuComplex * x int incx const cuComplex * y int incy cuComplex * A int lda ) [CODESPLIT] public static void cublasCgeru ( int m , int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasCgeruNative ( m , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasCgerc ( int m int n cuComplex alpha const cuComplex * x int incx const cuComplex * y int incy cuComplex * A int lda ) [CODESPLIT] public static void cublasCgerc ( int m , int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasCgercNative ( m , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCher ( char uplo int n float alpha const cuComplex * x int incx cuComplex * A int lda ) [CODESPLIT] public static void cublasCher ( char uplo , int n , float alpha , Pointer x , int incx , Pointer A , int lda ) { cublasCherNative ( uplo , n , alpha , x , incx , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasChpr ( char uplo int n float alpha const cuComplex * x int incx cuComplex * AP ) [CODESPLIT] public static void cublasChpr ( char uplo , int n , float alpha , Pointer x , int incx , Pointer AP ) { cublasChprNative ( uplo , n , alpha , x , incx , AP ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasChpr2 ( char uplo int n cuComplex alpha const cuComplex * x int incx const cuComplex * y int incy cuComplex * AP ) [CODESPLIT] public static void cublasChpr2 ( char uplo , int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer AP ) { cublasChpr2Native ( uplo , n , alpha , x , incx , y , incy , AP ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCher2 ( char uplo int n cuComplex alpha const cuComplex * x int incx const cuComplex * y int incy cuComplex * A int lda ) [CODESPLIT] public static void cublasCher2 ( char uplo , int n , cuComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasCher2Native ( uplo , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSgemm ( char transa char transb int m int n int k float alpha const float * A int lda const float * B int ldb float beta float * C int ldc ) [CODESPLIT] public static void cublasSgemm ( char transa , char transb , int m , int n , int k , float alpha , Pointer A , int lda , Pointer B , int ldb , float beta , Pointer C , int ldc ) { cublasSgemmNative ( transa , transb , m , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSsymm ( char side char uplo int m int n float alpha const float * A int lda const float * B int ldb float beta float * C int ldc ) ; [CODESPLIT] public static void cublasSsymm ( char side , char uplo , int m , int n , float alpha , Pointer A , int lda , Pointer B , int ldb , float beta , Pointer C , int ldc ) { cublasSsymmNative ( side , uplo , m , n , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSsyrk ( char uplo char trans int n int k float alpha const float * A int lda float beta float * C int ldc ) [CODESPLIT] public static void cublasSsyrk ( char uplo , char trans , int n , int k , float alpha , Pointer A , int lda , float beta , Pointer C , int ldc ) { cublasSsyrkNative ( uplo , trans , n , k , alpha , A , lda , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasSsyr2k ( char uplo char trans int n int k float alpha const float * A int lda const float * B int ldb float beta float * C int ldc ) [CODESPLIT] public static void cublasSsyr2k ( char uplo , char trans , int n , int k , float alpha , Pointer A , int lda , Pointer B , int ldb , float beta , Pointer C , int ldc ) { cublasSsyr2kNative ( uplo , trans , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasStrmm ( char side char uplo char transa char diag int m int n float alpha const float * A int lda const float * B int ldb ) [CODESPLIT] public static void cublasStrmm ( char side , char uplo , char transa , char diag , int m , int n , float alpha , Pointer A , int lda , Pointer B , int ldb ) { cublasStrmmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasStrsm ( char side char uplo char transa char diag int m int n float alpha const float * A int lda float * B int ldb ) [CODESPLIT] public static void cublasStrsm ( char side , char uplo , char transa , char diag , int m , int n , float alpha , Pointer A , int lda , Pointer B , int ldb ) { cublasStrsmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCgemm ( char transa char transb int m int n int k cuComplex alpha const cuComplex * A int lda const cuComplex * B int ldb cuComplex beta cuComplex * C int ldc ) [CODESPLIT] public static void cublasCgemm ( char transa , char transb , int m , int n , int k , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuComplex beta , Pointer C , int ldc ) { cublasCgemmNative ( transa , transb , m , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCsymm ( char side char uplo int m int n cuComplex alpha const cuComplex * A int lda const cuComplex * B int ldb cuComplex beta cuComplex * C int ldc ) ; [CODESPLIT] public static void cublasCsymm ( char side , char uplo , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuComplex beta , Pointer C , int ldc ) { cublasCsymmNative ( side , uplo , m , n , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasChemm ( char side char uplo int m int n cuComplex alpha const cuComplex * A int lda const cuComplex * B int ldb cuComplex beta cuComplex * C int ldc ) ; [CODESPLIT] public static void cublasChemm ( char side , char uplo , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuComplex beta , Pointer C , int ldc ) { cublasChemmNative ( side , uplo , m , n , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCsyrk ( char uplo char trans int n int k cuComplex alpha const cuComplex * A int lda cuComplex beta cuComplex * C int ldc ) [CODESPLIT] public static void cublasCsyrk ( char uplo , char trans , int n , int k , cuComplex alpha , Pointer A , int lda , cuComplex beta , Pointer C , int ldc ) { cublasCsyrkNative ( uplo , trans , n , k , alpha , A , lda , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCherk ( char uplo char trans int n int k float alpha const cuComplex * A int lda float beta cuComplex * C int ldc ) [CODESPLIT] public static void cublasCherk ( char uplo , char trans , int n , int k , float alpha , Pointer A , int lda , float beta , Pointer C , int ldc ) { cublasCherkNative ( uplo , trans , n , k , alpha , A , lda , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCsyr2k ( char uplo char trans int n int k cuComplex alpha const cuComplex * A int lda const cuComplex * B int ldb cuComplex beta cuComplex * C int ldc ) [CODESPLIT] public static void cublasCsyr2k ( char uplo , char trans , int n , int k , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuComplex beta , Pointer C , int ldc ) { cublasCsyr2kNative ( uplo , trans , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCher2k ( char uplo char trans int n int k cuComplex alpha const cuComplex * A int lda const cuComplex * B int ldb float beta cuComplex * C int ldc ) [CODESPLIT] public static void cublasCher2k ( char uplo , char trans , int n , int k , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb , float beta , Pointer C , int ldc ) { cublasCher2kNative ( uplo , trans , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCtrmm ( char side char uplo char transa char diag int m int n cuComplex alpha const cuComplex * A int lda const cuComplex * B int ldb ) [CODESPLIT] public static void cublasCtrmm ( char side , char uplo , char transa , char diag , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb ) { cublasCtrmmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasCtrsm ( char side char uplo char transa char diag int m int n cuComplex alpha const cuComplex * A int lda cuComplex * B int ldb ) [CODESPLIT] public static void cublasCtrsm ( char side , char uplo , char transa , char diag , int m , int n , cuComplex alpha , Pointer A , int lda , Pointer B , int ldb ) { cublasCtrsmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ; }


Input: <pre > double cublasDasum ( int n const double * x int incx ) [CODESPLIT] public static double cublasDasum ( int n , Pointer x , int incx ) { double result = cublasDasumNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > void cublasDaxpy ( int n double alpha const double * x int incx double * y int incy ) [CODESPLIT] public static void cublasDaxpy ( int n , double alpha , Pointer x , int incx , Pointer y , int incy ) { cublasDaxpyNative ( n , alpha , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDcopy ( int n const double * x int incx double * y int incy ) [CODESPLIT] public static void cublasDcopy ( int n , Pointer x , int incx , Pointer y , int incy ) { cublasDcopyNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > double cublasDdot ( int n const double * x int incx const double * y int incy ) [CODESPLIT] public static double cublasDdot ( int n , Pointer x , int incx , Pointer y , int incy ) { double result = cublasDdotNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > double dnrm2 ( int n const double * x int incx ) [CODESPLIT] public static double cublasDnrm2 ( int n , Pointer x , int incx ) { double result = cublasDnrm2Native ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > void cublasDrot ( int n double * x int incx double * y int incy double sc double ss ) [CODESPLIT] public static void cublasDrot ( int n , Pointer x , int incx , Pointer y , int incy , double sc , double ss ) { cublasDrotNative ( n , x , incx , y , incy , sc , ss ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDrotg ( double * host_sa double * host_sb double * host_sc double * host_ss ) [CODESPLIT] public static void cublasDrotg ( Pointer host_sa , Pointer host_sb , Pointer host_sc , Pointer host_ss ) { cublasDrotgNative ( host_sa , host_sb , host_sc , host_ss ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDscal ( int n double alpha double * x int incx ) [CODESPLIT] public static void cublasDscal ( int n , double alpha , Pointer x , int incx ) { cublasDscalNative ( n , alpha , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDswap ( int n double * x int incx double * y int incy ) [CODESPLIT] public static void cublasDswap ( int n , Pointer x , int incx , Pointer y , int incy ) { cublasDswapNative ( n , x , incx , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > int idamax ( int n const double * x int incx ) [CODESPLIT] public static int cublasIdamax ( int n , Pointer x , int incx ) { int result = cublasIdamaxNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > int idamin ( int n const double * x int incx ) [CODESPLIT] public static int cublasIdamin ( int n , Pointer x , int incx ) { int result = cublasIdaminNative ( n , x , incx ) ; checkResultBLAS ( ) ; return result ; }


Input: <pre > cublasDgemv ( char trans int m int n double alpha const double * A int lda const double * x int incx double beta double * y int incy ) [CODESPLIT] public static void cublasDgemv ( char trans , int m , int n , double alpha , Pointer A , int lda , Pointer x , int incx , double beta , Pointer y , int incy ) { cublasDgemvNative ( trans , m , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasDger ( int m int n double alpha const double * x int incx const double * y int incy double * A int lda ) [CODESPLIT] public static void cublasDger ( int m , int n , double alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasDgerNative ( m , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDsyr ( char uplo int n double alpha const double * x int incx double * A int lda ) [CODESPLIT] public static void cublasDsyr ( char uplo , int n , double alpha , Pointer x , int incx , Pointer A , int lda ) { cublasDsyrNative ( uplo , n , alpha , x , incx , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDsyr2 ( char uplo int n double alpha const double * x int incx const double * y int incy double * A int lda ) [CODESPLIT] public static void cublasDsyr2 ( char uplo , int n , double alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasDsyr2Native ( uplo , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDspr ( char uplo int n double alpha const double * x int incx double * AP ) [CODESPLIT] public static void cublasDspr ( char uplo , int n , double alpha , Pointer x , int incx , Pointer AP ) { cublasDsprNative ( uplo , n , alpha , x , incx , AP ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDspr2 ( char uplo int n double alpha const double * x int incx const double * y int incy double * AP ) [CODESPLIT] public static void cublasDspr2 ( char uplo , int n , double alpha , Pointer x , int incx , Pointer y , int incy , Pointer AP ) { cublasDspr2Native ( uplo , n , alpha , x , incx , y , incy , AP ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDtrsv ( char uplo char trans char diag int n const double * A int lda double * x int incx ) [CODESPLIT] public static void cublasDtrsv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { cublasDtrsvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDtrmv ( char uplo char trans char diag int n const double * A int lda double * x int incx ) ; [CODESPLIT] public static void cublasDtrmv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { cublasDtrmvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDtbmv ( char uplo char trans char diag int n int k const double * A int lda double * x int incx ) [CODESPLIT] public static void cublasDtbmv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { cublasDtbmvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDtpmv ( char uplo char trans char diag int n const double * AP double * x int incx ) ; [CODESPLIT] public static void cublasDtpmv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { cublasDtpmvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDtpsv ( char uplo char trans char diag int n const double * AP double * X int incx ) [CODESPLIT] public static void cublasDtpsv ( char uplo , char trans , char diag , int n , Pointer AP , Pointer x , int incx ) { cublasDtpsvNative ( uplo , trans , diag , n , AP , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDtbsv ( char uplo char trans char diag int n int k const double * A int lda double * X int incx ) [CODESPLIT] public static void cublasDtbsv ( char uplo , char trans , char diag , int n , int k , Pointer A , int lda , Pointer x , int incx ) { cublasDtbsvNative ( uplo , trans , diag , n , k , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDsymv ( char uplo int n double alpha const double * A int lda const double * x int incx double beta double * y int incy ) [CODESPLIT] public static void cublasDsymv ( char uplo , int n , double alpha , Pointer A , int lda , Pointer x , int incx , double beta , Pointer y , int incy ) { cublasDsymvNative ( uplo , n , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDsbmv ( char uplo int n int k double alpha const double * A int lda const double * x int incx double beta double * y int incy ) [CODESPLIT] public static void cublasDsbmv ( char uplo , int n , int k , double alpha , Pointer A , int lda , Pointer x , int incx , double beta , Pointer y , int incy ) { cublasDsbmvNative ( uplo , n , k , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDspmv ( char uplo int n double alpha const double * AP const double * x int incx double beta double * y int incy ) [CODESPLIT] public static void cublasDspmv ( char uplo , int n , double alpha , Pointer AP , Pointer x , int incx , double beta , Pointer y , int incy ) { cublasDspmvNative ( uplo , n , alpha , AP , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDtrsm ( char side char uplo char transa char diag int m int n double alpha const double * A int lda double * B int ldb ) [CODESPLIT] public static void cublasDtrsm ( char side , char uplo , char transa , char diag , int m , int n , double alpha , Pointer A , int lda , Pointer B , int ldb ) { cublasDtrsmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZtrsm ( char side char uplo char transa char diag int m int n cuDoubleComplex alpha const cuDoubleComplex * A int lda cuDoubleComplex * B int ldb ) [CODESPLIT] public static void cublasZtrsm ( char side , char uplo , char transa , char diag , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb ) { cublasZtrsmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDtrmm ( char side char uplo char transa char diag int m int n double alpha const double * A int lda const double * B int ldb ) [CODESPLIT] public static void cublasDtrmm ( char side , char uplo , char transa , char diag , int m , int n , double alpha , Pointer A , int lda , Pointer B , int ldb ) { cublasDtrmmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDsymm ( char side char uplo int m int n double alpha const double * A int lda const double * B int ldb double beta double * C int ldc ) ; [CODESPLIT] public static void cublasDsymm ( char side , char uplo , int m , int n , double alpha , Pointer A , int lda , Pointer B , int ldb , double beta , Pointer C , int ldc ) { cublasDsymmNative ( side , uplo , m , n , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZsymm ( char side char uplo int m int n cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * B int ldb cuDoubleComplex beta cuDoubleComplex * C int ldc ) ; [CODESPLIT] public static void cublasZsymm ( char side , char uplo , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuDoubleComplex beta , Pointer C , int ldc ) { cublasZsymmNative ( side , uplo , m , n , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDsyrk ( char uplo char trans int n int k double alpha const double * A int lda double beta double * C int ldc ) [CODESPLIT] public static void cublasDsyrk ( char uplo , char trans , int n , int k , double alpha , Pointer A , int lda , double beta , Pointer C , int ldc ) { cublasDsyrkNative ( uplo , trans , n , k , alpha , A , lda , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZsyrk ( char uplo char trans int n int k cuDoubleComplex alpha const cuDoubleComplex * A int lda cuDoubleComplex beta cuDoubleComplex * C int ldc ) [CODESPLIT] public static void cublasZsyrk ( char uplo , char trans , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , cuDoubleComplex beta , Pointer C , int ldc ) { cublasZsyrkNative ( uplo , trans , n , k , alpha , A , lda , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZsyr2k ( char uplo char trans int n int k cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * B int ldb cuDoubleComplex beta cuDoubleComplex * C int ldc ) [CODESPLIT] public static void cublasZsyr2k ( char uplo , char trans , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuDoubleComplex beta , Pointer C , int ldc ) { cublasZsyr2kNative ( uplo , trans , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZher2k ( char uplo char trans int n int k cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * B int ldb double beta cuDoubleComplex * C int ldc ) [CODESPLIT] public static void cublasZher2k ( char uplo , char trans , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , double beta , Pointer C , int ldc ) { cublasZher2kNative ( uplo , trans , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZher ( char uplo int n double alpha const cuDoubleComplex * x int incx cuDoubleComplex * A int lda ) [CODESPLIT] public static void cublasZher ( char uplo , int n , double alpha , Pointer x , int incx , Pointer A , int lda ) { cublasZherNative ( uplo , n , alpha , x , incx , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZhpr ( char uplo int n double alpha const cuDoubleComplex * x int incx cuDoubleComplex * AP ) [CODESPLIT] public static void cublasZhpr ( char uplo , int n , double alpha , Pointer x , int incx , Pointer AP ) { cublasZhprNative ( uplo , n , alpha , x , incx , AP ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZhpr2 ( char uplo int n cuDoubleComplex alpha const cuDoubleComplex * x int incx const cuDoubleComplex * y int incy cuDoubleComplex * AP ) [CODESPLIT] public static void cublasZhpr2 ( char uplo , int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer AP ) { cublasZhpr2Native ( uplo , n , alpha , x , incx , y , incy , AP ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZher2 ( char uplo int n cuDoubleComplex alpha const cuDoubleComplex * x int incx const cuDoubleComplex * y int incy cuDoubleComplex * A int lda ) [CODESPLIT] public static void cublasZher2 ( char uplo , int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasZher2Native ( uplo , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasDsyr2k ( char uplo char trans int n int k double alpha const double * A int lda const double * B int ldb double beta double * C int ldc ) [CODESPLIT] public static void cublasDsyr2k ( char uplo , char trans , int n , int k , double alpha , Pointer A , int lda , Pointer B , int ldb , double beta , Pointer C , int ldc ) { cublasDsyr2kNative ( uplo , trans , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZgemm ( char transa char transb int m int n int k cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * B int ldb cuDoubleComplex beta cuDoubleComplex * C int ldc ) [CODESPLIT] public static void cublasZgemm ( char transa , char transb , int m , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuDoubleComplex beta , Pointer C , int ldc ) { cublasZgemmNative ( transa , transb , m , n , k , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZtrmm ( char side char uplo char transa char diag int m int n cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * B int ldb ) [CODESPLIT] public static void cublasZtrmm ( char side , char uplo , char transa , char diag , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb ) { cublasZtrmmNative ( side , uplo , transa , diag , m , n , alpha , A , lda , B , ldb ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasZgeru ( int m int n cuDoubleComplex alpha const cuDoubleComplex * x int incx const cuDoubleComplex * y int incy cuDoubleComplex * A int lda ) [CODESPLIT] public static void cublasZgeru ( int m , int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasZgeruNative ( m , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > cublasZgerc ( int m int n cuDoubleComplex alpha const cuDoubleComplex * x int incx const cuDoubleComplex * y int incy cuDoubleComplex * A int lda ) [CODESPLIT] public static void cublasZgerc ( int m , int n , cuDoubleComplex alpha , Pointer x , int incx , Pointer y , int incy , Pointer A , int lda ) { cublasZgercNative ( m , n , alpha , x , incx , y , incy , A , lda ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZherk ( char uplo char trans int n int k double alpha const cuDoubleComplex * A int lda double beta cuDoubleComplex * C int ldc ) [CODESPLIT] public static void cublasZherk ( char uplo , char trans , int n , int k , double alpha , Pointer A , int lda , double beta , Pointer C , int ldc ) { cublasZherkNative ( uplo , trans , n , k , alpha , A , lda , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZhemm ( char side char uplo int m int n cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * B int ldb cuDoubleComplex beta cuDoubleComplex * C int ldc ) ; [CODESPLIT] public static void cublasZhemm ( char side , char uplo , int m , int n , cuDoubleComplex alpha , Pointer A , int lda , Pointer B , int ldb , cuDoubleComplex beta , Pointer C , int ldc ) { cublasZhemmNative ( side , uplo , m , n , alpha , A , lda , B , ldb , beta , C , ldc ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZtrsv ( char uplo char trans char diag int n const cuDoubleComplex * A int lda cuDoubleComplex * x int incx ) [CODESPLIT] public static void cublasZtrsv ( char uplo , char trans , char diag , int n , Pointer A , int lda , Pointer x , int incx ) { cublasZtrsvNative ( uplo , trans , diag , n , A , lda , x , incx ) ; checkResultBLAS ( ) ; }


Input: <pre > void cublasZhbmv ( char uplo int n int k cuDoubleComplex alpha const cuDoubleComplex * A int lda const cuDoubleComplex * x int incx cuDoubleComplex beta cuDoubleComplex * y int incy ) [CODESPLIT] public static void cublasZhbmv ( char uplo , int n , int k , cuDoubleComplex alpha , Pointer A , int lda , Pointer x , int incx , cuDoubleComplex beta , Pointer y , int incy ) { cublasZhbmvNative ( uplo , n , k , alpha , A , lda , x , incx , beta , y , incy ) ; checkResultBLAS ( ) ; }


Input: tiek pieņemts ka izsaucošā funkcija nodrošina ka vārds tiešām beidzas ar šo galotni . [CODESPLIT] public String stem ( String word ) throws WrongEndingException { if ( ! word . endsWith ( ending ) ) throw new WrongEndingException ( "Gļuks - vārds (" + w rd + "  nebeidzas ar norādīto galotni (" + e d ng + " " ;   return word . substring ( 0 , word . length ( ) - ending . length ( ) ) ; }


Input: / * Returned Lexemes shouldn t be modified to avoid changing recognition of other words! Not cloned due to performance and memory usage concerns . [CODESPLIT] public ArrayList < Lexeme > getEndingLexemes ( String celms ) { return paradigm . getLexemesByStem ( ) . get ( stemID - 1 ) . get ( celms ) ; }


Input: Add one occurrence of one lexeme . [CODESPLIT] public void addLexeme ( int lexemeId ) { int count = 1 ; if ( lexemeFrequency . get ( lexemeId ) != null ) count = lexemeFrequency . get ( lexemeId ) + 1 ; lexemeFrequency . put ( lexemeId , count ) ; }


Input: Add one occurrence of one ending . [CODESPLIT] public void addEnding ( int endingId ) { int count = 1 ; if ( endingFrequency . get ( endingId ) != null ) count = endingFrequency . get ( endingId ) + 1 ; endingFrequency . put ( endingId , count ) ; }


Input: Convert frequency data in XML format . [CODESPLIT] public void toXML ( Writer stream ) throws IOException { stream . write ( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" ) ; stream . write ( "<Statistika>\n" ) ; stream . write ( "<Galotņu_biežums\n");   for ( Entry < Integer , Integer > tuple : endingFrequency . entrySet ( ) ) { stream . write ( " Galotne_" + tuple . getKey ( ) . toString ( ) + "=\"" + tuple . getValue ( ) . toString ( ) + "\"" ) ; } stream . write ( "/>\n" ) ; stream . write ( "<Leksēmu_biežums\n");   for ( Entry < Integer , Integer > tuple : lexemeFrequency . entrySet ( ) ) { stream . write ( " Leksēma_"+ t uple. g etKey( ) . t oString( ) + " =\""+ t uple. g etValue( ) . t oString( ) + " \"") ;  } stream . write ( "/>\n" ) ; stream . write ( "</Statistika>\n" ) ; stream . flush ( ) ; }


Input: Cumulative frequency estimate for given wordform . [CODESPLIT] public double getEstimate ( AttributeValues wordform ) { double estimate = 0.1 ; String endingIdStr = wordform . getValue ( AttributeNames . i_EndingID ) ; int endingId = ( endingIdStr == null ) ? - 1 : Integer . parseInt ( endingIdStr ) ; if ( endingFrequency . get ( endingId ) != null ) estimate += endingFrequency . get ( endingId ) ; String lexemeIdStr = wordform . getValue ( AttributeNames . i_LexemeID ) ; int lexemeId = ( lexemeIdStr == null ) ? - 1 : Integer . parseInt ( lexemeIdStr ) ; if ( lexemeFrequency . get ( lexemeId ) != null ) estimate += lexemeFrequency . get ( lexemeId ) * lexemeWeight ; return estimate ; }


Input: Determine if given char is a whitespace char ( space tab newline ) . [CODESPLIT] public static boolean isSpace ( char c ) { return Character . isWhitespace ( c ) || Character . isISOControl ( c ) || c == ' ' || c == ' ' || c == ' ' || c == ' ' ; }


Input:
/ * Tokenizes the string ( sentence? ) and runs morphoanalysis on each word . [CODESPLIT] public static LinkedList < Word > tokenize ( Analyzer morphoAnalyzer , String chunk ) { LinkedList < Word > tokens = new LinkedList < Word > ( ) ; if ( chunk == null ) return tokens ; Trie automats = morphoAnalyzer . automats ; //bug fix - pievienota beigās whitespace
 String str = chunk + " " ; //workaround dubultapostrofu izvirtībai
 str = str . replaceAll ( "''" , "\u200B''" ) ; // FIXME mēs te mazliet izčakarējam accumulatedWhitespace on Offsetus
 //workaround teikuma beigu saīsinājumiem utt
 str = str . replaceAll ( "([\\p{L}\\d])\\.(\\p{Z})*$" , "$1\u200B.$2" ) ; // FIXME mēs te mazliet izčakarējam accumulatedWhitespace un offsetus
 //        str = str.replaceAll("([\\d])\\.(\\p{Z})*$", "$1\u200B.$2"); // FIXME mēs te mazliet izčakarējam accumulatedWhitespace un offsetus
 // te tiek ciklā doti visi tekstā esošie vārdi uz morfoanalīzi.
 int progress = 0 ; boolean inApostrophes = false ; Status statuss = Status . IN_SPACE ; StringBuilder accumulatedWhitespace = new StringBuilder ( ) ; int lastGoodEnd = 0 ; boolean canEndInNextStep = false ; for ( int i = 0 ; i < str . length ( ) ; i ++ ) { switch ( statuss ) { case IN_SPACE : if ( ! Splitting . isSpace ( str . charAt ( i ) ) ) { if ( str . charAt ( i ) == ' ' ) inApostrophes = true ; automats . reset ( ) ; //atjauno automāta stāvokli
 automats . findNextBranch ( str . charAt ( i ) ) ; //atrod pirmo derīgo zaru
 if ( automats . status ( ) > 0 ) { //pārbauda vai automātā atrada meklēto simbolu
 //ja atrada
 statuss = Status . IN_WORD ; progress = i ; //pārbauda vai ar to var arī virkne beigties
 canEndInNextStep = ( automats . status ( ) == 2 ) ; } else { //ja neatrada, pievieno vienu simbolu un mēģina vēl
 tokens . add ( formToken ( morphoAnalyzer , str , i , i + 1 , accumulatedWhitespace ) ) ; } } else { accumulatedWhitespace . append ( str . charAt ( i ) ) ; } break ; case IN_WORD : //pārbauda vai ir atrastas potenciālās beigas
 if ( canEndInNextStep == true && ( Splitting . isSeparator ( str . charAt ( i ) ) || ! Character . isLetter ( ( i > 0 ? str . charAt ( i - 1 ) : 0 ) ) ) ) { lastGoodEnd = i ; if ( str . charAt ( i ) == ' ' && inApostrophes ) { tokens . add ( formToken ( morphoAnalyzer , str , progress , i , accumulatedWhitespace ) ) ; accumulatedWhitespace = new StringBuilder ( ) ; tokens . add ( formToken ( morphoAnalyzer , str , i , i + 1 , accumulatedWhitespace ) ) ; inApostrophes = false ; statuss = Status . IN_SPACE ; break ; } } canEndInNextStep = false ; //mēģina atrast nākamo simbolu automātā
 if ( automats . findNext ( str . charAt ( i ) ) > 0 ) { //ja atrada
 //pārbauda vai ar to var arī virkne beigties
 if ( automats . status ( ) == 2 ) canEndInNextStep = true ; } else { //ja neatrada, pārbauda vai automāta darbības laikā tika atrasta potenciālā beigu pozīcija
 if ( lastGoodEnd > progress ) { tokens . add ( formToken ( morphoAnalyzer , str , progress , lastGoodEnd , accumulatedWhitespace ) ) ; i = lastGoodEnd - 1 ; statuss = Status . IN_SPACE ; accumulatedWhitespace = new StringBuilder ( ) ; } else { i = progress ; //mēgina atrast nākamo derīgo zaru
 automats . nextBranch ( ) ; automats . findNextBranch ( str . charAt ( i ) ) ; if ( automats . status ( ) > 0 ) { //pārbauda vai atrada meklēto simbolu
 //pārbauda vai ar to var arī virkne beigties
 if ( automats . status ( ) == 2 ) canEndInNextStep = true ; } else { //ja neatrada, pievieno simbolu rezultātam un pēc tam dosies meklēt jauno sākumu
 //vispār šis ir fishy. FIXME
 tokens . add ( formToken ( morphoAnalyzer , str , i , i + 1 , accumulatedWhitespace ) ) ; statuss = Status . IN_SPACE ; accumulatedWhitespace = new StringBuilder ( ) ; } } } break ; } } // for i..
 if ( statuss == Status . IN_WORD ) { tokens . add ( formToken ( morphoAnalyzer , str , progress , str . length ( ) , accumulatedWhitespace ) ) ; } return tokens ; }


Input: * Tokenizes some text ( usually a sentence ) [CODESPLIT] public static LinkedList < Word > tokenize ( Analyzer morphoAnalyzer , String chunk , boolean bruteSplit ) { if ( bruteSplit ) { LinkedList < Word > tokens = new LinkedList < Word > ( ) ; if ( chunk == null ) return tokens ; String [ ] parts_of_string = chunk . trim ( ) . split ( " " ) ; for ( String part : parts_of_string ) { if ( part . length ( ) > 0 ) tokens . add ( ( morphoAnalyzer == null ) ? new Word ( part ) : morphoAnalyzer . analyze ( part ) ) ; } return tokens ; } else { return tokenize ( morphoAnalyzer , chunk ) ; } }


Input:
* Tokenizes a paragraph and splits it into sentences . [CODESPLIT] public static LinkedList < LinkedList < Word > > tokenizeSentences ( Analyzer morphoAnalyzer , String paragraph , int lengthCap ) { LinkedList < LinkedList < Word >> result = new LinkedList < LinkedList < Word > > ( ) ; List < Word > tokens = Splitting . tokenize ( morphoAnalyzer , paragraph ) ; LinkedList < Word > sentence = new LinkedList < Word > ( ) ; for ( Word word : tokens ) { // Teikumu beigas iekšā tiešajā runā - pievelkam pēdiņu klāt
 if ( sentence . size ( ) == 0 ) { if ( ( word . isRecognized ( ) && word . getBestWordform ( ) . getTag ( ) . equalsIgnoreCase ( "zq" ) ) || word . getToken ( ) . equals ( ")" ) ) { // Pārbaudam vai iepriekšējā teikuma beigās ir punkts
 if ( ! result . isEmpty ( ) && ! result . getLast ( ) . isEmpty ( ) ) { String prevtoken = result . getLast ( ) . getLast ( ) . getToken ( ) ; if ( prevtoken . equals ( "." ) || prevtoken . equals ( "!" ) || prevtoken . equals ( "?" ) || prevtoken . equals ( "\"" ) ) { result . getLast ( ) . add ( word ) ; continue ; } } } } sentence . add ( word ) ; if ( Splitting . isChunkCloser ( word ) || // does this token look like end of sentence
 ( sentence . size ( ) >= lengthCap - 5 && ( word . hasAttribute ( AttributeNames . i_PartOfSpeech , AttributeNames . v_Punctuation ) || word . getToken ( ) . startsWith ( "<" ) ) ) || sentence . size ( ) > lengthCap ) { // hard limit
 result . add ( sentence ) ; sentence = new LinkedList < Word > ( ) ; } } if ( ! sentence . isEmpty ( ) ) result . add ( sentence ) ; return result ; }


Input:
/ * public String getDemo () { return this . getValue ( LocījumuDemo ) ; TODO : apskatīt kur lieto un vai vajag } // [CODESPLIT] public void shortDescription ( PrintWriter stream ) { stream . printf ( "%s :\t%s : %s  #%d\n" , token , getTag ( ) , getValue ( AttributeNames . i_Lemma ) , lexeme . getID ( ) ) ; //FIXME - nečeko, vai leksēma nav null
 }


Input: For debugging purposes only . [CODESPLIT] public void longDescription ( PrintStream out ) { out . println ( this . token + ":" ) ; for ( String s : this . attributes . keySet ( ) ) { out . println ( s + "\t" + attributes . get ( s ) ) ; } }


Input: Check if attribute - value structure has attribute matching given attributeValue and if so then set corresponding position in the tag . [CODESPLIT] private static void verifyAndSetKamolsAttribute ( AttributeValues avs , StringBuilder tag , int index , char tagValue , String attribute , String attributeValue ) { if ( avs . isMatchingStrong ( attribute , attributeValue ) ) tag . setCharAt ( index , tagValue ) ; }


Input: Convert internal attribute - value structure to SemTi - Kamols tag . [CODESPLIT] public static String toKamolsMarkup ( AttributeValues avs ) { StringBuilder res = toKamolsMarkup ( avs , defaulti ) ; if ( res . length ( ) < 1 ) return res . toString ( ) ; // if (res.charAt(0) == 'v' && res.charAt(1) == '_') res.setCharAt(1, 'm'); PP 2012.12.07 - nezinu kāpēc tas te ir, bet tas čakarē tagošanu (jo tagsvm.... neatbilst nevienam varēt vai būt verbam) // if (res.charAt(0) == 'p' && res.charAt(6) == '_') res.setCharAt(6, 'n');  // if (res.charAt(0) == 'v' && res.charAt(3) != 'p' && res.charAt(10) == '_')	res.setCharAt(10, 'n'); return res . toString ( ) ; }