FloatingPointTensor (keanu-project 0.0.26 API)

All Superinterfaces:

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

All Known Subinterfaces:

DoubleTensor

All Known Implementing Classes:

JVMDoubleTensor, JVMFloatingPointTensor, Nd4jDoubleTensor, Nd4jFloatingPointTensor
```
public interface FloatingPointTensor<N extends java.lang.Number,T extends FloatingPointTensor<N,T>>
extends NumberTensor<N,T>, io.improbable.keanu.kotlin.DoubleOperators<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`	`acos()`
`default T`	`acosh()`
`T`	`acoshInPlace()`
`T`	`acosInPlace()`
`default T`	`asin()`
`default T`	`asinh()`
`T`	`asinhInPlace()`
`T`	`asinInPlace()`
`default T`	`atan()`
`default T`	`atan2(N y)`
`default T`	`atan2(T y)`
`T`	`atan2InPlace(N y)`
`T`	`atan2InPlace(T y)`
`default T`	`atanh()`
`T`	`atanhInPlace()`
`T`	`atanInPlace()`
`default T`	`ceil()`
`T`	`ceilInPlace()`
`T`	`choleskyDecomposition()`
`default T`	`cos()`
`default T`	`cosh()`
`T`	`coshInPlace()`
`T`	`cosInPlace()`
`N`	`determinant()`
`default T`	`digamma()`
`T`	`digammaInPlace()`
`default T`	`exp()`
`default T`	`exp2()`
`T`	`exp2InPlace()`
`T`	`expInPlace()`
`default T`	`expM1()`
`T`	`expM1InPlace()`
`default T`	`floor()`
`T`	`floorInPlace()`
`BooleanTensor`	`isFinite()`
`BooleanTensor`	`isInfinite()`
`default BooleanTensor`	`isNaN()`
`BooleanTensor`	`isNegativeInfinity()`
`BooleanTensor`	`isPositiveInfinity()`
`default T`	`log()`
`default T`	`log10()`
`T`	`log10InPlace()`
`default T`	`log1p()`
`T`	`log1pInPlace()`
`default T`	`log2()`
`T`	`log2InPlace()`
`default T`	`logAddExp(T that)`
`default T`	`logAddExp2(T that)`
`T`	`logAddExp2InPlace(T that)`
`T`	`logAddExpInPlace(T that)`
`default T`	`logGamma()`
`T`	`logGammaInPlace()`
`T`	`logInPlace()`
`T`	`matrixInverse()`
`int`	`nanArgMax()`
`IntegerTensor`	`nanArgMax(int axis)`
`int`	`nanArgMin()`
`IntegerTensor`	`nanArgMin(int axis)`
`BooleanTensor`	`notNaN()`
`default T`	`reciprocal()`
`T`	`reciprocalInPlace()`
`default T`	`replaceNaN(N value)`
`T`	`replaceNaNInPlace(N value)`
`default T`	`round()`
`T`	`roundInPlace()`
`default T`	`sigmoid()`
`T`	`sigmoidInPlace()`
`default T`	`sin()`
`default T`	`sinh()`
`T`	`sinhInPlace()`
`T`	`sinInPlace()`
`default T`	`sqrt()`
`T`	`sqrtInPlace()`
`default T`	`standardize()`
`T`	`standardizeInPlace()`
`default T`	`tan()`
`default T`	`tanh()`
`T`	`tanhInPlace()`
`T`	`tanInPlace()`

Methods inherited from interface io.improbable.keanu.tensor.NumberTensor
abs, absInPlace, apply, applyInPlace, argMax, argMax, argMin, argMin, asFlatDoubleArray, asFlatIntegerArray, average, clamp, clampInPlace, cumProd, cumProdInPlace, cumSum, cumSumInPlace, div, div, divInPlace, divInPlace, equalsWithinEpsilon, greaterThan, greaterThan, greaterThanMask, greaterThanOrEqual, greaterThanOrEqual, greaterThanOrEqualToMask, lessThan, lessThan, lessThanMask, lessThanOrEqual, lessThanOrEqual, lessThanOrEqualToMask, matrixMultiply, max, max, maxInPlace, min, min, minInPlace, minus, minus, minusInPlace, minusInPlace, plus, plus, plusInPlace, plusInPlace, pow, pow, powInPlace, powInPlace, product, product, reverseDiv, reverseDiv, reverseDivInPlace, reverseDivInPlace, reverseMinus, reverseMinus, reverseMinusInPlace, reverseMinusInPlace, safeLogTimes, safeLogTimesInPlace, setAllInPlace, setWithMask, setWithMaskInPlace, standardDeviation, sum, sum, tensorMultiply, times, times, timesInPlace, timesInPlace, toDouble, toInteger, unaryMinus, 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

Methods inherited from interface io.improbable.keanu.kotlin.DoubleOperators
div, minus, plus, pow, reverseDiv, reverseMinus, times

Method Detail

replaceNaN
```
default T replaceNaN(N value)
```

replaceNaNInPlace
```
T replaceNaNInPlace(N value)
```

notNaN
```
BooleanTensor notNaN()
```

isNaN
```
default BooleanTensor isNaN()
```

isFinite
```
BooleanTensor isFinite()
```

isInfinite
```
BooleanTensor isInfinite()
```

isNegativeInfinity
```
BooleanTensor isNegativeInfinity()
```

