Nd4jDoubleTensor (keanu-project 0.0.24 API)

java.lang.Object
- io.improbable.keanu.tensor.dbl.Nd4jDoubleTensor

All Implemented Interfaces:

io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>, io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>, DoubleTensor, NumberTensor<java.lang.Double,DoubleTensor>, Tensor<java.lang.Double>
```
public class Nd4jDoubleTensor
extends java.lang.Object
implements DoubleTensor
```
Class for representing n-dimensional arrays of doubles. This is backed by Nd4j.

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

Field Summary
- Fields inherited from interface io.improbable.keanu.tensor.dbl.DoubleTensor
  MINUS_ONE_SCALAR, ONE_SCALAR, TWO_SCALAR, ZERO_SCALAR
- Fields inherited from interface io.improbable.keanu.tensor.Tensor
  ONE_BY_ONE_SHAPE, SCALAR_SHAPE, SCALAR_STRIDE

Constructor Summary

Constructors
Constructor and Description

Nd4jDoubleTensor(double[] data, long[] shape)

Nd4jDoubleTensor(org.nd4j.linalg.api.ndarray.INDArray tensor)

Constructors
Constructor and Description
`Nd4jDoubleTensor(double[] data, long[] shape)`
`Nd4jDoubleTensor(org.nd4j.linalg.api.ndarray.INDArray tensor)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`DoubleTensor`	`abs()`
`DoubleTensor`	`absInPlace()`
`DoubleTensor`	`acos()`
`DoubleTensor`	`acosInPlace()`
`DoubleTensor`	`apply(java.util.function.Function<java.lang.Double,java.lang.Double> function)`
`DoubleTensor`	`applyInPlace(java.util.function.Function<java.lang.Double,java.lang.Double> function)`
`static Nd4jDoubleTensor`	`arange(double start, double end)`
`static Nd4jDoubleTensor`	`arange(double start, double end, double stepSize)`
`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.
`java.lang.Double[]`	`asFlatArray()`
`double[]`	`asFlatDoubleArray()`
`int[]`	`asFlatIntegerArray()`
`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)`
`DoubleTensor`	`cos()`
`DoubleTensor`	`cosInPlace()`
`static Nd4jDoubleTensor`	`create(double[] values, long[] shape)`
`static Nd4jDoubleTensor`	`create(double value, long[] shape)`
`double`	`determinant()`
`DoubleTensor`	`diag()`
`DoubleTensor`	`digamma()`
`DoubleTensor`	`digammaInPlace()`
`DoubleTensor`	`div(double value)`
`DoubleTensor`	`div(DoubleTensor that)`
`DoubleTensor`	`divInPlace(double value)`
`DoubleTensor`	`divInPlace(DoubleTensor that)`
`DoubleTensor`	`duplicate()`
`BooleanTensor`	`elementwiseEquals(java.lang.Double value)`
`BooleanTensor`	`elementwiseEquals(Tensor that)`
`boolean`	`equals(java.lang.Object o)`
`boolean`	`equalsWithinEpsilon(DoubleTensor o, double epsilon)`
`DoubleTensor`	`exp()`
`DoubleTensor`	`expInPlace()`
`static Nd4jDoubleTensor`	`eye(long n)`
`DoubleTensor`	`floor()`
`DoubleTensor`	`floorInPlace()`
`Tensor.FlattenedView<java.lang.Double>`	`getFlattenedView()`
`DoubleTensor`	`getGreaterThanMask(DoubleTensor greaterThanThis)`
`DoubleTensor`	`getGreaterThanOrEqualToMask(DoubleTensor greaterThanOrEqualToThis)`
`long`	`getLength()`
`DoubleTensor`	`getLessThanMask(DoubleTensor lessThanThis)`
`DoubleTensor`	`getLessThanOrEqualToMask(DoubleTensor lessThanOrEqualToThis)`
`int`	`getRank()`
`long[]`	`getShape()`
`java.lang.Double`	`getValue(long... index)`
`BooleanTensor`	`greaterThan(double value)`
`BooleanTensor`	`greaterThan(DoubleTensor value)`
`BooleanTensor`	`greaterThanOrEqual(double value)`
`BooleanTensor`	`greaterThanOrEqual(DoubleTensor value)`
`int`	`hashCode()`
`boolean`	`isShapePlaceholder()`
`BooleanTensor`	`lessThan(double value)`
`BooleanTensor`	`lessThan(DoubleTensor value)`
`BooleanTensor`	`lessThanOrEqual(double value)`
`BooleanTensor`	`lessThanOrEqual(DoubleTensor value)`
`static Nd4jDoubleTensor`	`linspace(double start, double end, int numberOfPoints)`
`DoubleTensor`	`log()`
`DoubleTensor`	`logGamma()`
`DoubleTensor`	`logGammaInPlace()`
`DoubleTensor`	`logInPlace()`
`DoubleTensor`	`matrixInverse()`
`DoubleTensor`	`matrixMultiply(DoubleTensor value)`
`double`	`max()`
`DoubleTensor`	`maxInPlace(DoubleTensor max)`
`double`	`min()`
`DoubleTensor`	`minInPlace(DoubleTensor min)`
`DoubleTensor`	`minus(double value)`
`DoubleTensor`	`minus(DoubleTensor that)`
`DoubleTensor`	`minusInPlace(double value)`
`DoubleTensor`	`minusInPlace(DoubleTensor that)`
`BooleanTensor`	`notNaN()`
`static Nd4jDoubleTensor`	`ones(long... shape)`
`DoubleTensor`	`permute(int... rearrange)`
`DoubleTensor`	`plus(double value)`
`DoubleTensor`	`plus(DoubleTensor that)`
`DoubleTensor`	`plusInPlace(double value)`
`DoubleTensor`	`plusInPlace(DoubleTensor that)`
`DoubleTensor`	`pow(double exponent)`
`DoubleTensor`	`pow(DoubleTensor exponent)`
`DoubleTensor`	`powInPlace(double exponent)`
`DoubleTensor`	`powInPlace(DoubleTensor exponent)`
`double`	`product()`
`DoubleTensor`	`reciprocal()`
`DoubleTensor`	`reciprocalInPlace()`
`DoubleTensor`	`replaceNaN(double value)`
`DoubleTensor`	`replaceNaNInPlace(double value)`
`DoubleTensor`	`reshape(long... newShape)`
`DoubleTensor`	`round()`
`DoubleTensor`	`roundInPlace()`
`DoubleTensor`	`safeLogTimes(DoubleTensor y)`
`DoubleTensor`	`safeLogTimesInPlace(DoubleTensor y)` This is identical to log().times(y), except that it changes NaN results to 0.
`java.lang.Double`	`scalar()`
`static Nd4jDoubleTensor`	`scalar(double scalarValue)`
`DoubleTensor`	`setAllInPlace(double value)`
`DoubleTensor`	`setValue(java.lang.Double value, long... index)`
`DoubleTensor`	`setWithMask(DoubleTensor mask, java.lang.Double value)`
`DoubleTensor`	`setWithMaskInPlace(DoubleTensor mask, java.lang.Double value)`
`DoubleTensor`	`sigmoid()`
`DoubleTensor`	`sigmoidInPlace()`
`DoubleTensor`	`sin()`
`DoubleTensor`	`sinInPlace()`
`DoubleTensor`	`slice(int dimension, long index)`
`java.util.List<DoubleTensor>`	`split(int dimension, long... splitAtIndices)`
`DoubleTensor`	`sqrt()`
`DoubleTensor`	`sqrtInPlace()`
`double`	`standardDeviation()`
`DoubleTensor`	`standardize()`
`DoubleTensor`	`standardizeInPlace()`
`java.lang.Double`	`sum()`
`DoubleTensor`	`sum(int... overDimensions)`
`DoubleTensor`	`tan()`
`DoubleTensor`	`tanInPlace()`
`DoubleTensor`	`tensorMultiply(DoubleTensor value, int[] dimsLeft, int[] dimsRight)`
`DoubleTensor`	`times(double value)`
`DoubleTensor`	`times(DoubleTensor that)`
`DoubleTensor`	`timesInPlace(double value)`
`DoubleTensor`	`timesInPlace(DoubleTensor that)`
`DoubleTensor`	`toDouble()`
`IntegerTensor`	`toInteger()`
`java.lang.String`	`toString()`
`DoubleTensor`	`transpose()`
`DoubleTensor`	`unaryMinus()`
`DoubleTensor`	`unaryMinusInPlace()`
`static Nd4jDoubleTensor`	`zeros(long[] shape)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.improbable.keanu.tensor.dbl.DoubleTensor
concat, concat, create, isNaN, max, min, reverseDiv, reverseMinus, sliceAlongDimension, stack, vector

Methods inherited from interface io.improbable.keanu.tensor.Tensor
asFlatList, create, createFilled, elementwiseEquals, getValue, hasSameShapeAs, hasSameShapeAs, isLengthOne, isMatrix, isScalar, isVector

- Constructor Detail
  - Nd4jDoubleTensor
```
public Nd4jDoubleTensor(double[] data,
                        long[] shape)
