jcuda.jcublas.JCublas.cublasSetVectorNative 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 Tabnine
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasSetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in CPU memory space to a vector y
 * in GPU memory space. Elements in both vectors are assumed to have a
 * size of elemSize bytes. Storage spacing between consecutive elements
 * is incx for the source vector x and incy for the destination vector
 * y. In general, y points to an object, or part of an object, allocated
 * via cublasAlloc(). Column major format for two-dimensional matrices
 * is assumed throughout CUBLAS. Therefore, if the increment for a vector
 * is equal to 1, this access a column vector while using an increment
 * equal to the leading dimension of the respective matrix accesses a
 * row vector.<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetVector(int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
 return checkResult(cublasSetVectorNative(n, elemSize, x, incx, y, incy));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasSetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in CPU memory space to a vector y
 * in GPU memory space. Elements in both vectors are assumed to have a
 * size of elemSize bytes. Storage spacing between consecutive elements
 * is incx for the source vector x and incy for the destination vector
 * y. In general, y points to an object, or part of an object, allocated
 * via cublasAlloc(). Column major format for two-dimensional matrices
 * is assumed throughout CUBLAS. Therefore, if the increment for a vector
 * is equal to 1, this access a column vector while using an increment
 * equal to the leading dimension of the respective matrix accesses a
 * row vector.<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetVector(int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasSetVectorNative(n, elemSize, x, incx, y, incy));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasSetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in CPU memory space to a vector y
 * in GPU memory space. Elements in both vectors are assumed to have a
 * size of elemSize bytes. Storage spacing between consecutive elements
 * is incx for the source vector x and incy for the destination vector
 * y. In general, y points to an object, or part of an object, allocated
 * via cublasAlloc(). Column major format for two-dimensional matrices
 * is assumed throughout CUBLAS. Therefore, if the increment for a vector
 * is equal to 1, this access a column vector while using an increment
 * equal to the leading dimension of the respective matrix accesses a
 * row vector.<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetVector(int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasSetVectorNative(n, elemSize, x, incx, y, incy));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasSetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in CPU memory space to a vector y
 * in GPU memory space. Elements in both vectors are assumed to have a
 * size of elemSize bytes. Storage spacing between consecutive elements
 * is incx for the source vector x and incy for the destination vector
 * y. In general, y points to an object, or part of an object, allocated
 * via cublasAlloc(). Column major format for two-dimensional matrices
 * is assumed throughout CUBLAS. Therefore, if the increment for a vector
 * is equal to 1, this access a column vector while using an increment
 * equal to the leading dimension of the respective matrix accesses a
 * row vector.<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetVector(int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasSetVectorNative(n, elemSize, x, incx, y, incy));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasSetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in CPU memory space to a vector y
 * in GPU memory space. Elements in both vectors are assumed to have a
 * size of elemSize bytes. Storage spacing between consecutive elements
 * is incx for the source vector x and incy for the destination vector
 * y. In general, y points to an object, or part of an object, allocated
 * via cublasAlloc(). Column major format for two-dimensional matrices
 * is assumed throughout CUBLAS. Therefore, if the increment for a vector
 * is equal to 1, this access a column vector while using an increment
 * equal to the leading dimension of the respective matrix accesses a
 * row vector.<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetVector(int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasSetVectorNative(n, elemSize, x, incx, y, incy));
}

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasSetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in CPU memory space to a vector y
 * in GPU memory space. Elements in both vectors are assumed to have a
 * size of elemSize bytes. Storage spacing between consecutive elements
 * is incx for the source vector x and incy for the destination vector
 * y. In general, y points to an object, or part of an object, allocated
 * via cublasAlloc(). Column major format for two-dimensional matrices
 * is assumed throughout CUBLAS. Therefore, if the increment for a vector
 * is equal to 1, this access a column vector while using an increment
 * equal to the leading dimension of the respective matrix accesses a
 * row vector.<br />
 *<br />
 * Return Values<br />
 * -------------<br />
 * CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library not been initialized<br />
 * CUBLAS_STATUS_INVALID_VALUE    if incx, incy, or elemSize <= 0<br />
 * CUBLAS_STATUS_MAPPING_ERROR    if an error occurred accessing GPU memory<br />
 * CUBLAS_STATUS_SUCCESS          if the operation completed successfully<br />
 */
public static int cublasSetVector(int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasSetVectorNative(n, elemSize, x, incx, y, incy));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, jcuda.Pointer, int, jcuda.Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, jcuda.Pointer, int, jcuda.Pointer, int)
 */
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));
}

/**
 * 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#cublasSetVector(int, int, Pointer, int, Pointer, int)
 */
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));
}

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

Reading from database using SQL prepared statement
startActivity (Activity)
getSharedPreferences (Context)
getResourceAsStream (ClassLoader)
Selector (java.nio.channels)
A controller for the selection of SelectableChannel objects. Selectable channels can be registered w
KeyStore (java.security)
KeyStore is responsible for maintaining cryptographic keys and their owners. The type of the syste
NumberFormat (java.text)
The abstract base class for all number formats. This class provides the interface for formatting and
BlockingQueue (java.util.concurrent)
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
Modifier (javassist)
The Modifier class provides static methods and constants to decode class and member access modifiers
HttpServletRequest (javax.servlet.http)
Extends the javax.servlet.ServletRequest interface to provide request information for HTTP servlets.
Top 12 Jupyter Notebook Extensions

How to use cublasSetVectorNativemethodin jcuda.jcublas.JCublas

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

How to use
cublasSetVectorNative
method
in
jcuda.jcublas.JCublas