bigdl-SPARK_3.0 0.12.0 API - com.intel.analytics.bigdl.tensor.DnnTensor.DnnTensorUnsupportOperations

final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

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

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

Multiply a Tensor by another one, return the result in new allocated memory. The number of elements in the Tensors must match, but the sizes do not matter. The size of the returned Tensor will be the size of the first Tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

multiply all elements of this with value not in place.

multiply all elements of this with value not in place. It will allocate new memory.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Add a Tensor to another one, return the result in new allocated memory. The number of elements in the Tensors must match, but the sizes do not matter. The size of the returned Tensor will be the size of the first Tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Add all elements of this with value not in place.

Add all elements of this with value not in place. It will allocate new memory.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: TensorMath

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

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

Subtract a Tensor from another one, return the result in new allocated memory. The number of elements in the Tensors must match, but the sizes do not matter. The size of the returned Tensor will be the size of the first Tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

subtract all elements of this with the value not in place. It will allocate new memory.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Divide a Tensor by another one, return the result in new allocated memory. The number of elements in the Tensors must match, but the sizes do not matter. The size of the returned Tensor will be the size of the first Tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

divide all elements of this with value not in place.

divide all elements of this with value not in place. It will allocate new memory.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def abs(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

accumulates all elements of y into this

y: other tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

value: scalar
y: other tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

view this.tensor and add multiple Dimensions to dim dimension

t: source tensor
returns: this

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

t: source tensor
dim: the specific dimension, default is 1
returns: this

Definition Classes: DnnTensorUnsupportOperations → Tensor

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.

Performs the element-wise division of tensor1 by tensor2, multiply the result by the scalar value and add it to x. The number of elements must match, but sizes do not matter.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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.

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. The number of elements must match, but sizes do not matter.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

res = v1 * res + v2 * mat1*mat2

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

res = res + v2 * mat1 * mat2

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

res = res + mat1 * mat2

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

res = M + (mat1*mat2)

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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).

Performs a matrix-matrix multiplication between mat1 (2D tensor) and mat2 (2D tensor). Optional values v1 and v2 are scalars that multiply M and mat1 * mat2 respectively. Optional value beta is a scalar that scales the result tensor, before accumulating the result into the tensor. Defaults to 1.0. If mat1 is a n x m matrix, mat2 a m x p matrix, M must be a n x p matrix.

res = (v1 * M) + (v2 * mat1*mat2)

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

res = res + alpha * (mat * vec2)

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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.

Performs a matrix-vector multiplication between mat (2D Tensor) and vec2 (1D Tensor) and add it to vec1. Optional values v1 and v2 are scalars that multiply vec1 and vec2 respectively.

In other words, res = (beta * vec1) + alpha * (mat * vec2)

Sizes must respect the matrix-multiplication operation: if mat is a n × m matrix, vec2 must be vector of size m and vec1 must be a vector of size n.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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).

Performs the outer-product between vec1 (1D Tensor) and vec2 (1D Tensor). Optional values v1 and v2 are scalars that multiply mat and vec1 [out] vec2 respectively. In other words,res_ij = (v1 * mat_ij) + (v2 * vec1_i * vec2_j)

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Performs the outer-product between vec1 (1D tensor) and vec2 (1D tensor). Optional values v1 and v2 are scalars that multiply mat and vec1 [out] vec2 respectively. In other words, res_ij = (v1 * mat_ij) + (v2 * vec1_i * vec2_j)

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Compare with other tensor.

Compare with other tensor. The shape of the other tensor must be same with this tensor. If element wise difference is less than delta, return true.

Definition Classes: Tensor

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

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

Subset the tensor by apply the elements of the given table to the corresponding dimension of the tensor. The elements of the given table can be an Int or another Table. An Int means select on current dimension; A table means narrow on current dimension, the table should have two elements, of which the first is the start index and the second is the end index. An empty table is equal to Table(1, size_of_current_dimension) If the table length is less than the tensor dimension, each missing dimension is token up by an empty table

t: The table length should be less than or equal to the tensor dimensions

Definition Classes: DnnTensorUnsupportOperations → Tensor
See also: select
narrow

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

Query the value on a given index.

Query the value on a given index. Tensor should not be empty