```
  - Nd4jDoubleTensor
```
public Nd4jDoubleTensor(org.nd4j.linalg.api.ndarray.INDArray tensor)
```
- Method Detail
  - scalar
```
public static Nd4jDoubleTensor scalar(double scalarValue)
```
    Specified by:
    
    scalar in interface DoubleTensor
    
    Specified by:
    
    scalar in interface Tensor<java.lang.Double>
  - create
```
public static Nd4jDoubleTensor create(double[] values,
                                      long[] shape)
```
    Specified by:
    
    create in interface DoubleTensor
  - create
```
public static Nd4jDoubleTensor create(double value,
                                      long[] shape)
```
    Specified by:
    
    create in interface DoubleTensor
  - ones
```
public static Nd4jDoubleTensor ones(long... shape)
```
    Specified by:
    
    ones in interface DoubleTensor
  - eye
```
public static Nd4jDoubleTensor eye(long n)
```
    Specified by:
    
    eye in interface DoubleTensor
  - zeros
```
public static Nd4jDoubleTensor zeros(long[] shape)
```
    Specified by:
    
    zeros in interface DoubleTensor
  - linspace
```
public static Nd4jDoubleTensor linspace(double start,
                                        double end,
                                        int numberOfPoints)
```
    Specified by:
    
    linspace in interface DoubleTensor
  - arange
```
public static Nd4jDoubleTensor arange(double start,
                                      double end)
