Codota Logo
JCublas.cublasSetVectorNative
Code IndexAdd Codota to your IDE (free)

How to use
cublasSetVectorNative
method
in
jcuda.jcublas.JCublas

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

  • Add the Codota plugin to your IDE and get smart completions
private void myMethod () {
Gson g =
  • Codota Iconnew Gson()
  • Codota IconGsonBuilder gsonBuilder;gsonBuilder.create()
  • Codota Iconnew GsonBuilder().create()
  • Smart code suggestions by Codota
}
origin: org.scalanlp/jcublas

/**
 * 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));
}
origin: org.jcuda/jcublas

/**
 * 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));
}
origin: org.nd4j/nd4j-jcublas-common

/**
 * 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));
}
origin: org.nd4j/jcublas

/**
 * 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));
}
origin: org.nd4j/jcublas-windows64

/**
 * 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));
}
origin: org.nd4j/jcublas-osx

/**
 * 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
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 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));
}
jcuda.jcublasJCublascublasSetVectorNative

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

  • Making http post requests using okhttp
  • startActivity (Activity)
  • getApplicationContext (Context)
  • scheduleAtFixedRate (ScheduledExecutorService)
    Creates and executes a periodic action that becomes enabled first after the given initial delay, and
  • Pointer (com.sun.jna)
    An abstraction for a native pointer data type. A Pointer instance represents, on the Java side, a na
  • Runnable (java.lang)
    Represents a command that can be executed. Often used to run code in a different Thread.
  • Connection (java.sql)
    A connection represents a link from a Java application to a database. All SQL statements and results
  • DecimalFormat (java.text)
    DecimalFormat is a concrete subclass ofNumberFormat that formats decimal numbers. It has a variety o
  • 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
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now