indexes: the indexes length should be same as the tensor dimension length and each value count from 1
returns: the value on the given index

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Query tensor on a given index.

Query tensor on a given index. Tensor should not be empty

index: count from 1

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

func: applied function
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

t: tensor to be modified
func: applied function
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

final def asInstanceOf[T0]: T0

Definition Classes: Any

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

res_i = res_i + (alpha * batch1_i * batch2_i)

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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.

Perform a batch matrix matrix multiplication of matrices and stored in batch1 and batch2 with batch add. batch1 and batch2 must be 3D Tensors each containing the same number of matrices. If batch1 is a b × n × m Tensor, batch2 a b × m × p Tensor, res will be a b × n × p Tensor.

In other words, res_i = (beta * M_i) + (alpha * batch1_i * batch2_i)

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Fill with random value(bernoulli distribution).

Fill with random value(bernoulli distribution). It will change the value of the current tensor and return itself

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

res_i = res_i + batch1_i * batch2_i

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

D: new numeric type
castTensor: the cast value set to this tensor
returns: return castTensort

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

x: tensor
y: tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

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

y: tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def ceil(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def clamp(min: Double, max: Double): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def clone(): Tensor[T]

Get a new tensor with same value and different storage

returns: new tensor

Definition Classes: Tensor → AnyRef

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

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

stores the element-wise maximum of x and y in z. z.cmax(x, y) means z = max(x, y)

x: tensor
y: tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

stores the element-wise maximum of x and y in x. x.cmax(y) = max(x, y)

y: tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

stores the element-wise maximum of x and y in z. z.cmin(x, y) means z = min(x, y)

x: tensor
y: tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

stores the element-wise maximum of x and y in x. x.cmin(y) = min(x, y)

y: tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

x: tensor
y: tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

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

y: tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def contiguous(): Tensor[T]

Get a contiguous tensor from current tensor

returns: the current tensor if it's contiguous; or a new contiguous tensor with separated storage

Definition Classes: DnnTensorUnsupportOperations → 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).

This function computes 2 dimensional convolution of a single image with a single kernel (2D output). the dimensions of input and kernel need to be 2, and Input image needs to be bigger than kernel. The last argument controls if the convolution is a full ('F') or valid ('V') convolution. The default is valid convolution.

vf: full ('F') or valid ('V') convolution.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Copy the value of the given tensor to the current.

Copy the value of the given tensor to the current. They should have same size. It will use the old storage

other: source tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Compare and print differences between two tensors

returns: true if there's difference, vice versa

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def dim(): Int

A shortcut of nDimension()

Definition Classes: DnnTensorUnsupportOperations → Tensor
See also: nDimension()

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

Performs the p-norm distance calculation between two tensors

y: the secode Tensor
norm: the norm of distance

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

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

y: tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

divide all elements of this with value in-place.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Performs the dot product.

Performs the dot product. The number of elements must match: both Tensors are seen as a 1D vector.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def emptyInstance(): Tensor[T]

return a new empty tensor of the same type

