QuantizedTensorUnsupported

abstract def copy(other: Tensor[T]): Tensor[T]

Copy the value of the given tensor to the current.

abstract def dim(): Int

A shortcut of nDimension()

abstract def getTensorNumeric(): TensorNumeric[T]

Return tensor numeric

abstract def getTensorType: TensorType

Return tensor type

abstract def nDimension(): Int

Dimension number of the tensor.

abstract def nElement(): Int

Element number

abstract def set(): Tensor[T]

Shrunk the size of the storage to 0, and also the tensor size

abstract def set(other: Tensor[T]): Tensor[T]

The Tensor is now going to "view" the same storage as the given tensor.

abstract def size(dim: Int): Int

size of the tensor on the given dimension

abstract def size(): Array[Int]

Size of tensor.

abstract def stride(dim: Int): Int

Jumps between elements on the given dimension in the storage.

abstract def stride(): Array[Int]

Jumps between elements on the each dimension in the storage.

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(t: Tensor[T]): Tensor[T]

Multiply a Tensor by another one, return the result in new allocated memory.

def *(s: T): Tensor[T]

multiply all elements of this with value not in place.

def +(t: Tensor[T]): Tensor[T]

Add a Tensor to another one, return the result in new allocated memory.

def +(s: T): Tensor[T]

Add all elements of this with value not in place.

def +(e: Either[Tensor[T], T]): Tensor[T]

def -(t: Tensor[T]): Tensor[T]

Subtract a Tensor from another one, return the result in new allocated memory.

def -(s: T): Tensor[T]

subtract all elements of this with the value not in place.

def /(t: Tensor[T]): Tensor[T]

Divide a Tensor by another one, return the result in new allocated memory.

def /(s: T): Tensor[T]

divide all elements of this with value not in place.

final def ==(arg0: Any): Boolean

def abs(x: Tensor[T]): Tensor[T]

def abs(): Tensor[T]

replaces all elements in-place with the absolute values of the elements of this.

def add(x: Tensor[T], y: Tensor[T]): Tensor[T]

def add(value: T): Tensor[T]

x.add(value) : add value to all elements of x in place.

def add(x: Tensor[T], value: T, y: Tensor[T]): Tensor[T]

z.add(x, value, y) puts the result of x + value * y in z.

def add(y: Tensor[T]): Tensor[T]

accumulates all elements of y into this

def add(value: T, y: Tensor[T]): Tensor[T]

x.add(value,y) multiply-accumulates values of y into x.

def addMultiDimension(t: Tensor[T], dims: Array[Int]): Tensor[T]

view this.tensor and add multiple Dimensions to dim dimension

def addSingletonDimension(t: Tensor[T], dim: Int): Tensor[T]

view this.tensor and add a Singleton Dimension to dim dimension

def addcdiv(value: T, tensor1: Tensor[T], tensor2: Tensor[T]): Tensor[T]

Performs the element-wise division of tensor1 by tensor2, multiply the result by the scalar value and add it to x.

def addcmul(tensor1: Tensor[T], tensor2: Tensor[T]): Tensor[T]

def addcmul(value: T, tensor1: Tensor[T], tensor2: Tensor[T]): Tensor[T]

Performs the element-wise multiplication of tensor1 by tensor2, multiply the result by the scalar value (1 if not present) and add it to x.

