jcuda.jcublas.JCublas.cublasSetMatrixNative java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Gson g =new Gson()
GsonBuilder gsonBuilder;gsonBuilder.create()
new GsonBuilder().create()
Smart code suggestions by Codota
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus
 * cublasSetMatrix (int rows, int cols, int elemSize, const void *A,
 *                  int lda, void *B, int ldb)<br />
 *<br />
 * copies a tile of rows x cols elements from a matrix A in CPU memory
 * space to a matrix B in GPU memory space. Each element requires storage
 * of elemSize bytes. Both matrices are assumed to be stored in column
 * major format, with the leading dimension (i.e. number of rows) of
 * source matrix A provided in lda, and the leading dimension of matrix B
 * provided in ldb. In general, B points to an object, or part of an
 * object, that was allocated via cublasAlloc().<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or
 *                                ldb <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetMatrix (int rows, int cols, int elemSize, Pointer A, int lda, Pointer B, int ldb)
{
  return checkResult(cublasSetMatrixNative(rows, elemSize, cols, A, lda, B, ldb));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus
 * cublasSetMatrix (int rows, int cols, int elemSize, const void *A,
 *                  int lda, void *B, int ldb)<br />
 *<br />
 * copies a tile of rows x cols elements from a matrix A in CPU memory
 * space to a matrix B in GPU memory space. Each element requires storage
 * of elemSize bytes. Both matrices are assumed to be stored in column
 * major format, with the leading dimension (i.e. number of rows) of
 * source matrix A provided in lda, and the leading dimension of matrix B
 * provided in ldb. In general, B points to an object, or part of an
 * object, that was allocated via cublasAlloc().<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or
 *                                ldb <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetMatrix (int rows, int cols, int elemSize, Pointer A, int lda, Pointer B, int ldb)
{
  return checkResult(cublasSetMatrixNative(rows, elemSize, cols, A, lda, B, ldb));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus
 * cublasSetMatrix (int rows, int cols, int elemSize, const void *A,
 *                  int lda, void *B, int ldb)<br />
 *<br />
 * copies a tile of rows x cols elements from a matrix A in CPU memory
 * space to a matrix B in GPU memory space. Each element requires storage
 * of elemSize bytes. Both matrices are assumed to be stored in column
 * major format, with the leading dimension (i.e. number of rows) of
 * source matrix A provided in lda, and the leading dimension of matrix B
 * provided in ldb. In general, B points to an object, or part of an
 * object, that was allocated via cublasAlloc().<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or
 *                                ldb <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetMatrix (int rows, int cols, int elemSize, Pointer A, int lda, Pointer B, int ldb)
{
  return checkResult(cublasSetMatrixNative(rows, elemSize, cols, A, lda, B, ldb));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus
 * cublasSetMatrix (int rows, int cols, int elemSize, const void *A,
 *                  int lda, void *B, int ldb)<br />
 *<br />
 * copies a tile of rows x cols elements from a matrix A in CPU memory
 * space to a matrix B in GPU memory space. Each element requires storage
 * of elemSize bytes. Both matrices are assumed to be stored in column
 * major format, with the leading dimension (i.e. number of rows) of
 * source matrix A provided in lda, and the leading dimension of matrix B
 * provided in ldb. In general, B points to an object, or part of an
 * object, that was allocated via cublasAlloc().<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or
 *                                ldb <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetMatrix (int rows, int cols, int elemSize, Pointer A, int lda, Pointer B, int ldb)
{
  return checkResult(cublasSetMatrixNative(rows, elemSize, cols, A, lda, B, ldb));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus
 * cublasSetMatrix (int rows, int cols, int elemSize, const void *A,
 *                  int lda, void *B, int ldb)<br />
 *<br />
 * copies a tile of rows x cols elements from a matrix A in CPU memory
 * space to a matrix B in GPU memory space. Each element requires storage
 * of elemSize bytes. Both matrices are assumed to be stored in column
 * major format, with the leading dimension (i.e. number of rows) of
 * source matrix A provided in lda, and the leading dimension of matrix B
 * provided in ldb. In general, B points to an object, or part of an
 * object, that was allocated via cublasAlloc().<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or
 *                                ldb <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetMatrix (int rows, int cols, int elemSize, Pointer A, int lda, Pointer B, int ldb)
{
 return checkResult(cublasSetMatrixNative(rows, elemSize, cols, A, lda, B, ldb));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus
 * cublasSetMatrix (int rows, int cols, int elemSize, const void *A,
 *                  int lda, void *B, int ldb)<br />
 *<br />
 * copies a tile of rows x cols elements from a matrix A in CPU memory
 * space to a matrix B in GPU memory space. Each element requires storage
 * of elemSize bytes. Both matrices are assumed to be stored in column
 * major format, with the leading dimension (i.e. number of rows) of
 * source matrix A provided in lda, and the leading dimension of matrix B
 * provided in ldb. In general, B points to an object, or part of an
 * object, that was allocated via cublasAlloc().<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if rows or cols < 0, or elemSize, lda, or
 *                                ldb <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetMatrix (int rows, int cols, int elemSize, Pointer A, int lda, Pointer B, int ldb)
{
  return checkResult(cublasSetMatrixNative(rows, elemSize, cols, A, lda, B, ldb));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see jcuda.jcublas.JCublas#cublasSetMatrix(int, int, int, jcuda.Pointer, int, jcuda.Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see jcuda.jcublas.JCublas#cublasSetMatrix(int, int, int, jcuda.Pointer, int, jcuda.Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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.
 *
 * @see JCublas#cublasSetMatrix(int, int, int, Pointer, int, Pointer, int)
 */
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));
}

Popular methods of JCublas

checkResult
If the given result is different to cublasStatus.CUBLAS_STATUS_SUCCESS and exceptions have been enab
checkResultBLAS
Obtain the current CUBLAS status by calling cublasGetErrorNative, and store the result as the lastRe
cublasAllocNative
cublasCaxpyNative
cublasCcopyNative
cublasCdotcNative
cublasCdotuNative
cublasCgbmvNative
cublasCgemmNative
cublasCgemvNative
cublasCgercNative
cublasCgeruNative

Popular in Java

Parsing JSON documents to java classes using gson
getContentResolver (Context)
getApplicationContext (Context)
getSystemService (Context)
SQLException (java.sql)
An exception that indicates a failed JDBC operation. It provides the following information about pro
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
LinkedList (java.util)
Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
JLabel (javax.swing)
SAXParseException (org.xml.sax)
Encapsulate an XML parse error or warning.This exception may include information for locating the er

How to use cublasSetMatrixNativemethodin jcuda.jcublas.JCublas

Best Java code snippets using jcuda.jcublas.JCublas.cublasSetMatrixNative (Showing top 18 results out of 315)

How to use
cublasSetMatrixNative
method
in
jcuda.jcublas.JCublas