NumberTensor (keanu-project 0.0.26 API)

All Superinterfaces:

io.improbable.keanu.kotlin.NumberOperators<T>, Tensor<N,T>

All Known Subinterfaces:

DoubleTensor, FixedPointTensor<N,T>, FloatingPointTensor<N,T>, IntegerTensor

All Known Implementing Classes:

JVMDoubleTensor, JVMFloatingPointTensor, JVMNumberTensor, Nd4jDoubleTensor, Nd4jFixedPointTensor, Nd4jFloatingPointTensor, Nd4jIntegerTensor, Nd4jNumberTensor, ScalarIntegerTensor
```
public interface NumberTensor<N extends java.lang.Number,T extends NumberTensor<N,T>>
extends Tensor<N,T>, io.improbable.keanu.kotlin.NumberOperators<T>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface io.improbable.keanu.tensor.Tensor
  Tensor.FlattenedView<N>

Field Summary
- Fields inherited from interface io.improbable.keanu.tensor.Tensor
  ONE_BY_ONE_SHAPE, SCALAR_SHAPE, SCALAR_STRIDE

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default T`	`abs()`
`T`	`absInPlace()`
`default T`	`apply(java.util.function.Function<N,N> function)`
`T`	`applyInPlace(java.util.function.Function<N,N> function)`
`int`	`argMax()` Find the index into the flattened array of the tensor of the largest value, e.g.
`IntegerTensor`	`argMax(int axis)` Find the indices into the tensor of the largest values in a specified axis (dimension), e.g.
`int`	`argMin()`
`IntegerTensor`	`argMin(int axis)`
`double[]`	`asFlatDoubleArray()`
`int[]`	`asFlatIntegerArray()`
`N`	`average()`
`default T`	`clamp(T min, T max)`
`T`	`clampInPlace(T min, T max)`
`default T`	`cumProd(int requestedDimension)`
`T`	`cumProdInPlace(int dimension)`
`default T`	`cumSum(int requestedDimension)`
`T`	`cumSumInPlace(int dimension)`
`default T`	`div(N value)`
`default T`	`div(T value)`
`T`	`divInPlace(N value)`
`T`	`divInPlace(T that)`
`boolean`	`equalsWithinEpsilon(T other, N epsilon)`
`BooleanTensor`	`greaterThan(N value)`
`BooleanTensor`	`greaterThan(T value)`
`T`	`greaterThanMask(T greaterThanThis)`
`BooleanTensor`	`greaterThanOrEqual(N value)`
`BooleanTensor`	`greaterThanOrEqual(T value)`
`T`	`greaterThanOrEqualToMask(T greaterThanThis)`
`BooleanTensor`	`lessThan(N value)`
`BooleanTensor`	`lessThan(T value)`
`T`	`lessThanMask(T lessThanThis)`
`BooleanTensor`	`lessThanOrEqual(N value)`
`BooleanTensor`	`lessThanOrEqual(T value)`
`T`	`lessThanOrEqualToMask(T lessThanThis)`
`T`	`matrixMultiply(T value)`
`N`	`max()`
`default T`	`max(T max)`
`T`	`maxInPlace(T max)`
`N`	`min()`
`default T`	`min(T min)`
`T`	`minInPlace(T min)`
`default T`	`minus(N value)`
`default T`	`minus(T that)`
`T`	`minusInPlace(N value)`
`T`	`minusInPlace(T that)`
`default T`	`plus(N value)`
`default T`	`plus(T that)`
`T`	`plusInPlace(N value)`
`T`	`plusInPlace(T that)`
`default T`	`pow(N exponent)`
`default T`	`pow(T exponent)`
`T`	`powInPlace(N exponent)`
`T`	`powInPlace(T exponent)`
`N`	`product()`
`T`	`product(int... overDimensions)`
`default T`	`reverseDiv(N value)`
`default T`	`reverseDiv(T value)`
`T`	`reverseDivInPlace(N value)`
`T`	`reverseDivInPlace(T value)`
`default T`	`reverseMinus(N value)`
`default T`	`reverseMinus(T value)`
`T`	`reverseMinusInPlace(N value)`
`T`	`reverseMinusInPlace(T value)`
`default T`	`safeLogTimes(T y)` This is identical to log().times(y), except that it changes NaN results to 0.
`T`	`safeLogTimesInPlace(T y)`
`T`	`setAllInPlace(N value)`
`default T`	`setWithMask(T mask, N value)`
`T`	`setWithMaskInPlace(T mask, N value)`
`N`	`standardDeviation()`
`N`	`sum()`
`T`	`sum(int... overDimensions)`
`T`	`tensorMultiply(T value, int[] dimLeft, int[] dimsRight)`
`default T`	`times(N value)`
`default T`	`times(T that)`
`T`	`timesInPlace(N value)`
`T`	`timesInPlace(T that)`
`DoubleTensor`	`toDouble()`
`IntegerTensor`	`toInteger()`
`default T`	`unaryMinus()`
`T`	`unaryMinusInPlace()`