returns: new tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Implements == operator comparing each element in x with y

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def erf(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def erfc(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def exp(): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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.

Expanding a tensor allocates new memory, tensor where singleton dimensions can be expanded to multiple ones by setting the stride to 0. Any dimension that has size 1 can be expanded to arbitrary value with new memory allocation. Attempting to expand along a dimension that does not have size 1 will result in an error.

sizes: the size that tensor will expend to

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

template: the given tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Fill with a given value.

Fill with a given value. It will change the value of the current tensor and return itself

v: value to fill the tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

def floor(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Populate the given tensor with the floor result of elements

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Fill with a given value.

Fill with a given value. It will change the value of the current tensor and return itself

Note the value should be an instance of T

v: value to fill the tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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.

returns: this

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Implements >= operator comparing each element in x with value

Definition Classes: DnnTensorUnsupportOperations → TensorMath

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native()

def getTensorNumeric(): TensorNumeric[T]

Return tensor numeric

Definition Classes: DnnTensorUnsupportOperations → Tensor

def getTensorType: TensorType

Return tensor type

returns: Dense / Quant

Definition Classes: DnnTensorUnsupportOperations → Tensor

def getType(): TensorDataType

return the tensor datatype( DoubleType or FloatType)

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Implements > operator comparing each element in x with y

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

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.

Accumulate the elements of tensor into the original tensor by adding to the indices in the order given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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.

Accumulate the elements of tensor into the original tensor by adding to the indices in the order given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def inv(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def isContiguous(): Boolean

Check if the tensor is contiguous on the storage

returns: true if it's contiguous

Definition Classes: DnnTensorUnsupportOperations → Tensor

def isEmpty: Boolean

returns: whether this tensor is an empty tensor. Note that nDimension == 0 is not sufficient to determine a tensor is empty, because a scalar tensor's nDimension is also 0.

Definition Classes: DnnTensorUnsupportOperations → Tensor

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

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

Check if the size is same with the give tensor

other: tensor to be compared
returns: true if they have same size

Definition Classes: DnnTensorUnsupportOperations → Tensor

def isScalar: Boolean

returns: whether this tensor is a scalar

Definition Classes: DnnTensorUnsupportOperations → Tensor

def isTable: Boolean

Return false because it's not a Table

returns: false

Definition Classes: Tensor → Activity

def isTensor: Boolean

Return true because it's a Tensor implemented from Activity

returns: true

Definition Classes: Tensor → Activity

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

Implements <= operator comparing each element in x with y

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def log(): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Replaces all elements in-place with the elements of lnx

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def log1p(): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def logGamma(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Implements < operator comparing each element in x with y

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

other: another tensor
func: applied function
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Copies the elements of tensor into mask locations of itself.

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Fills the masked elements of itself with value val

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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.

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

performs the max operation over the dimension n

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

performs the max operation over the dimension n

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def max(): T

returns the single biggest element of x

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

performs the mean operation over the dimension dim.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def mean(): T

returns the mean of all elements of this.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

performs the min operation over the dimension n

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

performs the min operation over the dimension n

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def min(): T

returns the single minimum element of x

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

res = mat1*mat2

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

put the result of x * value in current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

multiply all elements of this with value in-place.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

res = res + (mat * vec2)

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def nDimension(): Int

Dimension number of the tensor.

Dimension number of the tensor. For empty tensor, its dimension number is 0

returns: dimension number

Definition Classes: DnnTensorUnsupportOperations → Tensor

def nElement(): Int

Element number

returns: element number

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

Get a subset of the tensor on dim-th dimension. The offset is given by index, and length is given by size. The important difference with select is that it will not reduce the dimension number. For Instance tensor = 1 2 3 4 5 6 tensor.narrow(1, 1, 1) is [1 2 3] tensor.narrow(2, 2, 2) is 2 3 5 6

Definition Classes: DnnTensorUnsupportOperations → Tensor

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

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

Computes numerical negative value element-wise.

Computes numerical negative value element-wise. y = -x

returns: this tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def norm(value: Int): T

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

value: the n-norms

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

y: result buffer

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def notEqualValue(value: Double): Boolean

Element wise inequality between tensor and given value

Definition Classes: Tensor

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

def numNonZeroByRow(): Array[Int]

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

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

returns: an array number of non-zero elements in first dimension.

Definition Classes: Tensor

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def prod(): T

returns the product of the elements of this

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def rand(): Tensor[T]

Fill with random value(uniform distribution).

Fill with random value(uniform distribution). It will change the value of the current tensor and return itself

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

Fill with random value(normal gaussian distribution with the specified mean and stdv). It will change the value of the current tensor and return itself

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def randn(): Tensor[T]

Fill with random value(normal gaussian distribution).

Fill with random value(normal gaussian distribution). It will change the value of the current tensor and return itself

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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).

returns: this tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Repeating a tensor allocates new memory, unless result is provided, in which case its memory is resized. sizes specify the number of times the tensor is repeated in each dimension.

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

create a new tensor without any change of the tensor

sizes: the size of the new Tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def resize(size1: Int, size2: Int, size3: Int, size4: Int, size5: Int): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → Tensor

def resize(size1: Int, size2: Int, size3: Int, size4: Int): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → Tensor

def resize(size1: Int, size2: Int, size3: Int): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → Tensor

def resize(size1: Int, size2: Int): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → Tensor

def resize(size1: Int): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Resize the current tensor to the give shape

sizes: Array describe the size
strides: Array describe the jumps

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: Tensor

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

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

Resize the current tensor to the same size of the given tensor. It will still use the same storage if the storage is sufficient for the new size

src: target tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Save the tensor to given path

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

returns: this

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

Remove the dim-th dimension and return the subset part. For instance tensor = 1 2 3 4 5 6 tensor.select(1, 1) is [1 2 3] tensor.select(1, 2) is [4 5 6] tensor.select(2, 3) is [3 6]

Definition Classes: DnnTensorUnsupportOperations → Tensor

def set(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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.

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. As the result, any modification in the elements of the Storage will have an impact on the elements of the Tensor, and vice-versa. This is an efficient method, as there is no memory copy!

If only storage is provided, the whole storage will be viewed as a 1D Tensor.

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

The Tensor is now going to "view" the same storage as the given tensor. As the result, any modification in the elements of the Tensor will have an impact on the elements of the given tensor, and vice-versa. This is an efficient method, as there is no memory copy!

other: the given tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Write the value on a given position.

Write the value on a given position. The number of parameters should be equal to the dimension number of the tensor.

value: the written value

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Set value for a scalar tensor

value: the written value

Definition Classes: DnnTensorUnsupportOperations → Tensor

def shallowClone(): Tensor[T]

Get a new tensor with same storage.

returns: new tensor

Definition Classes: Tensor

def sign(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def size(dim: Int): Int

size of the tensor on the given dimension

dim: dimension, count from 1
returns: size

Definition Classes: DnnTensorUnsupportOperations → Tensor

def size(): Array[Int]

Size of tensor.

Size of tensor. Return an array of which each value represents the size on the dimension(i + 1), i is the index of the corresponding value. It will generate a new array each time method is invoked.

returns: size array

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

spilt one tensor into multi tensor along the dim dimension

dim: the specific dimension

Definition Classes: DnnTensorUnsupportOperations → Tensor

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).

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). The sizes of the non-dim dimensions remain unchanged. Internally, a series of narrows are performed along dimensions dim. Argument dim defaults to 1.

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def sqrt(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def square(): Tensor[T]

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

returns: current tensor reference

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Removes given dimensions of the tensor if it's singleton

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def squeeze(): Tensor[T]

Removes all singleton dimensions of the tensor

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def squeezeNewTensor(): Tensor[T]

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

returns: create a new tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def storage(): Storage[T]

Get the storage

returns: storage

Definition Classes: DnnTensorUnsupportOperations → Tensor

def storageOffset(): Int

tensor offset on the storage

returns: storage offset, count from 1

Definition Classes: DnnTensorUnsupportOperations → Tensor

def stride(dim: Int): Int

Jumps between elements on the given dimension in the storage.

dim: dimension, count from 1
returns: jump

Definition Classes: DnnTensorUnsupportOperations → Tensor

def stride(): Array[Int]

Jumps between elements on the each dimension in the storage.

Jumps between elements on the each dimension in the storage. It will generate a new array each time method is invoked.

returns: strides array

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

subtracts all elements of y from this

y: other tensor
returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

performs the sum operation over the dimension dim

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def sum(): T

returns the sum of the elements of this

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def sumSquare(): T

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Definition Classes: AnyRef

def t(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → Tensor
See also: transpose()

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def tanh(): Tensor[T]

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

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def toArray(): Array[T]

Convert 1D tensor to an array.

Convert 1D tensor to an array. If the tensor is not 1D, an exception will be thrown out.

Definition Classes: DnnTensorUnsupportOperations → Tensor

def toBreezeMatrix(): DenseMatrix[T]

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

returns: BrzDenseMatrix

Definition Classes: DnnTensorUnsupportOperations → Tensor

def toBreezeVector(): DenseVector[T]

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

returns: BrzDenseVector

Definition Classes: DnnTensorUnsupportOperations → Tensor

def toMLlibMatrix(): Matrix

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

returns: Matrix

Definition Classes: DnnTensorUnsupportOperations → Tensor

def toMLlibVector(): Vector

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

returns: Vector

Definition Classes: DnnTensorUnsupportOperations → Tensor

def toString(): String

Definition Classes: AnyRef → Any

def toTable: Table

Definition Classes: Tensor → Activity

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

Definition Classes: DnnTensorUnsupportOperations → Activity

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

Get the top k smallest values and their indices.

dim: dimension, default is the last dimension
increase: sort order, set it to true if you want to get the smallest top k values
result: result buffer
indices: indices buffer

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

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

dim1: dimension to be exchanged, count from one
dim2: dimension to be exchanged, count from one
returns: new tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def unary_-(): Tensor[T]

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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.

Returns a tensor which contains all slices of size @param size in the dimension @param dim. Step between two slices is given by @param step.

step: Step between two slices
returns: new tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

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)]

Definition Classes: DnnTensorUnsupportOperations → TensorMath

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

Update the value meeting the filter criteria with the give value

filter: filter
value: value to update

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Copy the given tensor values to the selected subset of the current tensor Each element of the given table can be an Int or another Table.

Copy the given tensor values to the selected subset of the current tensor Each element of the given table can be an Int or another Table. An Int means select on current dimension; A table means narrow on current dimension, the table should has two elements, of which the first is start index and the second is the end index. An empty table is equal to Table(1, size_of_current_dimension). If the table's length is smaller than the tensor's dimension, the missing dimension is applied by an empty table.

t: subset table
src: tensor to copy

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

Fill the select subset of the current tensor with the given value. The element of the given table can be an Int or another Table. An Int means select on current dimension; A table means narrow on the current dimension, the table should has two elements, of which the first is the start index and the second is the end index. An empty table is equal to Table(1, size_of_current_dimension) If the table length is less than the tensor dimension, each missing dimension is applied by an empty table

t: subset table
value: value to write

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

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

indexes: index array. It should has same length with the tensor dimension
value: value to write

Definition Classes: DnnTensorUnsupportOperations → Tensor

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.

Copy the give tensor value to the select subset of the current tensor by the given index. The subset should have the same size of the given tensor

index: index
src: tensor to write

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

For tensor(i) = value.

For tensor(i) = value. If tensor(i) is another tensor, it will fill the selected subset by the given value

index: index
value: value to write

Definition Classes: DnnTensorUnsupportOperations → Tensor

def value(): T

returns: the value of a scalar. Requires the tensor to be a scalar.

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

def valueAt(d1: Int): T

Query the value on a given position.

Query the value on a given position. The number of parameters should be equal to the dimension number of the tensor. Tensor should not be empty.

returns: the value on a given position

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Definition Classes: DnnTensorUnsupportOperations → Tensor

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

Return a new tensor with specified sizes.

Return a new tensor with specified sizes. The input tensor must be contiguous, and the elements number in the given sizes must be equal to the current tensor

returns: new tensor

Definition Classes: Tensor

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

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

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @native() @throws( ... )

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.

vf: full ('F') or valid ('V') convolution.

Definition Classes: DnnTensorUnsupportOperations → TensorMath

def zero(): Tensor[T]

Fill with zero.

Fill with zero. It will change the value of the current tensor and return itself

returns: current tensor

Definition Classes: DnnTensorUnsupportOperations → Tensor

def zipWith[A, B](t1: Tensor[A], t2: Tensor[B], func: (A, B) ⇒ T)(implicit arg0: ClassManifest[A], arg1: ClassManifest[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

The two given tensors should has the same size of the current tensor

A: numeric type of tensor 1
B: numeric type of tensor 2
t1: tensor 1
t2: tensor 2
func: zip with the function
returns: self

Definition Classes: DnnTensorUnsupportOperations → Tensor

Packages

DnnTensorUnsupportOperations

class DnnTensorUnsupportOperations[T] extends Tensor[T]

Instance Constructors

Value Members

Inherited from Tensor[T]

Inherited from Activity

Inherited from TensorMath[T]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

DnnTensorUnsupportOperations 

class DnnTensorUnsupportOperations[T] extends Tensor[T]

Instance Constructors

Value Members

Inherited from Tensor[T]

Inherited from Activity

Inherited from TensorMath[T]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped

DnnTensorUnsupportOperations