congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
JCublas.cublasGetVectorNative
Code IndexAdd Tabnine to your IDE (free)

How to use
cublasGetVectorNative
method
in
jcuda.jcublas.JCublas

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

origin: org.nd4j/jcublas-windows64

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasGetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in GPU memory space to a vector y
 * in CPU 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, x 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 cublasGetVector (int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasGetVectorNative(n, elemSize, x, incx, y, incy));
}
origin: org.jcuda/jcublas

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasGetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in GPU memory space to a vector y
 * in CPU 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, x 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 cublasGetVector (int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasGetVectorNative(n, elemSize, x, incx, y, incy));
}
origin: org.scalanlp/jcublas

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasGetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in GPU memory space to a vector y
 * in CPU 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, x 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 cublasGetVector (int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
 return checkResult(cublasGetVectorNative(n, elemSize, x, incx, y, incy));
}
origin: org.nd4j/nd4j-jcublas-common

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasGetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in GPU memory space to a vector y
 * in CPU 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, x 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 cublasGetVector (int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasGetVectorNative(n, elemSize, x, incx, y, incy));
}
origin: org.nd4j/jcublas

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasGetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in GPU memory space to a vector y
 * in CPU 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, x 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 cublasGetVector (int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasGetVectorNative(n, elemSize, x, incx, y, incy));
}
origin: org.nd4j/jcublas-osx

/**
 * Wrapper for CUBLAS function.<br />
 * <br />
 * cublasStatus<br />
 * cublasGetVector (int n, int elemSize, const void *x, int incx,
 *                  void *y, int incy)<br />
 *<br />
 * copies n elements from a vector x in GPU memory space to a vector y
 * in CPU 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, x 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 cublasGetVector (int n, int elemSize, Pointer x, int incx, Pointer y, int incy)
{
  return checkResult(cublasGetVectorNative(n, elemSize, x, incx, y, incy));
}
origin: org.nd4j/jcublas-osx

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.nd4j/jcublas-windows64

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

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.nd4j/nd4j-jcublas-common

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.nd4j/jcublas

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.nd4j/jcublas-windows64

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

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.nd4j/nd4j-jcublas-common

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.nd4j/jcublas

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.scalanlp/jcublas

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.nd4j/jcublas-osx

/**
 * 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.
 *
 * @see JCublas#cublasGetVector(int, int, Pointer, int, Pointer, int)
 */
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);
}
origin: org.scalanlp/jcublas

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

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
  • cublasCgercNative,
  • cublasCgeruNative,
  • cublasChbmvNative,
  • cublasChemmNative,
  • cublasChemvNative,
  • cublasCher2Native,
  • cublasCher2kNative,
  • cublasCherNative,
  • cublasCherkNative,
  • cublasChpr2Native

Popular in Java

  • Reactive rest calls using spring rest template
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • getApplicationContext (Context)
  • scheduleAtFixedRate (ScheduledExecutorService)
  • Connection (java.sql)
    A connection represents a link from a Java application to a database. All SQL statements and results
  • Properties (java.util)
    A Properties object is a Hashtable where the keys and values must be Strings. Each property can have
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • StringUtils (org.apache.commons.lang)
    Operations on java.lang.String that arenull safe. * IsEmpty/IsBlank - checks if a String contains
  • SAXParseException (org.xml.sax)
    Encapsulate an XML parse error or warning.> This module, both source code and documentation, is in t
  • Option (scala)
  • Github Copilot alternatives
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now