trait TensorMath[T] extends AnyRef

It provides multiple math operation functions for manipulating Tensor objects. All functions support both allocating a new Tensor to return the result and treating the caller as a target Tensor, in which case the target Tensor(s) will be resized accordingly and filled with the result. This property is especially useful when one wants to have tight control over when memory is allocated.

T

should be double or float

Linear Supertypes
AnyRef, Any
Known Subclasses
DnnTensor, DnnTensorUnsupportOperations, QuantizedTensorUnsupported, Tensor
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TensorMath
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract 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

  2. abstract 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.

  3. abstract 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

  4. abstract 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.

  5. abstract 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

  6. abstract 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.

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

  8. abstract 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.

  9. abstract def abs(x: Tensor[T]): Tensor[T]
  10. abstract def abs(): Tensor[T]

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

  11. abstract def add(x: Tensor[T], y: Tensor[T]): Tensor[T]
  12. abstract def add(value: T): Tensor[T]

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

  13. abstract 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.

  14. abstract def add(y: Tensor[T]): Tensor[T]

    accumulates all elements of y into this

    accumulates all elements of y into this

    y

    other tensor

    returns

    current tensor

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

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

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

    value

    scalar

    y

    other tensor

    returns

    current tensor

  16. abstract 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.

  17. abstract def addcmul(tensor1: Tensor[T], tensor2: Tensor[T]): Tensor[T]
  18. abstract 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.

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

    res = v1 * res + v2 * mat1*mat2

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

    res = res + v2 * mat1 * mat2

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

    res = res + mat1 * mat2

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

    res = M + (mat1*mat2)

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

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

    res = res + alpha * (mat * vec2)

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

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

  26. abstract 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.

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

  28. abstract def addr(v1: T, t1: Tensor[T], v2: T, t2: Tensor[T]): Tensor[T]
  29. abstract def addr(v1: T, t1: Tensor[T], t2: Tensor[T]): Tensor[T]
  30. abstract 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)

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

    res_i = res_i + (alpha * batch1_i * batch2_i)

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

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

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

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

    res_i = res_i + batch1_i * batch2_i

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

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

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

    x

    tensor

    y

    tensor

    returns

    current tensor

  36. abstract 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

  37. abstract def ceil(): Tensor[T]

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

  38. abstract def clamp(min: Double, max: Double): Tensor[T]
  39. abstract 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

  40. abstract 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

  41. abstract def cmax(value: T): Tensor[T]

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

  42. abstract 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

  43. abstract 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

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

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

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

    x

    tensor

    y

    tensor

    returns

    current tensor

  45. abstract 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

  46. abstract def conv2(kernel: Tensor[T], vf: Char = 'V'): 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.

  47. abstract 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

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

    Performs the p-norm distance calculation between two tensors

    Performs the p-norm distance calculation between two tensors

    y

    the secode Tensor

    norm

    the norm of distance

  49. abstract 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

  50. abstract def div(value: T): Tensor[T]

    divide all elements of this with value in-place.

  51. abstract 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.

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

    Implements == operator comparing each element in x with y

    Implements == operator comparing each element in x with y

    returns

    current tensor reference

  53. abstract def erf(): Tensor[T]

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

  54. abstract def erfc(): Tensor[T]

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

  55. abstract def exp(): Tensor[T]
  56. abstract def exp(y: Tensor[T]): Tensor[T]
  57. abstract def floor(): Tensor[T]

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

  58. abstract def floor(y: Tensor[T]): Tensor[T]

    Populate the given tensor with the floor result of elements

  59. abstract 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.

    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

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

    Implements >= operator comparing each element in x with value

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

    Implements > operator comparing each element in x with y

    Implements > operator comparing each element in x with y

    returns

    current tensor reference

  62. abstract 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.

  63. abstract 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.

  64. abstract def inv(): Tensor[T]

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

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

    Implements <= operator comparing each element in x with y

    Implements <= operator comparing each element in x with y

    returns

    current tensor reference

  66. abstract def log(): Tensor[T]
  67. abstract def log(y: Tensor[T]): Tensor[T]

    Replaces all elements in-place with the elements of lnx

    Replaces all elements in-place with the elements of lnx

    returns

    current tensor reference

  68. abstract def log1p(): Tensor[T]
  69. abstract def log1p(y: Tensor[T]): Tensor[T]
  70. abstract def logGamma(): Tensor[T]

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

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

    Implements < operator comparing each element in x with y

    Implements < operator comparing each element in x with y

    returns

    current tensor reference

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

    Copies the elements of tensor into mask locations of itself.

    Copies the elements of tensor into mask locations of itself.

    returns

    current tensor reference

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

    Fills the masked elements of itself with value val

    Fills the masked elements of itself with value val

    returns

    current tensor reference

  74. abstract 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 a new Tensor which contains all elements aligned to a 1 in the corresponding mask.

    returns

    current tensor reference

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

    performs the max operation over the dimension n

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

    performs the max operation over the dimension n

  77. abstract def max(): T

    returns the single biggest element of x

  78. abstract def mean(dim: Int): Tensor[T]

    performs the mean operation over the dimension dim.

  79. abstract def mean(): T

    returns the mean of all elements of this.

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

    performs the min operation over the dimension n

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

    performs the min operation over the dimension n

  82. abstract def min(): T

    returns the single minimum element of x

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

    res = mat1*mat2

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

    put the result of x * value in current tensor

  85. abstract def mul(value: T): Tensor[T]

    multiply all elements of this with value in-place.

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

    res = res + (mat * vec2)

  87. abstract def negative(x: Tensor[T]): Tensor[T]

    Computes numerical negative value element-wise.

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

    returns

    this tensor

  88. abstract def norm(value: Int): T

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

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

    value

    the n-norms

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

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

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

    y

    result buffer

  90. abstract def pow(n: T): Tensor[T]
  91. abstract def pow(y: Tensor[T], n: T): Tensor[T]

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

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

    returns

    current tensor reference

  92. abstract def prod(x: Tensor[T], dim: Int): Tensor[T]
  93. abstract def prod(): T

    returns the product of the elements of this

  94. abstract def range(xmin: Double, xmax: Double, step: Int = 1): Tensor[T]

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

    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

  95. abstract 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

  96. abstract 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

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

    returns

    this

  97. abstract def sign(): Tensor[T]

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

  98. abstract def sqrt(y: Tensor[T]): Tensor[T]
  99. abstract def sqrt(): Tensor[T]

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

  100. abstract def square(): Tensor[T]

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

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

    returns

    current tensor reference

  101. abstract def sub(value: T): Tensor[T]
  102. abstract def sub(x: Tensor[T], y: Tensor[T]): Tensor[T]
  103. abstract def sub(y: Tensor[T]): Tensor[T]

    subtracts all elements of y from this

    subtracts all elements of y from this

    y

    other tensor

    returns

    current tensor

  104. abstract def sub(x: Tensor[T], value: T, y: Tensor[T]): Tensor[T]
  105. abstract def sub(value: T, y: Tensor[T]): Tensor[T]
  106. abstract def sum(x: Tensor[T], dim: Int): Tensor[T]
  107. abstract def sum(dim: Int): Tensor[T]

    performs the sum operation over the dimension dim

  108. abstract def sum(): T

    returns the sum of the elements of this

  109. abstract def sumSquare(): T
  110. abstract def tanh(y: Tensor[T]): Tensor[T]
  111. abstract def tanh(): Tensor[T]

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

  112. abstract def topk(k: Int, dim: Int = -1, increase: Boolean = true, result: Tensor[T] = null, indices: Tensor[T] = null, sortedResult: Boolean = true): (Tensor[T], Tensor[T])

    Get the top k smallest values and their indices.

    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

  113. abstract def unary_-(): Tensor[T]
  114. abstract 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)]

  115. abstract def xcorr2(kernel: Tensor[T], vf: Char = 'V'): 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.

    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.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def +(e: Either[Tensor[T], T]): Tensor[T]
  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  7. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  8. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  10. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  12. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  13. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  14. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  15. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  16. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  17. def toString(): String
    Definition Classes
    AnyRef → Any
  18. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  19. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  20. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped