DoubleTensor (keanu-project 0.0.24 API)

All Superinterfaces:

io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>, io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>, NumberTensor<java.lang.Double,DoubleTensor>, Tensor<java.lang.Double>

All Known Implementing Classes:

Nd4jDoubleTensor, ScalarDoubleTensor
```
public interface DoubleTensor
extends NumberTensor<java.lang.Double,DoubleTensor>, io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
```

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

Field Summary

Fields
Modifier and Type Field and Description

static DoubleTensor MINUS_ONE_SCALAR

static DoubleTensor ONE_SCALAR

static DoubleTensor TWO_SCALAR

static DoubleTensor ZERO_SCALAR
- Fields inherited from interface io.improbable.keanu.tensor.Tensor
  ONE_BY_ONE_SHAPE, SCALAR_SHAPE, SCALAR_STRIDE

Fields
Modifier and Type	Field and Description
`static DoubleTensor`	`MINUS_ONE_SCALAR`
`static DoubleTensor`	`ONE_SCALAR`
`static DoubleTensor`	`TWO_SCALAR`
`static DoubleTensor`	`ZERO_SCALAR`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`DoubleTensor`	`acos()`
`DoubleTensor`	`acosInPlace()`
`static DoubleTensor`	`arange(double start, double end)`
`static DoubleTensor`	`arange(double start, double end, double stepSize)`
`DoubleTensor`	`asin()`
`DoubleTensor`	`asinInPlace()`
`DoubleTensor`	`atan()`
`DoubleTensor`	`atan2(double y)`
`DoubleTensor`	`atan2(DoubleTensor y)`
`DoubleTensor`	`atan2InPlace(double y)`
`DoubleTensor`	`atan2InPlace(DoubleTensor y)`
`DoubleTensor`	`atanInPlace()`
`double`	`average()`
`DoubleTensor`	`ceil()`
`DoubleTensor`	`ceilInPlace()`
`DoubleTensor`	`choleskyDecomposition()`
`DoubleTensor`	`clamp(DoubleTensor min, DoubleTensor max)`
`DoubleTensor`	`clampInPlace(DoubleTensor min, DoubleTensor max)`
`static DoubleTensor`	`concat(DoubleTensor... toConcat)`
`static DoubleTensor`	`concat(int dimension, DoubleTensor... toConcat)`
`DoubleTensor`	`cos()`
`DoubleTensor`	`cosInPlace()`
`static DoubleTensor`	`create(double... values)`
`static DoubleTensor`	`create(double[] values, long... shape)`
`static DoubleTensor`	`create(double value, long[] shape)`
`double`	`determinant()`
`DoubleTensor`	`diag()`
`DoubleTensor`	`digamma()`
`DoubleTensor`	`digammaInPlace()`
`DoubleTensor`	`div(double value)`
`DoubleTensor`	`divInPlace(double value)`
`DoubleTensor`	`duplicate()`
`boolean`	`equalsWithinEpsilon(DoubleTensor other, double epsilon)`
`DoubleTensor`	`exp()`
`DoubleTensor`	`expInPlace()`
`static DoubleTensor`	`eye(long n)`
`DoubleTensor`	`floor()`
`DoubleTensor`	`floorInPlace()`
`BooleanTensor`	`greaterThan(double value)`
`BooleanTensor`	`greaterThanOrEqual(double value)`
`default BooleanTensor`	`isNaN()`
`BooleanTensor`	`lessThan(double value)`
`BooleanTensor`	`lessThanOrEqual(double value)`
`static DoubleTensor`	`linspace(double start, double end, int numberOfPoints)`
`DoubleTensor`	`log()`
`DoubleTensor`	`logGamma()`
`DoubleTensor`	`logGammaInPlace()`
`DoubleTensor`	`logInPlace()`
`DoubleTensor`	`matrixInverse()`
`DoubleTensor`	`matrixMultiply(DoubleTensor value)`
`double`	`max()`
`static DoubleTensor`	`max(DoubleTensor a, DoubleTensor b)`
`DoubleTensor`	`maxInPlace(DoubleTensor max)`
`double`	`min()`
`static DoubleTensor`	`min(DoubleTensor a, DoubleTensor b)`
`DoubleTensor`	`minInPlace(DoubleTensor min)`
`DoubleTensor`	`minus(double value)`
`DoubleTensor`	`minusInPlace(double value)`
`BooleanTensor`	`notNaN()`
`static DoubleTensor`	`ones(long... shape)`
`DoubleTensor`	`permute(int... rearrange)`
`DoubleTensor`	`plus(double value)`
`DoubleTensor`	`plusInPlace(double value)`
`DoubleTensor`	`pow(double exponent)`
`DoubleTensor`	`pow(DoubleTensor exponent)`
`DoubleTensor`	`powInPlace(double exponent)`
`double`	`product()`
`DoubleTensor`	`reciprocal()`
`DoubleTensor`	`reciprocalInPlace()`
`DoubleTensor`	`replaceNaN(double value)`
`DoubleTensor`	`replaceNaNInPlace(double value)`
`DoubleTensor`	`reshape(long... newShape)`
`default DoubleTensor`	`reverseDiv(double value)`
`default DoubleTensor`	`reverseMinus(double value)`
`DoubleTensor`	`round()`
`DoubleTensor`	`roundInPlace()`
`DoubleTensor`	`safeLogTimes(DoubleTensor y)`
`DoubleTensor`	`safeLogTimesInPlace(DoubleTensor y)`
`static DoubleTensor`	`scalar(double scalarValue)`
`DoubleTensor`	`setAllInPlace(double value)`
`DoubleTensor`	`setValue(java.lang.Double value, long... index)`
`DoubleTensor`	`sigmoid()`
`DoubleTensor`	`sigmoidInPlace()`
`DoubleTensor`	`sin()`
`DoubleTensor`	`sinInPlace()`
`DoubleTensor`	`slice(int dimension, long index)`
`default java.util.List<DoubleTensor>`	`sliceAlongDimension(int dimension, long indexStart, long indexEnd)`
`java.util.List<DoubleTensor>`	`split(int dimension, long... splitAtIndices)`
`DoubleTensor`	`sqrt()`
`DoubleTensor`	`sqrtInPlace()`
`static DoubleTensor`	`stack(int dimension, DoubleTensor... toStack)`
`double`	`standardDeviation()`
`DoubleTensor`	`standardize()`
`DoubleTensor`	`standardizeInPlace()`
`DoubleTensor`	`sum(int... overDimensions)`
`DoubleTensor`	`tan()`
`DoubleTensor`	`tanInPlace()`
`DoubleTensor`	`tensorMultiply(DoubleTensor value, int[] dimsLeft, int[] dimsRight)`
`DoubleTensor`	`times(double value)`
`DoubleTensor`	`timesInPlace(double value)`
`DoubleTensor`	`transpose()`
`static DoubleTensor`	`vector(double... values)`
`static DoubleTensor`	`zeros(long... shape)`