```
    Specified by:
    
    arange in interface DoubleTensor
    
    Parameters:
    
    start - start of range
    
    end - end of range (exclusive)
    
    Returns:
    
    a vector of numbers from start incrementing by one to end (exclusively)
  - arange
```
public static Nd4jDoubleTensor arange(double start,
                                      double end,
                                      double stepSize)
```
    Specified by:
    
    arange in interface DoubleTensor
    
    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)
  - getRank
```
public int getRank()
```
    Specified by:
    
    getRank in interface Tensor<java.lang.Double>
  - getShape
```
public long[] getShape()
```
    Specified by:
    
    getShape in interface Tensor<java.lang.Double>
  - getLength
```
public long getLength()
```
    Specified by:
    
    getLength in interface Tensor<java.lang.Double>
  - isShapePlaceholder
```
public boolean isShapePlaceholder()
```
    Specified by:
    
    isShapePlaceholder in interface Tensor<java.lang.Double>
  - getValue
```
public java.lang.Double getValue(long... index)
```
    Specified by:
    
    getValue in interface Tensor<java.lang.Double>
  - setValue
```
public DoubleTensor setValue(java.lang.Double value,
                             long... index)
```
    Specified by:
    
    setValue in interface DoubleTensor
    
    Specified by:
    
    setValue in interface Tensor<java.lang.Double>
  - reshape
```
public DoubleTensor reshape(long... newShape)
```
    Specified by:
    
    reshape in interface DoubleTensor
    
    Specified by:
    
    reshape in interface Tensor<java.lang.Double>
  - permute
```
public DoubleTensor permute(int... rearrange)
```
    Specified by:
    
    permute in interface DoubleTensor
  - diag
```
public DoubleTensor diag()
```
    Specified by:
    
    diag in interface DoubleTensor
    
    Specified by:
    
    diag in interface NumberTensor<java.lang.Double,DoubleTensor>
  - transpose
```
public DoubleTensor transpose()
```
    Specified by:
    
    transpose in interface DoubleTensor
    
    Specified by:
    
    transpose in interface NumberTensor<java.lang.Double,DoubleTensor>
  - sum
```
public DoubleTensor sum(int... overDimensions)
```
    Specified by:
    
    sum in interface DoubleTensor
    
    Specified by:
    
    sum in interface NumberTensor<java.lang.Double,DoubleTensor>
  - sum
```
public java.lang.Double sum()
```
    Specified by:
    
    sum in interface NumberTensor<java.lang.Double,DoubleTensor>
  - duplicate
```
public DoubleTensor duplicate()
```
    Specified by:
    
    duplicate in interface DoubleTensor
    
    Specified by:
    
    duplicate in interface Tensor<java.lang.Double>
  - apply
```
public DoubleTensor apply(java.util.function.Function<java.lang.Double,java.lang.Double> function)
```
    Specified by:
    
    apply in interface NumberTensor<java.lang.Double,DoubleTensor>
  - matrixInverse
```
public DoubleTensor matrixInverse()
```
    Specified by:
    
    matrixInverse in interface DoubleTensor
  - max
```
public double max()
```
    Specified by:
    
    max in interface DoubleTensor
  - min
```
public double min()
```
    Specified by:
    
    min in interface DoubleTensor
  - argMax
```
public int argMax()
```
    Description copied from interface: NumberTensor
    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]]
 
```
    Specified by:
    
    argMax in interface NumberTensor<java.lang.Double,DoubleTensor>
    
    Returns:
    
    A scalar tensor with the index of the largest value. If there are multiple largest values, it will be the first index.
  - argMax
