com.intel.analytics.bigdl.tensor

Tensor

trait Tensor[T] extends Serializable with TensorMath[T] with Activity

It is the class for handling numeric data.

T

should be Double or Float

Linear Supertypes
Activity, TensorMath[T], Serializable, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Tensor
  2. Activity
  3. TensorMath
  4. Serializable
  5. AnyRef
  6. Any
  1. Hide All
  2. Show all
Learn more about member selection
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

    t
    returns

    Definition Classes
    TensorMath
  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.

    s
    returns

    Definition Classes
    TensorMath
  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

    t
    returns

    Definition Classes
    TensorMath
  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.

    s
    returns

    Definition Classes
    TensorMath
  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

    t
    returns

    Definition Classes
    TensorMath
  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.

    s
    returns

    Definition Classes
    TensorMath
  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

    t
    returns

    Definition Classes
    TensorMath
  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.

    s
    returns

    Definition Classes
    TensorMath
  9. abstract def abs(x: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  10. abstract def abs(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  11. abstract def add(x: Tensor[T], y: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  12. abstract def add(value: T): Tensor[T]

    x.

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

    value
    returns

    Definition Classes
    TensorMath
  13. abstract def add(x: Tensor[T], value: T, y: Tensor[T]): Tensor[T]

    z.

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

    x
    value
    y
    returns

    Definition Classes
    TensorMath
  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

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

    x.

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

    value

    scalar

    y

    other tensor

    returns

    current tensor

    Definition Classes
    TensorMath
  16. abstract def addSingletonDimension(t: Tensor[T] = this, dim: Int = 1): Tensor[T]

    view this.

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

    t

    source tensor

    dim

    the specific dimension, default is 1

    returns

    this

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

    value
    tensor1
    tensor2
    returns

    Definition Classes
    TensorMath
  18. abstract def addcmul(tensor1: Tensor[T], tensor2: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  19. 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.

    value
    tensor1
    tensor2

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

    res = v1 * res + v2 * mat1*mat2

    res = v1 * res + v2 * mat1*mat2

    Definition Classes
    TensorMath
  21. abstract def addmm(v2: T, mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

    res = res + v2 * mat1 * mat2

    res = res + v2 * mat1 * mat2

    Definition Classes
    TensorMath
  22. abstract def addmm(mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

    res = res + mat1 * mat2

    res = res + mat1 * mat2

    Definition Classes
    TensorMath
  23. abstract def addmm(M: Tensor[T], mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

    res = M + (mat1*mat2)

    res = M + (mat1*mat2)

    Definition Classes
    TensorMath
  24. 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)

    v1
    M
    v2
    mat1
    mat2

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

    res = res + alpha * (mat * vec2)

    res = res + alpha * (mat * vec2)

    Definition Classes
    TensorMath
  26. abstract def addmv(beta: T, alpha: T, mat: Tensor[T], vec2: Tensor[T]): Tensor[T]

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

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

    Definition Classes
    TensorMath
  27. 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.

    Definition Classes
    TensorMath
  28. 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)

    v1
    t1
    v2
    t2
    t3
    returns

    Definition Classes
    TensorMath
  29. abstract def addr(v1: T, t1: Tensor[T], v2: T, t2: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  30. abstract def addr(v1: T, t1: Tensor[T], t2: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  31. 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)

    t1
    t2
    returns

    Definition Classes
    TensorMath
  32. abstract 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

    returns

    See also

    narrow

    select

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

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

    returns

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

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

    func

    applied function

    returns

    current tensor

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

    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

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

    res_i = res_i + (alpha * batch1_i * batch2_i)

    res_i = res_i + (alpha * batch1_i * batch2_i)

    Definition Classes
    TensorMath
  38. 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)

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

    Definition Classes
    TensorMath
  39. 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)

    Definition Classes
    TensorMath
  40. abstract 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

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

    res_i = res_i + batch1_i * batch2_i

    res_i = res_i + batch1_i * batch2_i

    Definition Classes
    TensorMath
  42. abstract 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

    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

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

    Element-wise divide z.

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

    x

    tensor

    y

    tensor

    returns

    current tensor

    Definition Classes
    TensorMath
  44. abstract def cdiv(y: Tensor[T]): Tensor[T]

    Element-wise divide x.

    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
    TensorMath
  45. abstract def ceil(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  46. abstract def clamp(min: Float, max: Float): Tensor[T]

    Definition Classes
    TensorMath
  47. 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

    Definition Classes
    TensorMath
  48. 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

    Definition Classes
    TensorMath
  49. abstract def cmax(value: T): Tensor[T]

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

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

    value
    returns

    Definition Classes
    TensorMath
  50. 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

    Definition Classes
    TensorMath
  51. 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

    Definition Classes
    TensorMath
  52. abstract def cmul(x: Tensor[T], y: Tensor[T]): Tensor[T]

    Element-wise multiply z.

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

    x

    tensor

    y

    tensor

    returns

    current tensor

    Definition Classes
    TensorMath
  53. abstract def cmul(y: Tensor[T]): Tensor[T]

    Element-wise multiply x.

    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
    TensorMath
  54. abstract def contiguous(): Tensor[T]

    Get a contiguous tensor from current tensor

    Get a contiguous tensor from current tensor

    returns

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

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

    kernel
    vf

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

    returns

    Definition Classes
    TensorMath
  56. abstract 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

  57. abstract def diff(other: Tensor[T], count: Int = 1, reverse: Boolean = false): Boolean

    Compare and print differences between two tensors

    Compare and print differences between two tensors

    other
    count
    returns

    true if there's difference, vice versa

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

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

    returns

    Definition Classes
    TensorMath
  59. abstract def dim(): Int

    A shortcut of nDimension()

    A shortcut of nDimension()

    See also

    nDimension()

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

    returns

    Definition Classes
    TensorMath
  61. abstract def div(y: Tensor[T]): Tensor[T]

    Element-wise divide x.

    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
    TensorMath
  62. abstract def div(value: T): Tensor[T]

    divide all elements of this with value in-place.

    divide all elements of this with value in-place.

    value
    returns

    Definition Classes
    TensorMath
  63. 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.

    y
    returns

    Definition Classes
    TensorMath
  64. abstract def emptyInstance(): Tensor[T]

    return a new empty tensor of the same type

    return a new empty tensor of the same type

    returns

    new tensor

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

    y
    returns

    current tensor reference

    Definition Classes
    TensorMath
  66. abstract def erf(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  67. abstract def erfc(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  68. abstract def exp(): Tensor[T]

    Definition Classes
    TensorMath
  69. abstract def exp(y: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  70. abstract 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

    returns

  71. abstract def expandAs(template: Tensor[T]): Tensor[T]

    This is equivalent to this.

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

    template

    the given tensor

    returns

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

  73. abstract def floor(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  74. abstract def floor(y: Tensor[T]): Tensor[T]

    Populate the given tensor with the floor result of elements

    Populate the given tensor with the floor result of elements

    y
    returns

    Definition Classes
    TensorMath
  75. abstract 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

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

    dim
    index
    src
    returns

    this

    Definition Classes
    TensorMath
  77. abstract def ge(x: Tensor[T], value: Double): Tensor[T]

    Implements >= operator comparing each element in x with value

    Implements >= operator comparing each element in x with value

    x
    value
    returns

    Definition Classes
    TensorMath
  78. abstract def getTensorNumeric(): TensorNumeric[T]

    Return tensor numeric

    Return tensor numeric

    returns

  79. abstract def getTensorType: TensorType

    Return tensor type

    Return tensor type

    returns

    Dense / Quant

  80. abstract def getType(): TensorDataType

    return the tensor datatype( DoubleType or FloatType)

    return the tensor datatype( DoubleType or FloatType)

    returns

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

    x
    y
    returns

    current tensor reference

    Definition Classes
    TensorMath
  82. 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.

    dim
    index
    y
    returns

    Definition Classes
    TensorMath
  83. 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.

    dim
    index
    y
    returns

    Definition Classes
    TensorMath
  84. abstract def inv(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  85. abstract def isContiguous(): Boolean

    Check if the tensor is contiguous on the storage

    Check if the tensor is contiguous on the storage

    returns

    true if it's contiguous

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

  87. abstract def isSameSizeAs(other: Tensor[_]): Boolean

    Check if the size is same with the give tensor

    Check if the size is same with the give tensor

    other

    tensor to be compared

    returns

    true if they have same size

  88. abstract def isScalar: Boolean

    returns

    whether this tensor is a scalar

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

    x
    y
    returns

    current tensor reference

    Definition Classes
    TensorMath
  90. abstract def log(): Tensor[T]

    Definition Classes
    TensorMath
  91. 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

    y
    returns

    current tensor reference

    Definition Classes
    TensorMath
  92. abstract def log1p(): Tensor[T]

    Definition Classes
    TensorMath
  93. abstract def log1p(y: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  94. abstract def logGamma(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  95. 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

    x
    y
    returns

    current tensor reference

    Definition Classes
    TensorMath
  96. abstract 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

    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

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

    mask
    y
    returns

    current tensor reference

    Definition Classes
    TensorMath
  98. 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

    mask
    e
    returns

    current tensor reference

    Definition Classes
    TensorMath
  99. 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.

    mask
    y
    returns

    current tensor reference

    Definition Classes
    TensorMath
  100. abstract def max(values: Tensor[T], indices: Tensor[T], dim: Int): (Tensor[T], Tensor[T])

    performs the max operation over the dimension n

    performs the max operation over the dimension n

    values
    indices
    dim
    returns

    Definition Classes
    TensorMath
  101. abstract def max(dim: Int): (Tensor[T], Tensor[T])

    performs the max operation over the dimension n

    performs the max operation over the dimension n

    dim
    returns

    Definition Classes
    TensorMath
  102. abstract def max(): T

    returns the single biggest element of x

    returns the single biggest element of x

    returns

    Definition Classes
    TensorMath
  103. abstract def mean(dim: Int): Tensor[T]

    performs the mean operation over the dimension dim.

    performs the mean operation over the dimension dim.

    dim
    returns

    Definition Classes
    TensorMath
  104. abstract def mean(): T

    returns the mean of all elements of this.

    returns the mean of all elements of this.

    returns

    Definition Classes
    TensorMath
  105. abstract def min(values: Tensor[T], indices: Tensor[T], dim: Int): (Tensor[T], Tensor[T])

    performs the min operation over the dimension n

    performs the min operation over the dimension n

    values
    indices
    dim
    returns

    Definition Classes
    TensorMath
  106. abstract def min(dim: Int): (Tensor[T], Tensor[T])

    performs the min operation over the dimension n

    performs the min operation over the dimension n

    dim
    returns

    Definition Classes
    TensorMath
  107. abstract def min(): T

    returns the single minimum element of x

    returns the single minimum element of x

    returns

    Definition Classes
    TensorMath
  108. abstract def mm(mat1: Tensor[T], mat2: Tensor[T]): Tensor[T]

    res = mat1*mat2

    res = mat1*mat2

    Definition Classes
    TensorMath
  109. abstract def mul(x: Tensor[T], value: T): Tensor[T]

    put the result of x * value in current tensor

    put the result of x * value in current tensor

    value
    returns

    Definition Classes
    TensorMath
  110. abstract def mul(value: T): Tensor[T]

    multiply all elements of this with value in-place.

    multiply all elements of this with value in-place.

    value
    returns

    Definition Classes
    TensorMath
  111. abstract def mv(mat: Tensor[T], vec2: Tensor[T]): Tensor[T]

    res = res + (mat * vec2)

    res = res + (mat * vec2)

    Definition Classes
    TensorMath
  112. abstract def nDimension(): Int

    Dimension number of the tensor.

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

    returns

    dimension number

  113. abstract def nElement(): Int

    Element number

    Element number

    returns

    element number

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

    dim
    index
    size
    returns

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

    Computes numerical negative value element-wise.

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

    x
    returns

    this tensor

    Definition Classes
    TensorMath
  116. 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

    returns

    Definition Classes
    TensorMath
  117. 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

    value
    dim
    returns

    Definition Classes
    TensorMath
  118. abstract def pow(n: T): Tensor[T]

    Definition Classes
    TensorMath
  119. 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

    y
    n
    returns

    current tensor reference

    Definition Classes
    TensorMath
  120. abstract def prod(x: Tensor[T], dim: Int): Tensor[T]

    Definition Classes
    TensorMath
  121. abstract def prod(): T

    returns the product of the elements of this

    returns the product of the elements of this

    returns

    Definition Classes
    TensorMath
  122. abstract 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

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

    returns

    current tensor

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

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

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

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

    xmin
    xmax
    step
    returns

    this tensor

    Definition Classes
    TensorMath
  127. 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

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

    dim
    result
    reducer

    Definition Classes
    TensorMath
  128. abstract 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.

    sizes
    returns

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

    create a new tensor without any change of the tensor

    create a new tensor without any change of the tensor

    sizes

    the size of the new Tensor

    returns

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

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

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

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

  134. abstract def resize(size1: Int): Tensor[T]

  135. abstract def resize(sizes: Array[Int], strides: Array[Int] = null): Tensor[T]

    Resize the current tensor to the give shape

    Resize the current tensor to the give shape

    sizes

    Array describe the size

    strides

    Array describe the jumps

    returns

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

  137. abstract def save(path: String, overWrite: Boolean = false): Tensor.this.type

    Save the tensor to given path

    Save the tensor to given path

    path
    overWrite
    returns

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

    dim
    index
    src
    returns

    this

    Definition Classes
    TensorMath
  139. abstract 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]

    dim
    index
    returns

  140. abstract def set(): Tensor[T]

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

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

    returns

  141. abstract def set(storage: Storage[T], storageOffset: Int = 1, sizes: Array[Int] = null, strides: Array[Int] = null): 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.

    storage
    storageOffset
    sizes
    strides
    returns

    current tensor

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

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

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

  145. abstract def setValue(d1: Int, d2: Int, d3: Int, value: T): Tensor.this.type

  146. abstract def setValue(d1: Int, d2: Int, value: T): Tensor.this.type

  147. abstract def setValue(d1: Int, value: T): Tensor.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

    returns

  148. abstract def setValue(value: T): Tensor.this.type

    Set value for a scalar tensor

    Set value for a scalar tensor

    value

    the written value

    returns

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

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

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

    returns

    Definition Classes
    TensorMath
  150. abstract def size(dim: Int): Int

    size of the tensor on the given dimension

    size of the tensor on the given dimension

    dim

    dimension, count from 1

    returns

    size

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

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

    spilt one tensor into multi tensor along the dim dimension

    spilt one tensor into multi tensor along the dim dimension

    dim

    the specific dimension

    returns

  153. abstract def split(size: Int, dim: Int = 1): 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.

    size
    dim
    returns

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

    Definition Classes
    TensorMath
  155. abstract def sqrt(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  156. 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

    Definition Classes
    TensorMath
  157. abstract def squeeze(dim: Int): Tensor[T]

    Removes given dimensions of the tensor if it's singleton

    Removes given dimensions of the tensor if it's singleton

    returns

    current tensor

  158. abstract def squeeze(): Tensor[T]

    Removes all singleton dimensions of the tensor

    Removes all singleton dimensions of the tensor

    returns

    current tensor

  159. abstract def squeezeNewTensor(): Tensor[T]

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

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

    returns

    create a new tensor

  160. abstract def storage(): Storage[T]

    Get the storage

    Get the storage

    returns

    storage

  161. abstract def storageOffset(): Int

    tensor offset on the storage

    tensor offset on the storage

    returns

    storage offset, count from 1

  162. abstract def stride(dim: Int): Int

    Jumps between elements on the given dimension in the storage.

    Jumps between elements on the given dimension in the storage.

    dim

    dimension, count from 1

    returns

    jump

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

  164. abstract def sub(value: T): Tensor[T]

    Definition Classes
    TensorMath
  165. abstract def sub(x: Tensor[T], y: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  166. 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

    Definition Classes
    TensorMath
  167. abstract def sub(x: Tensor[T], value: T, y: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  168. abstract def sub(value: T, y: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  169. abstract def sum(x: Tensor[T], dim: Int): Tensor[T]

    Definition Classes
    TensorMath
  170. abstract def sum(dim: Int): Tensor[T]

    performs the sum operation over the dimension dim

    performs the sum operation over the dimension dim

    dim
    returns

    Definition Classes
    TensorMath
  171. abstract def sum(): T

    returns the sum of the elements of this

    returns the sum of the elements of this

    returns

    Definition Classes
    TensorMath
  172. abstract def sumSquare(): T

    Definition Classes
    TensorMath
  173. abstract def t(): Tensor[T]

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

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

    See also

    transpose()

  174. abstract def tanh(y: Tensor[T]): Tensor[T]

    Definition Classes
    TensorMath
  175. abstract def tanh(): Tensor[T]

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

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

    returns

    Definition Classes
    TensorMath
  176. abstract 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.

    returns

  177. abstract def toBreezeMatrix(): DenseMatrix[T]

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

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

    returns

    BrzDenseMatrix

  178. abstract def toBreezeVector(): DenseVector[T]

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

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

    returns

    BrzDenseVector

  179. abstract def toMLlibMatrix(): Matrix

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

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

    returns

    Matrix

  180. abstract def toMLlibVector(): Vector

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

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

    returns

    Vector

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

    Definition Classes
    Activity
  182. 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.

    k
    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

    returns

    Definition Classes
    TensorMath
  183. abstract def transpose(dim1: Int, dim2: Int): Tensor[T]

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

    * 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

  184. abstract def unary_-(): Tensor[T]

    Definition Classes
    TensorMath
  185. abstract 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.

    dim
    size
    step

    Step between two slices

    returns

    new tensor

  186. abstract def uniform(args: T*): T

    return pseudo-random numbers, require 0<=args.

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

    args

    Definition Classes
    TensorMath
  187. abstract def update(filter: (T) ⇒ Boolean, value: T): Unit

    Update the value meeting the filter criteria with the give value

    Update the value meeting the filter criteria with the give value

    filter

    filter

    value

    value to update

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

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

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

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

    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

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

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

  193. abstract def value(): T

    returns

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

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

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

  196. abstract def valueAt(d1: Int, d2: Int, d3: Int): T

  197. abstract def valueAt(d1: Int, d2: Int): T

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

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

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

    kernel
    vf

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

    returns

    Definition Classes
    TensorMath
  201. abstract 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

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

    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

Concrete Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. def +(e: Either[Tensor[T], T]): Tensor[T]

    Definition Classes
    TensorMath
  5. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  6. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  7. 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.

    other
    delta
    returns

  8. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  9. def clone(): Tensor[T]

    Get a new tensor with same value and different storage

    Get a new tensor with same value and different storage

    returns

    new tensor

    Definition Classes
    Tensor → AnyRef
  10. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  11. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  12. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  13. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  14. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  15. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  16. def isTable: Boolean

    Return false because it's not a Table

    Return false because it's not a Table

    returns

    false

    Definition Classes
    TensorActivity
  17. def isTensor: Boolean

    Return true because it's a Tensor implemented from Activity

    Return true because it's a Tensor implemented from Activity

    returns

    true

    Definition Classes
    TensorActivity
  18. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  19. def notEqualValue(value: Double): Boolean

    Element wise inequality between tensor and given value

    Element wise inequality between tensor and given value

    value
    returns

  20. final def notify(): Unit

    Definition Classes
    AnyRef
  21. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  22. 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.

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

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

    Definition Classes
    AnyRef
  25. def toString(): String

    Definition Classes
    AnyRef → Any
  26. def toTable: Table

    Definition Classes
    TensorActivity
  27. 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

    sizes
    returns

    new tensor

  28. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  29. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  30. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from Activity

Inherited from TensorMath[T]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped