Tensors

abstract def acquireCommandQueue: Do[CommandQueue]

abstract val deviceIds: Seq[DeviceId]

implicit abstract val executionContext: ExecutionContext

abstract def handleOpenCLNotification(errorInfo: String, privateInfo: Option[ByteBuffer]): Unit

abstract def hashSourceCode: Fastring

abstract val logger: Logger

abstract val platformId: PlatformId

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Tensors, B)

final def ==(arg0: Any): Boolean

object PlusPrograms extends MonoidPrograms

object Tensor

def allocateBuffer[Element](size: Long)(implicit memory: Memory[Element]): Do[DeviceBuffer[Element]]

Returns an uninitialized buffer of Element on device.

def allocateBufferFrom[Element, HostBuffer](hostBuffer: HostBuffer)(implicit memory: Aux[Element, HostBuffer]): Do[DeviceBuffer[Element]]

Returns a buffer of Element on device whose content is copied from hostBuffer.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

lazy val context: Long

def createCommandQueue(deviceId: DeviceId, properties: Map[Int, Long]): CommandQueue

def createKernel(program: Program): Kernel

Creates single kernel from this Program.

def createKernels(program: Program): Seq[Kernel]

def createProgramWithSource(sourceCode: TraversableOnce[CharSequence]): Program

lazy val deviceCapabilities: (DeviceId) ⇒ CLCapabilities

def dispatch(command: (CommandQueue) ⇒ Do[Event]): Do[Event]

def enqueueReadBuffer[Element, Destination](commandQueue: CommandQueue, deviceBuffer: DeviceBuffer[Element], hostBuffer: Destination, preconditionEvents: Event*)(implicit memory: Aux[Element, Destination]): Do[Event]

def ensuring(cond: (Tensors) ⇒ Boolean, msg: ⇒ Any): Tensors

def ensuring(cond: (Tensors) ⇒ Boolean): Tensors

def ensuring(cond: Boolean, msg: ⇒ Any): Tensors

def ensuring(cond: Boolean): Tensors

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

val kernelCache: Cache[(trees)#ValueTerm, CompiledKernel]

def kernelCacheBuilder: CacheBuilder[(trees)#ValueTerm, CompiledKernel]

def monadicClose: UnitContinuation[Unit]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def openclCompilerFlags: String

lazy val platformCapabilities: CLCapabilities

def platformIds: Seq[PlatformId]

def releaseContext: UnitContinuation[Unit]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

val trees: AllTrees with MemoryTrees with StructuralTrees { type Category = com.thoughtworks.compute.Expressions.Tuples with com.thoughtworks.compute.Expressions.Floats with com.thoughtworks.compute.Expressions.Arrays }

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def waitForStatus(event: Event, callbackType: Status): UnitContinuation[Status]

def →[B](y: B): (Tensors, B)