```
public IntegerTensor argMax(int axis)
```
    Description copied from interface: NumberTensor
    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]]
 
```
    Specified by:
    
    argMax in interface NumberTensor<java.lang.Double,DoubleTensor>
    
    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
  - average
```
public double average()
```
    Specified by:
    
    average in interface DoubleTensor
  - standardDeviation
```
public double standardDeviation()
```
    Specified by:
    
    standardDeviation in interface DoubleTensor
  - equalsWithinEpsilon
```
public boolean equalsWithinEpsilon(DoubleTensor o,
                                   double epsilon)
```
    Specified by:
    
    equalsWithinEpsilon in interface DoubleTensor
  - clamp
```
public DoubleTensor clamp(DoubleTensor min,
                          DoubleTensor max)
```
    Specified by:
    
    clamp in interface DoubleTensor
  - ceil
```
public DoubleTensor ceil()
```
    Specified by:
    
    ceil in interface DoubleTensor
  - floor
```
public DoubleTensor floor()
```
    Specified by:
    
    floor in interface DoubleTensor
  - round
```
public DoubleTensor round()
```
    Specified by:
    
    round in interface DoubleTensor
  - standardize
```
public DoubleTensor standardize()
```
    Specified by:
    
    standardize in interface DoubleTensor
  - replaceNaN
```
public DoubleTensor replaceNaN(double value)
```
    Specified by:
    
    replaceNaN in interface DoubleTensor
  - sigmoid
```
public DoubleTensor sigmoid()
```
    Specified by:
    
    sigmoid in interface DoubleTensor
  - choleskyDecomposition
```
public DoubleTensor choleskyDecomposition()
```
    Specified by:
    
    choleskyDecomposition in interface DoubleTensor
  - scalar
```
public java.lang.Double scalar()
```
    Specified by:
    
    scalar in interface Tensor<java.lang.Double>
  - reciprocal
```
public DoubleTensor reciprocal()
```
    Specified by:
    
    reciprocal in interface DoubleTensor
  - minus
```
public DoubleTensor minus(double value)
```
    Specified by:
    
    minus in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    minus in interface DoubleTensor
  - plus
```
public DoubleTensor plus(double value)
```
    Specified by:
    
    plus in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    plus in interface DoubleTensor
  - times
```
public DoubleTensor times(double value)
```
    Specified by:
    
    times in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    times in interface DoubleTensor
  - matrixMultiply
```
public DoubleTensor matrixMultiply(DoubleTensor value)
```
    Specified by:
    
    matrixMultiply in interface DoubleTensor
    
    Specified by:
    
    matrixMultiply in interface NumberTensor<java.lang.Double,DoubleTensor>
  - tensorMultiply
```
public DoubleTensor tensorMultiply(DoubleTensor value,
                                   int[] dimsLeft,
                                   int[] dimsRight)