Methods inherited from interface io.improbable.keanu.tensor.Tensor
asFlatArray, asFlatList, broadcast, create, createFilled, diag, duplicate, elementwiseEquals, elementwiseEquals, elementwiseEquals, expandDims, get, getFlattenedView, getLength, getRank, getShape, getStride, getValue, hasSameShapeAs, hasSameShapeAs, isLengthOne, isMatrix, isScalar, isVector, moveAxis, permute, reshape, scalar, scalar, setValue, slice, slice, slice, sliceAlongDimension, split, squeeze, swapAxis, take, transpose

Method Detail

toDouble
```
DoubleTensor toDouble()
```

toInteger
```
IntegerTensor toInteger()
```

asFlatDoubleArray
```
double[] asFlatDoubleArray()
```

asFlatIntegerArray
```
int[] asFlatIntegerArray()
```

sum
```
N sum()
```

sum
```
T sum(int... overDimensions)
```

cumSum

default T cumSum(int requestedDimension)

cumSumInPlace
```
T cumSumInPlace(int dimension)
```

product
```
N product()
```

product
```
T product(int... overDimensions)
```

cumProd

default T cumProd(int requestedDimension)

cumProdInPlace
```
T cumProdInPlace(int dimension)
```

max
```
N max()
```

max
```
default T max(T max)
```

maxInPlace
```
T maxInPlace(T max)
```

min
```
N min()
```

min
```
default T min(T min)
```

minInPlace
```
T minInPlace(T min)
```

clamp

default T clamp(T min,
                T max)

clampInPlace

T clampInPlace(T min,
               T max)

matrixMultiply
```
T matrixMultiply(T value)
```

tensorMultiply

T tensorMultiply(T value,
                 int[] dimLeft,
                 int[] dimsRight)

abs
```
default T abs()
```

absInPlace
```
T absInPlace()
```

minus
```
default T minus(N value)
```

minusInPlace
```
T minusInPlace(N value)
```

minus
```
default T minus(T that)
```
Specified by:

minus in interface io.improbable.keanu.kotlin.NumberOperators<T extends NumberTensor<N,T>>

minusInPlace
```
T minusInPlace(T that)
```

reverseMinus
```
default T reverseMinus(T value)
```

reverseMinusInPlace
```
T reverseMinusInPlace(T value)
```

reverseMinus
```
default T reverseMinus(N value)
```

reverseMinusInPlace
```
T reverseMinusInPlace(N value)
```

plus
```
default T plus(N value)
```

plusInPlace
```
T plusInPlace(N value)
```

plus
```
default T plus(T that)
```
Specified by:

plus in interface io.improbable.keanu.kotlin.NumberOperators<T extends NumberTensor<N,T>>

plusInPlace
```
T plusInPlace(T that)
```

unaryMinus
```
default T unaryMinus()
```
Specified by:

unaryMinus in interface io.improbable.keanu.kotlin.NumberOperators<T extends NumberTensor<N,T>>

unaryMinusInPlace
```
T unaryMinusInPlace()
```

times
```
default T times(N value)
```

timesInPlace
```
T timesInPlace(N value)
```

times
```
default T times(T that)
```
Specified by:

times in interface io.improbable.keanu.kotlin.NumberOperators<T extends NumberTensor<N,T>>

timesInPlace
```
T timesInPlace(T that)
```

div
```
default T div(N value)
```

divInPlace
```
T divInPlace(N value)
```

div
```
default T div(T value)
```
Specified by:

div in interface io.improbable.keanu.kotlin.NumberOperators<T extends NumberTensor<N,T>>

divInPlace
```
T divInPlace(T that)
```

reverseDiv
```
default T reverseDiv(N value)
```

reverseDivInPlace
```
T reverseDivInPlace(N value)
```

reverseDiv
```
default T reverseDiv(T value)
```

reverseDivInPlace
```
T reverseDivInPlace(T value)
```

pow
```
default T pow(T exponent)
```
Specified by:

pow in interface io.improbable.keanu.kotlin.NumberOperators<T extends NumberTensor<N,T>>

powInPlace
```
T powInPlace(T exponent)
```

pow
```
default T pow(N exponent)
```

powInPlace
```
T powInPlace(N exponent)
```

average
```
N average()
```

standardDeviation
```
N standardDeviation()
```