Methods inherited from interface io.improbable.keanu.tensor.NumberTensor
abs, absInPlace, apply, applyInPlace, argMax, argMax, divInPlace, getGreaterThanMask, getGreaterThanOrEqualToMask, getLessThanMask, getLessThanOrEqualToMask, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, minusInPlace, plusInPlace, powInPlace, setWithMask, setWithMaskInPlace, sum, timesInPlace, toDouble, toInteger, unaryMinusInPlace

Methods inherited from interface io.improbable.keanu.tensor.Tensor
asFlatArray, asFlatDoubleArray, asFlatIntegerArray, asFlatList, create, createFilled, elementwiseEquals, elementwiseEquals, elementwiseEquals, getFlattenedView, getLength, getRank, getShape, getValue, getValue, hasSameShapeAs, hasSameShapeAs, isLengthOne, isMatrix, isScalar, isShapePlaceholder, isVector, scalar

Methods inherited from interface io.improbable.keanu.kotlin.NumberOperators
div, minus, plus, times, unaryMinus

Field Detail

MINUS_ONE_SCALAR

static final DoubleTensor MINUS_ONE_SCALAR

ZERO_SCALAR
```
static final DoubleTensor ZERO_SCALAR
```

ONE_SCALAR
```
static final DoubleTensor ONE_SCALAR
```

TWO_SCALAR
```
static final DoubleTensor TWO_SCALAR
```

Method Detail

create

static DoubleTensor create(double value,
                           long[] shape)

create

static DoubleTensor create(double[] values,
                           long... shape)

create

static DoubleTensor create(double... values)

ones

static DoubleTensor ones(long... shape)

eye
```
static DoubleTensor eye(long n)
```

zeros

static DoubleTensor zeros(long... shape)

linspace

static DoubleTensor linspace(double start,
                             double end,
                             int numberOfPoints)

arange
```
static DoubleTensor arange(double start,
                           double end)
```
Parameters:

start - start of range

end - end of range (exclusive)

Returns:

a vector of numbers from start incrementing by one to end (exclusively)

arange
```
static DoubleTensor arange(double start,
                           double end,
                           double stepSize)
```
Parameters:

start - start of range

end - end of range (exclusive)

stepSize - size of step from start to end

Returns:

a vector of numbers starting at start and stepping to end (exclusively)

scalar
```
static DoubleTensor scalar(double scalarValue)
```
Specified by:

scalar in interface Tensor<java.lang.Double>

vector

static DoubleTensor vector(double... values)

stack
```
static DoubleTensor stack(int dimension,
                          DoubleTensor... toStack)
```
Parameters:

dimension - the dimension along which toStack are stacked

toStack - an array of DoubleTensor's of the same shape

Returns:

a DoubleTensor with toStack joined along a new dimension
e.g. A, B, C = DoubleTensor.ones(4, 2)
DoubleTensor.stack(0, A, B, C) gives DoubleTensor.ones(3, 4, 2)
DoubleTensor.stack(1, A, B, C) gives DoubleTensor.ones(4, 3, 2)
DoubleTensor.stack(2, A, B, C) gives DoubleTensor.ones(4, 2, 3)
DoubleTensor.stack(-1, A, B, C) gives DoubleTensor.ones(4, 2, 3)

concat

static DoubleTensor concat(DoubleTensor... toConcat)

concat
```
static DoubleTensor concat(int dimension,
                           DoubleTensor... toConcat)
```
Parameters:

dimension - the dimension along which the tensors will be joined

toConcat - an array of DoubleTensor

Returns:

a DoubleTensor with toConcat joined along an existing dimension
e.g. A, B, C = DoubleTensor.ones(4, 2)
DoubleTensor.concat(0, A, B, C) gives DoubleTensor.ones(12, 2)

min

static DoubleTensor min(DoubleTensor a,
                        DoubleTensor b)

max

static DoubleTensor max(DoubleTensor a,
                        DoubleTensor b)

setValue

DoubleTensor setValue(java.lang.Double value,
                      long... index)

Specified by:: setValue in interface Tensor<java.lang.Double>

reshape
```
DoubleTensor reshape(long... newShape)
```
Specified by:

reshape in interface Tensor<java.lang.Double>

permute

DoubleTensor permute(int... rearrange)

duplicate
```
DoubleTensor duplicate()
```
Specified by:

duplicate in interface Tensor<java.lang.Double>

diag
```
DoubleTensor diag()
```
Specified by:

diag in interface NumberTensor<java.lang.Double,DoubleTensor>

transpose
```
DoubleTensor transpose()
```
Specified by:

transpose in interface NumberTensor<java.lang.Double,DoubleTensor>

sum
```
DoubleTensor sum(int... overDimensions)
```
Specified by:

sum in interface NumberTensor<java.lang.Double,DoubleTensor>

reciprocal
```
DoubleTensor reciprocal()
```

minus
```
DoubleTensor minus(double value)
```
Specified by:

minus in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

reverseMinus
```
default DoubleTensor reverseMinus(double value)
```
Specified by:

reverseMinus in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

plus
```
DoubleTensor plus(double value)
```
Specified by:

plus in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

times
```
DoubleTensor times(double value)
```
Specified by:

times in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

div
```
DoubleTensor div(double value)
```
Specified by:

div in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

reverseDiv
```
default DoubleTensor reverseDiv(double value)
```
Specified by:

reverseDiv in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

matrixMultiply
```
DoubleTensor matrixMultiply(DoubleTensor value)
```
Specified by:

matrixMultiply in interface NumberTensor<java.lang.Double,DoubleTensor>

tensorMultiply

DoubleTensor tensorMultiply(DoubleTensor value,
                            int[] dimsLeft,
                            int[] dimsRight)

Specified by:: tensorMultiply in interface NumberTensor<java.lang.Double,DoubleTensor>

pow
```
DoubleTensor pow(DoubleTensor exponent)
```
Specified by:

pow in interface io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>

pow
```
DoubleTensor pow(double exponent)
```
Specified by:

pow in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

sqrt
```
DoubleTensor sqrt()
```

log
```
DoubleTensor log()
```
Specified by:

log in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

safeLogTimes

DoubleTensor safeLogTimes(DoubleTensor y)

logGamma
```
DoubleTensor logGamma()
```

digamma
```
DoubleTensor digamma()
```

sin
```
DoubleTensor sin()
```
Specified by:

sin in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

cos
```
DoubleTensor cos()
```
Specified by:

cos in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

tan
```
DoubleTensor tan()
```

atan
```
DoubleTensor atan()
```

atan2
```
DoubleTensor atan2(double y)
```

atan2
```
DoubleTensor atan2(DoubleTensor y)
```

asin
```
DoubleTensor asin()
```
Specified by:

asin in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

acos
```
DoubleTensor acos()
```
Specified by:

acos in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