```
    Specified by:
    
    tensorMultiply in interface DoubleTensor
    
    Specified by:
    
    tensorMultiply in interface NumberTensor<java.lang.Double,DoubleTensor>
  - div
```
public DoubleTensor div(double value)
```
    Specified by:
    
    div in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    div in interface DoubleTensor
  - pow
```
public DoubleTensor pow(DoubleTensor exponent)
```
    Specified by:
    
    pow in interface io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>
    
    Specified by:
    
    pow in interface DoubleTensor
  - pow
```
public DoubleTensor pow(double exponent)
```
    Specified by:
    
    pow in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    pow in interface DoubleTensor
  - sqrt
```
public DoubleTensor sqrt()
```
    Specified by:
    
    sqrt in interface DoubleTensor
  - log
```
public DoubleTensor log()
```
    Specified by:
    
    log in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    log in interface DoubleTensor
  - safeLogTimes
```
public DoubleTensor safeLogTimes(DoubleTensor y)
```
    Specified by:
    
    safeLogTimes in interface DoubleTensor
  - logGamma
```
public DoubleTensor logGamma()
```
    Specified by:
    
    logGamma in interface DoubleTensor
  - digamma
```
public DoubleTensor digamma()
```
    Specified by:
    
    digamma in interface DoubleTensor
  - sin
```
public DoubleTensor sin()
```
    Specified by:
    
    sin in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    sin in interface DoubleTensor
  - cos
```
public DoubleTensor cos()
```
    Specified by:
    
    cos in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    cos in interface DoubleTensor
  - tan
```
public DoubleTensor tan()
```
    Specified by:
    
    tan in interface DoubleTensor
  - atan
```
public DoubleTensor atan()
```
    Specified by:
    
    atan in interface DoubleTensor
  - atan2
```
public DoubleTensor atan2(double y)
```
    Specified by:
    
    atan2 in interface DoubleTensor
  - atan2
```
public DoubleTensor atan2(DoubleTensor y)
```
    Specified by:
    
    atan2 in interface DoubleTensor
  - asin
```
public DoubleTensor asin()
```
    Specified by:
    
    asin in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    asin in interface DoubleTensor
  - acos
```
public DoubleTensor acos()
```
    Specified by:
    
    acos in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    acos in interface DoubleTensor
  - exp
```
public DoubleTensor exp()
```
    Specified by:
    
    exp in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    exp in interface DoubleTensor
  - minus
```
public DoubleTensor minus(DoubleTensor that)
```
    Specified by:
    
    minus in interface io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>
  - plus
```
public DoubleTensor plus(DoubleTensor that)
```
    Specified by:
    
    plus in interface io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>
  - times
```
public DoubleTensor times(DoubleTensor that)
```
    Specified by:
    
    times in interface io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>
  - div
```
public DoubleTensor div(DoubleTensor that)
```
    Specified by:
    
    div in interface io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>
  - abs
```
public DoubleTensor abs()
```
    Specified by:
    
    abs in interface NumberTensor<java.lang.Double,DoubleTensor>
  - unaryMinus
```
public DoubleTensor unaryMinus()
```
    Specified by:
    
    unaryMinus in interface io.improbable.keanu.kotlin.NumberOperators<DoubleTensor>
  - setWithMask
```
public DoubleTensor setWithMask(DoubleTensor mask,
                                java.lang.Double value)