argMax
```
int argMax()
```
Find the index into the flattened array of the tensor of the largest value, e.g.
```
 DoubleTensor tensor = DoubleTensor.arange(0, 6).reshape(2, 3);
 // [[0., 1., 2.],
 //  [3., 4., 5.]]
 IntegerTensor max = tensor.argMax();
 // [[5]]
 
```
Returns:

A scalar tensor with the index of the largest value. If there are multiple largest values, it will be the first index.

argMax
```
IntegerTensor argMax(int axis)
```
Find the indices into the tensor of the largest values in a specified axis (dimension), e.g.
```
 DoubleTensor tensor = DoubleTensor.arange(0, 6).reshape(2, 3);
 // [[0., 1., 2.],
 //  [3., 4., 5.]]
 IntegerTensor maxesFor0 = tensor.argMax(0);
 // [[1, 1, 1]]
 IntegerTensor maxFor1 = tensor.argMax(1);
 // [[2, 2]]
 
```
Parameters:

axis - The axis (dimension) to find the largest values in

Returns:

A tensor where each value is the location of the maximum value in the vector at that location in the specified dimension in the original tensor. If there are multiple largest values in this vector, it will be the first index.

See Also:

An article about argmax over an axis in numpy

argMin
```
int argMin()
```

argMin
```
IntegerTensor argMin(int axis)
```

setWithMask

default T setWithMask(T mask,
                      N value)

setWithMaskInPlace

T setWithMaskInPlace(T mask,
                     N value)

apply

default T apply(java.util.function.Function<N,N> function)

applyInPlace

T applyInPlace(java.util.function.Function<N,N> function)

setAllInPlace
```
T setAllInPlace(N value)
```

safeLogTimes
```
default T safeLogTimes(T y)
```
This is identical to log().times(y), except that it changes NaN results to 0. This is important when calculating 0log0, which should return 0 See https://arcsecond.wordpress.com/2009/03/19/0log0-0-for-real/ for some mathematical justification

Parameters:

y - The tensor value to multiply by

Returns:

the log of this tensor multiplied by y

safeLogTimesInPlace
```
T safeLogTimesInPlace(T y)
```

equalsWithinEpsilon

boolean equalsWithinEpsilon(T other,
                            N epsilon)

lessThan
```
BooleanTensor lessThan(T value)
```

lessThanOrEqual

BooleanTensor lessThanOrEqual(T value)

greaterThan
```
BooleanTensor greaterThan(T value)
```

greaterThanOrEqual

BooleanTensor greaterThanOrEqual(T value)

lessThan
```
BooleanTensor lessThan(N value)
```

lessThanOrEqual

BooleanTensor lessThanOrEqual(N value)

greaterThan
```
BooleanTensor greaterThan(N value)
```

greaterThanOrEqual

BooleanTensor greaterThanOrEqual(N value)

greaterThanMask
```
T greaterThanMask(T greaterThanThis)
```

greaterThanOrEqualToMask

T greaterThanOrEqualToMask(T greaterThanThis)

lessThanMask
```
T lessThanMask(T lessThanThis)
```

lessThanOrEqualToMask

T lessThanOrEqualToMask(T lessThanThis)

Interface NumberTensor<N extends java.lang.Number,T extends NumberTensor<N,T>>

Nested Class Summary

Nested classes/interfaces inherited from interface io.improbable.keanu.tensor.Tensor

Field Summary

Fields inherited from interface io.improbable.keanu.tensor.Tensor

Method Summary

Methods inherited from interface io.improbable.keanu.tensor.Tensor

Method Detail

toDouble

toInteger

asFlatDoubleArray

asFlatIntegerArray

sum

sum

cumSum

cumSumInPlace

product

product

cumProd

cumProdInPlace

max

max

maxInPlace

min

min

minInPlace

clamp

clampInPlace

matrixMultiply

tensorMultiply

abs

absInPlace

minus

minusInPlace

minus

minusInPlace

reverseMinus

reverseMinusInPlace

reverseMinus

reverseMinusInPlace

plus

plusInPlace

plus

plusInPlace

unaryMinus

unaryMinusInPlace

times

timesInPlace

times

timesInPlace

div

divInPlace

div

divInPlace

reverseDiv

reverseDivInPlace

reverseDiv

reverseDivInPlace

pow

powInPlace

pow

powInPlace

average

standardDeviation

argMax

argMax

argMin

argMin

setWithMask

setWithMaskInPlace

apply

applyInPlace

setAllInPlace

safeLogTimes

safeLogTimesInPlace

equalsWithinEpsilon

lessThan

lessThanOrEqual

greaterThan

greaterThanOrEqual