exp
```
DoubleTensor exp()
```
Specified by:

exp in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>

matrixInverse
```
DoubleTensor matrixInverse()
```

max
```
double max()
```

min
```
double min()
```

average
```
double average()
```

standardDeviation
```
double standardDeviation()
```

equalsWithinEpsilon

boolean equalsWithinEpsilon(DoubleTensor other,
                            double epsilon)

standardize
```
DoubleTensor standardize()
```

replaceNaN
```
DoubleTensor replaceNaN(double value)
```

clamp

DoubleTensor clamp(DoubleTensor min,
                   DoubleTensor max)

ceil
```
DoubleTensor ceil()
```

floor
```
DoubleTensor floor()
```

round
```
DoubleTensor round()
```

sigmoid
```
DoubleTensor sigmoid()
```

choleskyDecomposition
```
DoubleTensor choleskyDecomposition()
```

determinant
```
double determinant()
```

product
```
double product()
```

slice

DoubleTensor slice(int dimension,
                   long index)

Specified by:: slice in interface Tensor<java.lang.Double>

split

java.util.List<DoubleTensor> split(int dimension,
                                   long... splitAtIndices)

sliceAlongDimension

default java.util.List<DoubleTensor> sliceAlongDimension(int dimension,
                                                         long indexStart,
                                                         long indexEnd)

reciprocalInPlace
```
DoubleTensor reciprocalInPlace()
```

minusInPlace

DoubleTensor minusInPlace(double value)

plusInPlace

DoubleTensor plusInPlace(double value)

timesInPlace

DoubleTensor timesInPlace(double value)

divInPlace
```
DoubleTensor divInPlace(double value)
```

powInPlace

DoubleTensor powInPlace(double exponent)

sqrtInPlace
```
DoubleTensor sqrtInPlace()
```

logInPlace
```
DoubleTensor logInPlace()
```

safeLogTimesInPlace

DoubleTensor safeLogTimesInPlace(DoubleTensor y)

logGammaInPlace
```
DoubleTensor logGammaInPlace()
```

digammaInPlace
```
DoubleTensor digammaInPlace()
```

sinInPlace
```
DoubleTensor sinInPlace()
```

cosInPlace
```
DoubleTensor cosInPlace()
```

tanInPlace
```
DoubleTensor tanInPlace()
```

atanInPlace
```
DoubleTensor atanInPlace()
```

atan2InPlace
```
DoubleTensor atan2InPlace(double y)
```

atan2InPlace

DoubleTensor atan2InPlace(DoubleTensor y)

asinInPlace
```
DoubleTensor asinInPlace()
```

acosInPlace
```
DoubleTensor acosInPlace()
```

expInPlace
```
DoubleTensor expInPlace()
```

minInPlace

DoubleTensor minInPlace(DoubleTensor min)

maxInPlace

DoubleTensor maxInPlace(DoubleTensor max)

clampInPlace

DoubleTensor clampInPlace(DoubleTensor min,
                          DoubleTensor max)

ceilInPlace
```
DoubleTensor ceilInPlace()
```

floorInPlace
```
DoubleTensor floorInPlace()
```

roundInPlace
```
DoubleTensor roundInPlace()
```

sigmoidInPlace
```
DoubleTensor sigmoidInPlace()
```

standardizeInPlace
```
DoubleTensor standardizeInPlace()
```

replaceNaNInPlace

DoubleTensor replaceNaNInPlace(double value)

setAllInPlace

DoubleTensor setAllInPlace(double value)

lessThan
```
BooleanTensor lessThan(double value)
```

lessThanOrEqual

BooleanTensor lessThanOrEqual(double value)

greaterThan

BooleanTensor greaterThan(double value)

greaterThanOrEqual

BooleanTensor greaterThanOrEqual(double value)

notNaN
```
BooleanTensor notNaN()
```

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

Interface DoubleTensor

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

Field Detail

MINUS_ONE_SCALAR

ZERO_SCALAR

ONE_SCALAR

TWO_SCALAR

Method Detail

create

create

create

ones

eye

zeros

linspace

arange

arange

scalar

vector

stack

concat

concat

min

max

setValue

reshape

permute

duplicate

diag

transpose

sum

reciprocal

minus

reverseMinus

plus

times

div

reverseDiv

matrixMultiply

tensorMultiply

pow

pow

sqrt

log

safeLogTimes

logGamma

digamma

sin

cos

tan

atan

atan2

atan2

asin

acos

exp

matrixInverse

max

min

average

standardDeviation

equalsWithinEpsilon

standardize

replaceNaN

clamp

ceil

floor

round

sigmoid

choleskyDecomposition

determinant

product

slice