```
    Specified by:
    
    setWithMask in interface NumberTensor<java.lang.Double,DoubleTensor>
  - reciprocalInPlace
```
public DoubleTensor reciprocalInPlace()
```
    Specified by:
    
    reciprocalInPlace in interface DoubleTensor
  - minusInPlace
```
public DoubleTensor minusInPlace(double value)
```
    Specified by:
    
    minusInPlace in interface DoubleTensor
  - plusInPlace
```
public DoubleTensor plusInPlace(double value)
```
    Specified by:
    
    plusInPlace in interface DoubleTensor
  - timesInPlace
```
public DoubleTensor timesInPlace(double value)
```
    Specified by:
    
    timesInPlace in interface DoubleTensor
  - divInPlace
```
public DoubleTensor divInPlace(double value)
```
    Specified by:
    
    divInPlace in interface DoubleTensor
  - powInPlace
```
public DoubleTensor powInPlace(DoubleTensor exponent)
```
    Specified by:
    
    powInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - powInPlace
```
public DoubleTensor powInPlace(double exponent)
```
    Specified by:
    
    powInPlace in interface DoubleTensor
  - sqrtInPlace
```
public DoubleTensor sqrtInPlace()
```
    Specified by:
    
    sqrtInPlace in interface DoubleTensor
  - logInPlace
```
public DoubleTensor logInPlace()
```
    Specified by:
    
    logInPlace in interface DoubleTensor
  - safeLogTimesInPlace
```
public DoubleTensor safeLogTimesInPlace(DoubleTensor 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
    
    Specified by:
    
    safeLogTimesInPlace in interface DoubleTensor
    
    Parameters:
    
    y - The tensor value to multiply by
    
    Returns:
    
    the log of this tensor multiplied by y
  - logGammaInPlace
```
public DoubleTensor logGammaInPlace()
```
    Specified by:
    
    logGammaInPlace in interface DoubleTensor
  - digammaInPlace
```
public DoubleTensor digammaInPlace()
```
    Specified by:
    
    digammaInPlace in interface DoubleTensor
  - sinInPlace
```
public DoubleTensor sinInPlace()
```
    Specified by:
    
    sinInPlace in interface DoubleTensor
  - cosInPlace
```
public DoubleTensor cosInPlace()
```
    Specified by:
    
    cosInPlace in interface DoubleTensor
  - tanInPlace
```
public DoubleTensor tanInPlace()
```
    Specified by:
    
    tanInPlace in interface DoubleTensor
  - atanInPlace
```
public DoubleTensor atanInPlace()
```
    Specified by:
    
    atanInPlace in interface DoubleTensor
  - atan2InPlace
```
public DoubleTensor atan2InPlace(double y)
```
    Specified by:
    
    atan2InPlace in interface DoubleTensor
  - atan2InPlace
```
public DoubleTensor atan2InPlace(DoubleTensor y)
```
    Specified by:
    
    atan2InPlace in interface DoubleTensor
  - asinInPlace
```
public DoubleTensor asinInPlace()
```
    Specified by:
    
    asinInPlace in interface DoubleTensor
  - acosInPlace
```
public DoubleTensor acosInPlace()
```
    Specified by:
    
    acosInPlace in interface DoubleTensor
  - expInPlace
```
public DoubleTensor expInPlace()
```
    Specified by:
    
    expInPlace in interface DoubleTensor
  - minusInPlace
```
public DoubleTensor minusInPlace(DoubleTensor that)
```
    Specified by:
    
    minusInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
    
    Parameters:
    
    that - Right operand.
    
    Returns:
    
    A new DoubleTensor instance only if this has a length of 1 and right operand has a length greater than 1. Otherwise return this.
  - plusInPlace
```
public DoubleTensor plusInPlace(DoubleTensor that)
```
    Specified by:
    
    plusInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
    
    Parameters:
    
    that - Right operand.
    
    Returns:
    
    A new DoubleTensor instance only if this has a length of 1 and right operand has a length greater than 1. Otherwise return this.
  - timesInPlace
```
public DoubleTensor timesInPlace(DoubleTensor that)
```
    Specified by:
    
    timesInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
    
    Parameters:
    
    that - Right operand.
    
    Returns:
    
    A new DoubleTensor instance only if this has a length of 1 and right operand has a length greater than 1. Otherwise return this.
  - divInPlace
```
public DoubleTensor divInPlace(DoubleTensor that)
```
    Specified by:
    
    divInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
    
    Parameters:
    
    that - Right operand.
    
    Returns:
    
    A new DoubleTensor instance only if this has a length of 1 and right operand has a length greater than 1. Otherwise return this.
  - unaryMinusInPlace
```
public DoubleTensor unaryMinusInPlace()
```
    Specified by:
    
    unaryMinusInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - absInPlace
```
public DoubleTensor absInPlace()
```
    Specified by:
    
    absInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - getGreaterThanMask
```
public DoubleTensor getGreaterThanMask(DoubleTensor greaterThanThis)
```
    Specified by:
    
    getGreaterThanMask in interface NumberTensor<java.lang.Double,DoubleTensor>
  - getGreaterThanOrEqualToMask
```
public DoubleTensor getGreaterThanOrEqualToMask(DoubleTensor greaterThanOrEqualToThis)
```
    Specified by:
    
    getGreaterThanOrEqualToMask in interface NumberTensor<java.lang.Double,DoubleTensor>
  - getLessThanMask
```
public DoubleTensor getLessThanMask(DoubleTensor lessThanThis)
```
    Specified by:
    
    getLessThanMask in interface NumberTensor<java.lang.Double,DoubleTensor>
  - getLessThanOrEqualToMask
```
public DoubleTensor getLessThanOrEqualToMask(DoubleTensor lessThanOrEqualToThis)
```
    Specified by:
    
    getLessThanOrEqualToMask in interface NumberTensor<java.lang.Double,DoubleTensor>
  - setWithMaskInPlace
```
public DoubleTensor setWithMaskInPlace(DoubleTensor mask,
                                       java.lang.Double value)
```
    Specified by:
    
    setWithMaskInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - applyInPlace
```
public DoubleTensor applyInPlace(java.util.function.Function<java.lang.Double,java.lang.Double> function)
```
    Specified by:
    
    applyInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - maxInPlace
```
public DoubleTensor maxInPlace(DoubleTensor max)
```
    Specified by:
    
    maxInPlace in interface DoubleTensor
  - minInPlace
```
public DoubleTensor minInPlace(DoubleTensor min)
```
    Specified by:
    
    minInPlace in interface DoubleTensor
  - standardizeInPlace
```
public DoubleTensor standardizeInPlace()
```
    Specified by:
    
    standardizeInPlace in interface DoubleTensor
  - setAllInPlace
```
public DoubleTensor setAllInPlace(double value)
```
    Specified by:
    
    setAllInPlace in interface DoubleTensor
  - clampInPlace
```
public DoubleTensor clampInPlace(DoubleTensor min,
                                 DoubleTensor max)
```
    Specified by:
    
    clampInPlace in interface DoubleTensor
  - ceilInPlace
```
public DoubleTensor ceilInPlace()
```
    Specified by:
    
    ceilInPlace in interface DoubleTensor
  - floorInPlace
```
public DoubleTensor floorInPlace()
```
    Specified by:
    
    floorInPlace in interface DoubleTensor
  - roundInPlace
```
public DoubleTensor roundInPlace()
```
    Specified by:
    
    roundInPlace in interface DoubleTensor
  - sigmoidInPlace
```
public DoubleTensor sigmoidInPlace()
```
    Specified by:
    
    sigmoidInPlace in interface DoubleTensor
  - determinant
```
public double determinant()
```
    Specified by:
    
    determinant in interface DoubleTensor
  - product
```
public double product()
```
    Specified by:
    
    product in interface DoubleTensor
  - slice
```
public DoubleTensor slice(int dimension,
                          long index)
```
    Specified by:
    
    slice in interface DoubleTensor
    
    Specified by:
    
    slice in interface Tensor<java.lang.Double>
  - split
```
public java.util.List<DoubleTensor> split(int dimension,
                                          long... splitAtIndices)
```
    Specified by:
    
    split in interface DoubleTensor
    
    Parameters:
    
    dimension - the dimension to slice on
    
    splitAtIndices - the indices that the dimension to slice on should be slice on
    
    Returns:
    
    pieces of the tensor slice in the order specified by splitAtIndices. To get pieces that encompasses the entire tensor, the last index in the splitAtIndices must be the length of the dimension being slice on.
    e.g A = [ 1, 2, 3, 4, 5, 6 7, 8, 9, 1, 2, 3 ]
    A.slice(0, [1]) gives List([1, 2, 3, 4, 5, 6]) A.slice(0, [1, 2]) gives List([1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3]
    A.slice(1, [1, 3, 6]) gives List( [1, [2, 3 , [4, 5, 6, 7] 8, 9] 1, 2, 3] )
  - lessThan
```
public BooleanTensor lessThan(double value)
```
    Specified by:
    
    lessThan in interface DoubleTensor
  - lessThanOrEqual
```
public BooleanTensor lessThanOrEqual(double value)
```
    Specified by:
    
    lessThanOrEqual in interface DoubleTensor
  - lessThan
```
public BooleanTensor lessThan(DoubleTensor value)
```
    Specified by:
    
    lessThan in interface NumberTensor<java.lang.Double,DoubleTensor>
  - lessThanOrEqual
```
public BooleanTensor lessThanOrEqual(DoubleTensor value)
```
    Specified by:
    
    lessThanOrEqual in interface NumberTensor<java.lang.Double,DoubleTensor>
  - greaterThan
```
public BooleanTensor greaterThan(double value)
```
    Specified by:
    
    greaterThan in interface DoubleTensor
  - greaterThanOrEqual
```
public BooleanTensor greaterThanOrEqual(double value)
```
    Specified by:
    
    greaterThanOrEqual in interface DoubleTensor
  - notNaN
```
public BooleanTensor notNaN()
```
    Specified by:
    
    notNaN in interface DoubleTensor
  - replaceNaNInPlace
```
public DoubleTensor replaceNaNInPlace(double value)
```
    Specified by:
    
    replaceNaNInPlace in interface DoubleTensor
  - greaterThan
```
public BooleanTensor greaterThan(DoubleTensor value)
```
    Specified by:
    
    greaterThan in interface NumberTensor<java.lang.Double,DoubleTensor>
  - greaterThanOrEqual
```
public BooleanTensor greaterThanOrEqual(DoubleTensor value)
```
    Specified by:
    
    greaterThanOrEqual in interface NumberTensor<java.lang.Double,DoubleTensor>
  - elementwiseEquals
```
public BooleanTensor elementwiseEquals(Tensor that)
```
    Specified by:
    
    elementwiseEquals in interface Tensor<java.lang.Double>
  - elementwiseEquals
```
public BooleanTensor elementwiseEquals(java.lang.Double value)
```
    Specified by:
    
    elementwiseEquals in interface Tensor<java.lang.Double>
  - getFlattenedView
```
public Tensor.FlattenedView<java.lang.Double> getFlattenedView()
```
    Specified by:
    
    getFlattenedView in interface Tensor<java.lang.Double>
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toDouble
```
public DoubleTensor toDouble()
```
    Specified by:
    
    toDouble in interface NumberTensor<java.lang.Double,DoubleTensor>
  - toInteger
```
public IntegerTensor toInteger()
```
    Specified by:
    
    toInteger in interface NumberTensor<java.lang.Double,DoubleTensor>
  - asFlatDoubleArray
```
public double[] asFlatDoubleArray()
```
    Specified by:
    
    asFlatDoubleArray in interface Tensor<java.lang.Double>
  - asFlatIntegerArray
```
public int[] asFlatIntegerArray()
```
    Specified by:
    
    asFlatIntegerArray in interface Tensor<java.lang.Double>
  - asFlatArray
```
public java.lang.Double[] asFlatArray()
```
    Specified by:
    
    asFlatArray in interface Tensor<java.lang.Double>

Class Nd4jDoubleTensor

Nested Class Summary

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

Field Summary

Fields inherited from interface io.improbable.keanu.tensor.dbl.DoubleTensor

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.improbable.keanu.tensor.dbl.DoubleTensor

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

Constructor Detail

Nd4jDoubleTensor

Nd4jDoubleTensor

Method Detail

scalar

create

create

ones

eye

zeros

linspace

arange

arange

getRank

getShape

getLength

isShapePlaceholder

getValue

setValue

reshape

permute

diag

transpose

sum

sum

duplicate

apply

matrixInverse

max

min

argMax

argMax

average

standardDeviation

equalsWithinEpsilon

clamp

ceil

floor

round

standardize

replaceNaN

sigmoid

choleskyDecomposition

scalar

reciprocal

minus

plus

times

matrixMultiply

tensorMultiply

div

pow

pow

sqrt

log

safeLogTimes

logGamma

digamma

sin

cos

tan

atan

atan2

atan2

asin

acos

exp

minus

plus