def addmm(v1: T, v2: T, mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

res = v1 * res + v2 * mat1*mat2

def addmm(v2: T, mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

res = res + v2 * mat1 * mat2

def addmm(mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

res = res + mat1 * mat2

def addmm(M: Tensor[T], mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

res = M + (mat1*mat2)

def addmm(v1: T, M: Tensor[T], v2: T, mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

Performs a matrix-matrix multiplication between mat1 (2D tensor) and mat2 (2D tensor).

def addmv(alpha: T, mat: Tensor[T], vec2: Tensor[T]): Tensor[T]

res = res + alpha * (mat * vec2)

def addmv(beta: T, alpha: T, mat: Tensor[T], vec2: Tensor[T]): Tensor[T]

res = beta * res + alpha * (mat * vec2)

def addmv(beta: T, vec1: Tensor[T], alpha: T, mat: Tensor[T], vec2: Tensor[T]): Tensor[T]

Performs a matrix-vector multiplication between mat (2D Tensor) and vec2 (1D Tensor) and add it to vec1.

def addr(v1: T, t1: Tensor[T], v2: T, t2: Tensor[T], t3: Tensor[T]): Tensor[T]

Performs the outer-product between vec1 (1D Tensor) and vec2 (1D Tensor).

def addr(v1: T, t1: Tensor[T], v2: T, t2: Tensor[T]): Tensor[T]

def addr(v1: T, t1: Tensor[T], t2: Tensor[T]): Tensor[T]

def addr(t1: Tensor[T], t2: Tensor[T]): Tensor[T]

Performs the outer-product between vec1 (1D tensor) and vec2 (1D tensor).

def almostEqual(other: Tensor[T], delta: Double): Boolean

Compare with other tensor.

def apply(t: Table): Tensor[T]

Subset the tensor by apply the element of the given table to corresponding dimension of the tensor.

def apply(indexes: Array[Int]): T

Query the value on a given index.

def apply(index: Int): Tensor[T]

Query tensor on a given index.

def apply1(func: (T) ⇒ T): Tensor[T]

Apply a function to each element of the tensor and modified it value if it return a double

def applyFun[A](t: Tensor[A], func: (A) ⇒ T)(implicit arg0: ClassTag[A]): Tensor[T]

Apply a function to each element of the tensor t and set each value to self

final def asInstanceOf[T0]: T0

def baddbmm(alpha: T, batch1: Tensor[T], batch2: Tensor[T]): Tensor[T]

res_i = res_i + (alpha * batch1_i * batch2_i)

def baddbmm(beta: T, alpha: T, batch1: Tensor[T], batch2: Tensor[T]): Tensor[T]

res_i = (beta * res_i) + (alpha * batch1_i * batch2_i)

def baddbmm(beta: T, M: Tensor[T], alpha: T, batch1: Tensor[T], batch2: Tensor[T]): Tensor[T]

Perform a batch matrix matrix multiplication of matrices and stored in batch1 and batch2 with batch add.

def bernoulli(p: Double): Tensor[T]

Fill with random value(bernoulli distribution).

def bmm(batch1: Tensor[T], batch2: Tensor[T]): Tensor[T]

res_i = res_i + batch1_i * batch2_i

def cast[D](castTensor: Tensor[D])(implicit arg0: ClassTag[D], ev: TensorNumeric[D]): Tensor[D]

Cast the currenct tensor to a tensor with tensor numeric type D and set cast value to castTensor

def cdiv(x: Tensor[T], y: Tensor[T]): Tensor[T]

Element-wise divide z.cdiv(x, y) means z = x / y

def cdiv(y: Tensor[T]): Tensor[T]

Element-wise divide x.cdiv(y) all elements of x divide all elements of y.

def ceil(): Tensor[T]

Replaces all elements in-place with the ceil result of elements

def clamp(minValue: Double, maxValue: Double): Tensor[T]

def clone(): Tensor[T]

Get a new tensor with same value and different storage

def cmax(x: Tensor[T], y: Tensor[T]): Tensor[T]

stores the element-wise maximum of x and y in z.

def cmax(y: Tensor[T]): Tensor[T]

stores the element-wise maximum of x and y in x.

def cmax(value: T): Tensor[T]

For each elements of the tensor, performs the max operation compared with the given value vector.

def cmin(x: Tensor[T], y: Tensor[T]): Tensor[T]

stores the element-wise maximum of x and y in z.

def cmin(y: Tensor[T]): Tensor[T]

stores the element-wise maximum of x and y in x.

def cmul(x: Tensor[T], y: Tensor[T]): Tensor[T]

Element-wise multiply z.cmul(x, y) equals z = x * y

def cmul(y: Tensor[T]): Tensor[T]

Element-wise multiply x.cmul(y) multiplies all elements of x with corresponding elements of y.

def contiguous(): Tensor[T]

Get a contiguous tensor from current tensor

def conv2(kernel: Tensor[T], vf: Char): Tensor[T]

This function computes 2 dimensional convolution of a single image with a single kernel (2D output).

def diff(other: Tensor[T], count: Int, reverse: Boolean): Boolean

Compare and print differences between two tensors

def digamma(): Tensor[T]

Computes Psi, the derivative of Lgamma (the log of the absolute value of Gamma(x)), element-wise and update the content inplace

def dist(y: Tensor[T], norm: Int): T

Performs the p-norm distance calculation between two tensors

def div(y: Tensor[T]): Tensor[T]

Element-wise divide x.div(y) all elements of x divide all elements of y.

def div(value: T): Tensor[T]

divide all elements of this with value in-place.

def dot(y: Tensor[T]): T

Performs the dot product.

def emptyInstance(): Tensor[T]

return a new empty tensor of the same type

def eq(x: Tensor[T], y: T): Tensor[T]

Implements == operator comparing each element in x with y

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def erf(): Tensor[T]

Computes the reciprocal of this tensor element-wise and update the content inplace

def erfc(): Tensor[T]

Computes the reciprocal of this tensor element-wise and update the content inplace

val errorString: String

def exp(): Tensor[T]

def exp(y: Tensor[T]): Tensor[T]

def expand(sizes: Array[Int]): Tensor[T]

Expanding a tensor allocates new memory, tensor where singleton dimensions can be expanded to multiple ones by setting the stride to 0.

def expandAs(template: Tensor[T]): Tensor[T]

This is equivalent to this.expand(template.size())

def fill(v: T): Tensor[T]

Fill with a given value.

def finalize(): Unit

def floor(): Tensor[T]

Replaces all elements in-place with the floor result of elements

def floor(y: Tensor[T]): Tensor[T]

Populate the given tensor with the floor result of elements

def forceFill(v: Any): Tensor[T]

Fill with a given value.

def gather(dim: Int, index: Tensor[T], src: Tensor[T]): Tensor[T]

change this tensor with values from the original tensor by gathering a number of values from each "row", where the rows are along the dimension dim.

def ge(x: Tensor[T], value: Double): Tensor[T]

Implements >= operator comparing each element in x with value

final def getClass(): Class[_]

def getType(): TensorDataType

return the tensor datatype( DoubleType or FloatType)

def gt(x: Tensor[T], y: Tensor[T]): Tensor[T]

Implements > operator comparing each element in x with y

def hashCode(): Int

def index(dim: Int, index: Tensor[T], y: Tensor[T]): Tensor[T]

Accumulate the elements of tensor into the original tensor by adding to the indices in the order given in index.

def indexAdd(dim: Int, index: Tensor[T], y: Tensor[T]): Tensor[T]

Accumulate the elements of tensor into the original tensor by adding to the indices in the order given in index.

def inv(): Tensor[T]

Computes the reciprocal of this tensor element-wise and update the content inplace

def isContiguous(): Boolean

Check if the tensor is contiguous on the storage

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isSameSizeAs(other: Tensor[_]): Boolean

Check if the size is same with the give tensor

def isScalar: Boolean

def isTable: Boolean

Return false because it's not a Table

def isTensor: Boolean

Return true because it's a Tensor implemented from Activity

def le(x: Tensor[T], y: Tensor[T]): Tensor[T]

Implements <= operator comparing each element in x with y

def log(): Tensor[T]

def log(y: Tensor[T]): Tensor[T]

Replaces all elements in-place with the elements of lnx

def log1p(): Tensor[T]

def log1p(y: Tensor[T]): Tensor[T]

def logGamma(): Tensor[T]

Computes the log of the absolute value of Gamma(x) element-wise, and update the content inplace

def lt(x: Tensor[T], y: Tensor[T]): Tensor[T]

Implements < operator comparing each element in x with y

def map(other: Tensor[T], func: (T, T) ⇒ T): Tensor[T]

Map value of another tensor to corresponding value of current tensor and apply function on the two value and change the value of the current tensor The another tensor should has the same size of the current tensor

def maskedCopy(mask: Tensor[T], y: Tensor[T]): Tensor[T]

Copies the elements of tensor into mask locations of itself.

def maskedFill(mask: Tensor[T], e: T): Tensor[T]

Fills the masked elements of itself with value val

def maskedSelect(mask: Tensor[T], y: Tensor[T]): Tensor[T]

Returns a new Tensor which contains all elements aligned to a 1 in the corresponding mask.

def max(values: Tensor[T], indices: Tensor[T], dim: Int): (Tensor[T], Tensor[T])

performs the max operation over the dimension n

def max(dim: Int): (Tensor[T], Tensor[T])

performs the max operation over the dimension n

def max(): T

returns the single biggest element of x

def mean(dim: Int): Tensor[T]

performs the mean operation over the dimension dim.

def mean(): T

returns the mean of all elements of this.

def min(values: Tensor[T], indices: Tensor[T], dim: Int): (Tensor[T], Tensor[T])

performs the min operation over the dimension n

def min(dim: Int): (Tensor[T], Tensor[T])

performs the min operation over the dimension n

def min(): T

returns the single minimum element of x

def mm(mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

res = mat1*mat2

def mul(x: Tensor[T], value: T): Tensor[T]

put the result of x * value in current tensor

def mul(value: T): Tensor[T]

multiply all elements of this with value in-place.

def mv(mat: Tensor[T], vec2: Tensor[T]): Tensor[T]

res = res + (mat * vec2)

def narrow(dim: Int, index: Int, size: Int): Tensor[T]

Get a subset of the tensor on dim-th dimension.

final def ne(arg0: AnyRef): Boolean

def negative(x: Tensor[T]): Tensor[T]

Computes numerical negative value element-wise.

def norm(value: Int): T

returns the sum of the n-norms on the Tensor x

def norm(y: Tensor[T], value: Int, dim: Int): Tensor[T]

returns the p-norms of the Tensor x computed over the dimension dim.

def notEqualValue(value: Double): Boolean

Element wise inequality between tensor and given value

final def notify(): Unit

final def notifyAll(): Unit

def numNonZeroByRow(): Array[Int]

Count the number of non-zero elements in first dimension.

def pow(n: T): Tensor[T]

def pow(y: Tensor[T], n: T): Tensor[T]

Replaces all elements in-place with the elements of x to the power of n

def prod(x: Tensor[T], dim: Int): Tensor[T]

def prod(): T

returns the product of the elements of this

def rand(lowerBound: Double, upperBound: Double): Tensor[T]

Fill with random value(uniform distribution between [lowerBound, upperBound]) It will change the value of the current tensor and return itself

def rand(): Tensor[T]

Fill with random value(uniform distribution).

def randn(mean: Double, stdv: Double): Tensor[T]

Fill with random value(normal gaussian distribution with the specified mean and stdv).

def randn(): Tensor[T]

Fill with random value(normal gaussian distribution).

def range(xmin: Double, xmax: Double, step: Int): Tensor[T]

resize this tensor size to floor((xmax - xmin) / step) + 1 and set values from xmin to xmax with step (default to 1).

def reduce(dim: Int, result: Tensor[T], reducer: (T, T) ⇒ T): Tensor[T]

Reduce along the given dimension with the given reducer, and copy the result to the result tensor

def repeatTensor(sizes: Array[Int]): Tensor[T]

Repeating a tensor allocates new memory, unless result is provided, in which case its memory is resized.

def reshape(sizes: Array[Int]): Tensor[T]

create a new tensor without any change of the tensor

def resize(size1: Int, size2: Int, size3: Int, size4: Int, size5: Int): QuantizedTensorUnsupported.this.type

def resize(size1: Int, size2: Int, size3: Int, size4: Int): QuantizedTensorUnsupported.this.type

def resize(size1: Int, size2: Int, size3: Int): QuantizedTensorUnsupported.this.type

def resize(size1: Int, size2: Int): QuantizedTensorUnsupported.this.type

def resize(size1: Int): QuantizedTensorUnsupported.this.type

def resize(sizes: Array[Int], strides: Array[Int]): QuantizedTensorUnsupported.this.type

Resize the current tensor to the give shape

def resize(sizes: Array[Int], nElement: Int): Tensor[T]

def resizeAs(src: Tensor[_]): Tensor[T]

Resize the current tensor to the same size of the given tensor.

def save(path: String, overWrite: Boolean): QuantizedTensorUnsupported.this.type

Save the tensor to given path

def scatter(dim: Int, index: Tensor[T], src: Tensor[T]): Tensor[T]

Writes all values from tensor src into this tensor at the specified indices

def select(dim: Int, index: Int): Tensor[T]

Remove the dim-th dimension and return the subset part.

def set(storage: Storage[T], storageOffset: Int, sizes: Array[Int], strides: Array[Int]): Tensor[T]

The Tensor is now going to "view" the given storage, starting at position storageOffset (>=1) with the given dimension sizes and the optional given strides.

def setValue(value: T): QuantizedTensorUnsupported.this.type

Set value for a scalar tensor

def setValue(d1: Int, d2: Int, d3: Int, d4: Int, d5: Int, value: T): QuantizedTensorUnsupported.this.type

def setValue(d1: Int, d2: Int, d3: Int, d4: Int, value: T): QuantizedTensorUnsupported.this.type

def setValue(d1: Int, d2: Int, d3: Int, value: T): QuantizedTensorUnsupported.this.type

def setValue(d1: Int, d2: Int, value: T): QuantizedTensorUnsupported.this.type

def setValue(d1: Int, value: T): QuantizedTensorUnsupported.this.type

Write the value on a given position.

def shallowClone(): Tensor[T]

Get a new tensor with same storage.

def sign(): Tensor[T]

returns a new Tensor with the sign (+/- 1 or 0) of the elements of x.

def split(dim: Int): Array[Tensor[T]]

spilt one tensor into multi tensor along the dim dimension

def split(size: Int, dim: Int): Array[Tensor[T]]

Splits current tensor along dimension dim into a result table of Tensors of size size (a number) or less (in the case of the last Tensor).

def sqrt(y: Tensor[T]): Tensor[T]

def sqrt(): Tensor[T]

replaces all elements in-place with the square root of the elements of this.

def square(): Tensor[T]

Replaces all elements in-place with the elements of x squared

def squeeze(dim: Int): Tensor[T]

Removes given dimensions of the tensor if it's singleton

def squeeze(): Tensor[T]

Removes all singleton dimensions of the tensor

def squeezeNewTensor(): Tensor[T]

Create a new tensor that removes all singleton dimensions of the tensor

def storage(): Storage[T]

Get the storage

def storageOffset(): Int

tensor offset on the storage

def sub(value: T): Tensor[T]

def sub(x: Tensor[T], y: Tensor[T]): Tensor[T]

def sub(y: Tensor[T]): Tensor[T]

subtracts all elements of y from this

def sub(x: Tensor[T], value: T, y: Tensor[T]): Tensor[T]

def sub(value: T, y: Tensor[T]): Tensor[T]

def sum(x: Tensor[T], dim: Int): Tensor[T]

def sum(dim: Int): Tensor[T]

performs the sum operation over the dimension dim

def sum(): T

returns the sum of the elements of this

def sumSquare(): T

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

def t(): Tensor[T]

Shortcut of transpose(1, 2) for 2D tensor

def tanh(y: Tensor[T]): Tensor[T]

def tanh(): Tensor[T]

replaces all elements in-place with the tanh root of the elements of this.

def toArray(): Array[T]

Convert 1D tensor to an array.

def toBreezeMatrix(): DenseMatrix[T]

convert the tensor to BreezeMatrix, the dimension of the tensor need to be 2.

def toBreezeVector(): DenseVector[T]

convert the tensor to BreezeVector, the dimension of the tensor need to be 1.

def toMLlibMatrix(): Matrix

convert the tensor to MLlibMatrix, the dimension of the tensor need to be 2, and tensor need to be continuous.

def toMLlibVector(): Vector

convert the tensor to MLlibVector, the dimension of the tensor need to be 1, and tensor need to be continuous.

def toString(): String

def toTable: Table

def toTensor[D](implicit ev: TensorNumeric[D]): Tensor[D]

def topk(k: Int, dim: Int, increase: Boolean, result: Tensor[T], indices: Tensor[T], sortedResult: Boolean = true): (Tensor[T], Tensor[T])

Get the top k smallest values and their indices.

def transpose(dim1: Int, dim2: Int): Tensor[T]

* Create a new tensor which exchanges the given dimensions of the current tensor

def unary_-(): Tensor[T]

def unfold(dim: Int, size: Int, step: Int): Tensor[T]

Returns a tensor which contains all slices of size @param size in the dimension @param dim.

def uniform(args: T*): T

return pseudo-random numbers, require 0<=args.length<=2 if args.length = 0, return [0, 1) if args.length = 1, return [1, args(0)] or [args(0), 1] if args.length = 2, return [args(0), args(1)]

def update(filter: (T) ⇒ Boolean, value: T): Unit

Update the value meeting the filter criteria with the give value

def update(t: Table, src: Tensor[T]): Unit

Copy the given tensor value to the select subset of the current tensor The element of the given table can be an Int or another Table.

def update(t: Table, value: T): Unit

Fill the select subset of the current tensor with the given value.

def update(indexes: Array[Int], value: T): Unit

Write the value to the value indexed by the given index array

def update(index: Int, src: Tensor[T]): Unit

Copy the give tensor value to the select subset of the current tensor by the given index.

def update(index: Int, value: T): Unit

For tensor(i) = value.

def value(): T

def valueAt(d1: Int, d2: Int, d3: Int, d4: Int, d5: Int): T

def valueAt(d1: Int, d2: Int, d3: Int, d4: Int): T

def valueAt(d1: Int, d2: Int, d3: Int): T

def valueAt(d1: Int, d2: Int): T

def valueAt(d1: Int): T

Query the value on a given position.

def view(sizes: Array[Int]): Tensor[T]

def view(sizes: Int*): Tensor[T]

Return a new tensor with specified sizes.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def xcorr2(kernel: Tensor[T], vf: Char): Tensor[T]

This function operates with same options and input/output configurations as conv2, but performs cross-correlation of the input with the kernel k.

def zero(): Tensor[T]

Fill with zero.

def zipWith[A, B](t1: Tensor[A], t2: Tensor[B], func: (A, B) ⇒ T)(implicit arg0: ClassTag[A], arg1: ClassTag[B]): Tensor[T]

Zip values of two other tensors with applying the function func on each two values element-wisely and assign the result value to the current tensor