isPositiveInfinity
```
BooleanTensor isPositiveInfinity()
```

nanArgMax
```
IntegerTensor nanArgMax(int axis)
```

nanArgMax
```
int nanArgMax()
```

nanArgMin
```
IntegerTensor nanArgMin(int axis)
```

nanArgMin
```
int nanArgMin()
```

reciprocal
```
default T reciprocal()
```

reciprocalInPlace
```
T reciprocalInPlace()
```

sqrt
```
default T sqrt()
```

sqrtInPlace
```
T sqrtInPlace()
```

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

log in interface io.improbable.keanu.kotlin.DoubleOperators<T extends FloatingPointTensor<N,T>>

logInPlace
```
T logInPlace()
```

logGamma
```
default T logGamma()
```

logGammaInPlace
```
T logGammaInPlace()
```

digamma
```
default T digamma()
```

digammaInPlace
```
T digammaInPlace()
```

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

sin in interface io.improbable.keanu.kotlin.DoubleOperators<T extends FloatingPointTensor<N,T>>

sinInPlace
```
T sinInPlace()
```

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

cos in interface io.improbable.keanu.kotlin.DoubleOperators<T extends FloatingPointTensor<N,T>>

cosInPlace
```
T cosInPlace()
```

tan
```
default T tan()
```

tanInPlace
```
T tanInPlace()
```

atan
```
default T atan()
```

atanInPlace
```
T atanInPlace()
```

atan2
```
default T atan2(N y)
```

atan2InPlace
```
T atan2InPlace(N y)
```

atan2
```
default T atan2(T y)
```

atan2InPlace
```
T atan2InPlace(T y)
```

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

asin in interface io.improbable.keanu.kotlin.DoubleOperators<T extends FloatingPointTensor<N,T>>

asinInPlace
```
T asinInPlace()
```

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

acos in interface io.improbable.keanu.kotlin.DoubleOperators<T extends FloatingPointTensor<N,T>>

acosInPlace
```
T acosInPlace()
```

sinh
```
default T sinh()
```

sinhInPlace
```
T sinhInPlace()
```

cosh
```
default T cosh()
```

coshInPlace
```
T coshInPlace()
```

tanh
```
default T tanh()
```

tanhInPlace
```
T tanhInPlace()
```

asinh
```
default T asinh()
```

asinhInPlace
```
T asinhInPlace()
```

acosh
```
default T acosh()
```

acoshInPlace
```
T acoshInPlace()
```

atanh
```
default T atanh()
```

atanhInPlace
```
T atanhInPlace()
```

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

exp in interface io.improbable.keanu.kotlin.DoubleOperators<T extends FloatingPointTensor<N,T>>

expInPlace
```
T expInPlace()
```

logAddExp2
```
default T logAddExp2(T that)
```

logAddExp2InPlace
```
T logAddExp2InPlace(T that)
```

logAddExp
```
default T logAddExp(T that)
```

logAddExpInPlace
```
T logAddExpInPlace(T that)
```

log1p
```
default T log1p()
```

log1pInPlace
```
T log1pInPlace()
```

log2
```
default T log2()
```

log2InPlace
```
T log2InPlace()
```

log10
```
default T log10()
```

log10InPlace
```
T log10InPlace()
```

exp2
```
default T exp2()
```

exp2InPlace
```
T exp2InPlace()
```

expM1
```
default T expM1()
```

expM1InPlace
```
T expM1InPlace()
```

ceil
```
default T ceil()
```

ceilInPlace
```
T ceilInPlace()
```

floor
```
default T floor()
```

floorInPlace
```
T floorInPlace()
```

round
```
default T round()
```
Returns:

The tensor with the elements rounded half up e.g. 1.5 is 2 e.g. -2.5 is -3

roundInPlace
```
T roundInPlace()
```

sigmoid
```
default T sigmoid()
```

sigmoidInPlace
```
T sigmoidInPlace()
```

choleskyDecomposition
```
T choleskyDecomposition()
```

determinant
```
N determinant()
```

matrixInverse
```
T matrixInverse()
```

standardize
```
default T standardize()
```

standardizeInPlace
```
T standardizeInPlace()
```

Interface FloatingPointTensor<N extends java.lang.Number,T extends FloatingPointTensor<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.NumberTensor

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

Methods inherited from interface io.improbable.keanu.kotlin.DoubleOperators

Method Detail

replaceNaN

replaceNaNInPlace

notNaN

isNaN

isFinite

isInfinite

isNegativeInfinity

isPositiveInfinity

nanArgMax

nanArgMax

nanArgMin

nanArgMin

reciprocal

reciprocalInPlace

sqrt

sqrtInPlace

log

logInPlace

logGamma

logGammaInPlace

digamma

digammaInPlace

sin

sinInPlace

cos

cosInPlace

tan

tanInPlace

atan

atanInPlace

atan2

atan2InPlace

atan2

atan2InPlace

asin

asinInPlace

acos

acosInPlace

sinh

sinhInPlace

cosh

coshInPlace

tanh

tanhInPlace

asinh

asinhInPlace

acosh

acoshInPlace

atanh

atanhInPlace

exp

expInPlace

logAddExp2

logAddExp2InPlace

logAddExp

logAddExpInPlace

log1p

log1pInPlace

log2

log2InPlace

log10

log10InPlace

exp2

exp2InPlace

expM1

expM1InPlace

ceil

ceilInPlace

floor

floorInPlace