Tensor

abstract val dataType: D

abstract def dims: Dims

abstract def storage: Storage[D.Elem]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(coords: Coords): D.Elem

def asDataTyped: Tensor[dataType.type]

This replaces the type parameter with dataType.type this is useful in some cases where we have lost track of the type of D

final def asInstanceOf[T0]: T0

def assertDataType(dt: DataType): Try[Tensor[dt.type]]

def axes: Axes

def axesString: String

def broadcastTo(axes: Axes): Try[Tensor[dataType.type]]

def cast(dest: DataType): Tensor[dest.type]

def chunk(axis: Long, size: Long): Try[Seq[Tensor[dataType.type]]]

def clone(): AnyRef

def closeTo(that: Tensor[dataType.type], error: Float = 1e-5f): Boolean

def convertDataToAxes: Try[Axes]

convert this tensor to a Shape.

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def finalize(): Unit

def foldMap(dest: DataType, reduceAxes: List[Long], keepDims: Boolean)(f: (D.Elem) ⇒ Elem, g: (Elem, Elem) ⇒ Elem): Try[Tensor[dest.type]]

map each element to another type, then use a commutative and associative function to reduce along a set of given dimensions.

final def getClass(): Class[_]

def hashCode(): Int

def indices(axis: Long): Iterable[Long]

final def isInstanceOf[T0]: Boolean

def isNumeric: Boolean

Returns true if this tensor has an OnnxNumber instance available for its data type.

def l1NormTo(that: Tensor[dataType.type]): Double

def map(dest: DataType)(f: (D.Elem) ⇒ Elem): Tensor[dest.type]

def map(f: (D.Elem) ⇒ D.Elem): Tensor[dataType.type]

def max: D.Elem

def maxAxes(axes: Long*): Try[Tensor[dataType.type]]

Get the maximum values along a given axis.

final def ne(arg0: AnyRef): Boolean

def nonZero: Tensor[Int64.type]

This function computes the set of indices of a tensor for which it is non-zero.

final def notify(): Unit

final def notifyAll(): Unit

def rank: Int

def reshape(axes: Axes): Try[Tensor[dataType.type]]

This is equivalent to numpy.reshape(data, axes) the total size is unchanged, this only remaps the addressing of the tensor

def scalar: D.Elem

When called on a scalar (tensor with zero components), returns a scalar value.

def scalars: Iterator[D.Elem]

Iterate over all items in row major order

def select(range: List[AxisRange]): Tensor[dataType.type]

This is like numpy array slicing

def slice(axis: Long, index: Long): Tensor[dataType.type]

Slice along a given axis taking one of the subtensors along that axis

def slices(axis: Long): Seq[(Long, Tensor[dataType.type])]

def squeeze(axis: Long): Option[Tensor[dataType.type]]

def sum: D.Elem

def sumAxes(axes: Long*): Try[Tensor[dataType.type]]

same as numpy.sum discards each axis we sum, reducing the rank by that number of inputs

def sumAxesKeep(sumAxes: Long*): Try[Tensor[dataType.type]]

same as numpy.sum but keep the rank the same: leave 1 sized tensor in the place of the previous summed axis if no axes are given, sum over all axes

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

def toDoc: Doc

def toRowMajor: Tensor[dataType.type]

if the current tensor is not rowmajor, rewrite it to row-major

def toString(): String

def transpose(axes: List[Long]): Try[Tensor[dataType.type]]

Transpose given the permutation list

def transpose(axis1: Long, axis2: Long): Option[Tensor[dataType.type]]

def transposeDefault: Tensor[dataType.type]

Reverse the dimensions.

def unsqueeze(axis: Long): Option[Tensor[dataType.type]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writeInto(output: WritableStorage[D.Elem], start: Long): Long

def writeIntoStream(os: OutputStream)(implicit tb: ToBytes[D.Elem]): Unit