ScalarDoubleTensor (keanu-project 0.0.22 API)

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

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 ScalarDoubleTensor
extends java.lang.Object
implements DoubleTensor
```

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

ScalarDoubleTensor(double value)

ScalarDoubleTensor(long[] shape)

Constructors
Constructor and Description
`ScalarDoubleTensor(double value)`
`ScalarDoubleTensor(long[] shape)`

Method Summary

All 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)`
`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()`
`double`	`determinant()`
`DoubleTensor`	`diag()`
`DoubleTensor`	`digamma()`
`DoubleTensor`	`digammaInPlace()`
`DoubleTensor`	`div(double that)`
`DoubleTensor`	`div(DoubleTensor that)`
`DoubleTensor`	`divInPlace(double that)`
`DoubleTensor`	`divInPlace(DoubleTensor that)`
`ScalarDoubleTensor`	`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()`
`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 lessThanOrEqualsThis)`
`int`	`getRank()`
`long[]`	`getShape()`
`java.lang.Double`	`getValue(long[] index)`
`BooleanTensor`	`greaterThan(double value)`
`BooleanTensor`	`greaterThan(DoubleTensor that)`
`BooleanTensor`	`greaterThanOrEqual(double value)`
`BooleanTensor`	`greaterThanOrEqual(DoubleTensor that)`
`int`	`hashCode()`
`boolean`	`isShapePlaceholder()`
`BooleanTensor`	`lessThan(double that)`
`BooleanTensor`	`lessThan(DoubleTensor that)`
`BooleanTensor`	`lessThanOrEqual(double that)`
`BooleanTensor`	`lessThanOrEqual(DoubleTensor that)`
`DoubleTensor`	`log()`
`DoubleTensor`	`logGamma()`
`DoubleTensor`	`logGammaInPlace()`
`DoubleTensor`	`logInPlace()`
`DoubleTensor`	`matrixInverse()`
`DoubleTensor`	`matrixMultiply(DoubleTensor that)`
`double`	`max()`
`DoubleTensor`	`maxInPlace(DoubleTensor max)`
`double`	`min()`
`DoubleTensor`	`minInPlace(DoubleTensor min)`
`DoubleTensor`	`minus(double that)`
`DoubleTensor`	`minus(DoubleTensor that)`
`DoubleTensor`	`minusInPlace(double that)`
`DoubleTensor`	`minusInPlace(DoubleTensor that)`
`BooleanTensor`	`notNaN()`
`DoubleTensor`	`permute(int... rearrange)`
`DoubleTensor`	`plus(double that)`
`DoubleTensor`	`plus(DoubleTensor that)`
`DoubleTensor`	`plusInPlace(double that)`
`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 newValue)`
`DoubleTensor`	`reshape(long... newShape)`
`DoubleTensor`	`round()`
`DoubleTensor`	`roundInPlace()` Note that we have modified the native Java behaviour to match Python (and therefore ND4J) behaviour Which rounds negative numbers down if they end in 0.5 e.g.
`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()`
`DoubleTensor`	`setAllInPlace(double value)`
`DoubleTensor`	`setValue(java.lang.Double value, long[] index)`
`DoubleTensor`	`setWithMask(DoubleTensor mask, java.lang.Double value)`
`DoubleTensor`	`setWithMaskInPlace(DoubleTensor withMask, java.lang.Double valueToApply)`
`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 that, int[] dimsLeft, int[] dimsRight)`
`DoubleTensor`	`times(double that)`
`DoubleTensor`	`times(DoubleTensor that)`
`DoubleTensor`	`timesInPlace(double that)`
`DoubleTensor`	`timesInPlace(DoubleTensor that)`
`DoubleTensor`	`toDouble()`
`IntegerTensor`	`toInteger()`
`java.lang.String`	`toString()`
`DoubleTensor`	`transpose()`
`DoubleTensor`	`unaryMinus()`
`DoubleTensor`	`unaryMinusInPlace()`

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
arange, arange, concat, concat, create, create, create, eye, isNaN, linspace, max, min, ones, reverseDiv, reverseMinus, scalar, sliceAlongDimension, stack, vector, zeros

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

- Constructor Detail
  - ScalarDoubleTensor
```
public ScalarDoubleTensor(double value)
```
  - ScalarDoubleTensor
```
public ScalarDoubleTensor(long[] shape)
```
- Method Detail
  - 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>
  - duplicate
```
public ScalarDoubleTensor duplicate()
```
    Specified by:
    
    duplicate in interface DoubleTensor
    
    Specified by:
    
    duplicate 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>
  - sum
```
public java.lang.Double sum()
```
    Specified by:
    
    sum in interface NumberTensor<java.lang.Double,DoubleTensor>
  - 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>
  - scalar
```
public java.lang.Double scalar()
```
    Specified by:
    
    scalar 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>
    
    Parameters:
    
    overDimensions - the dimensions to sum over
    
    Returns:
    
    a new scalar with a shape that has the sum over dimensions dropped
  - reciprocal
```
public DoubleTensor reciprocal()
```
    Specified by:
    
    reciprocal in interface DoubleTensor
  - minus
```
public DoubleTensor minus(double that)
```
    Specified by:
    
    minus in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    minus in interface DoubleTensor
  - plus
```
public DoubleTensor plus(double that)
```
    Specified by:
    
    plus in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    plus in interface DoubleTensor
  - times
```
public DoubleTensor times(double that)
```
    Specified by:
    
    times in interface io.improbable.keanu.kotlin.DoubleOperators<DoubleTensor>
    
    Specified by:
    
    times in interface DoubleTensor
  - matrixMultiply
```
public DoubleTensor matrixMultiply(DoubleTensor that)
```
    Specified by:
    
    matrixMultiply in interface DoubleTensor
    
    Specified by:
    
    matrixMultiply in interface NumberTensor<java.lang.Double,DoubleTensor>
  - tensorMultiply
```
public DoubleTensor tensorMultiply(DoubleTensor that,
                                   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 that)
```
    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>
  - unaryMinus
```
public DoubleTensor unaryMinus()
```
    Specified by:
    
    unaryMinus in interface io.improbable.keanu.kotlin.NumberOperators<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 lessThanOrEqualsThis)
```
    Specified by:
    
    getLessThanOrEqualToMask in interface NumberTensor<java.lang.Double,DoubleTensor>
  - setWithMaskInPlace
```
public DoubleTensor setWithMaskInPlace(DoubleTensor withMask,
                                       java.lang.Double valueToApply)
```
    Specified by:
    
    setWithMaskInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - setWithMask
```
public DoubleTensor setWithMask(DoubleTensor mask,
                                java.lang.Double value)
```
    Specified by:
    
    setWithMask in interface NumberTensor<java.lang.Double,DoubleTensor>
  - abs
```
public DoubleTensor abs()
```
    Specified by:
    
    abs in interface NumberTensor<java.lang.Double,DoubleTensor>
  - 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
  - standardize
```
public DoubleTensor standardize()
```
    Specified by:
    
    standardize in interface DoubleTensor
  - replaceNaN
```
public DoubleTensor replaceNaN(double value)
```
    Specified by:
    
    replaceNaN 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
  - sigmoid
```
public DoubleTensor sigmoid()
```
    Specified by:
    
    sigmoid in interface DoubleTensor
  - choleskyDecomposition
```
public DoubleTensor choleskyDecomposition()
```
    Specified by:
    
    choleskyDecomposition 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
  - reciprocalInPlace
```
public DoubleTensor reciprocalInPlace()
```
    Specified by:
    
    reciprocalInPlace in interface DoubleTensor
  - minusInPlace
```
public DoubleTensor minusInPlace(double that)
```
    Specified by:
    
    minusInPlace in interface DoubleTensor
  - plusInPlace
```
public DoubleTensor plusInPlace(double that)
```
    Specified by:
    
    plusInPlace in interface DoubleTensor
  - timesInPlace
```
public DoubleTensor timesInPlace(double that)
```
    Specified by:
    
    timesInPlace in interface DoubleTensor
  - divInPlace
```
public DoubleTensor divInPlace(double that)
```
    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>
  - plusInPlace
```
public DoubleTensor plusInPlace(DoubleTensor that)
```
    Specified by:
    
    plusInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - timesInPlace
```
public DoubleTensor timesInPlace(DoubleTensor that)
```
    Specified by:
    
    timesInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - divInPlace
```
public DoubleTensor divInPlace(DoubleTensor that)
```
    Specified by:
    
    divInPlace in interface NumberTensor<java.lang.Double,DoubleTensor>
  - 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>
  - 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
  - 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()
```
    Note that we have modified the native Java behaviour to match Python (and therefore ND4J) behaviour Which rounds negative numbers down if they end in 0.5 e.g. Java: round(-2.5) == -2.0 Python: round(-2.5) == -3.0
    
    Specified by:
    
    roundInPlace in interface DoubleTensor
    
    Returns:
    
    Nearest integer value as a DoubleTensor
  - sigmoidInPlace
```
public DoubleTensor sigmoidInPlace()
```
    Specified by:
    
    sigmoidInPlace in interface DoubleTensor
  - standardizeInPlace
```
public DoubleTensor standardizeInPlace()
```
    Specified by:
    
    standardizeInPlace in interface DoubleTensor
  - replaceNaNInPlace
```
public DoubleTensor replaceNaNInPlace(double newValue)
```
    Specified by:
    
    replaceNaNInPlace in interface DoubleTensor
  - setAllInPlace
```
public DoubleTensor setAllInPlace(double value)
```
    Specified by:
    
    setAllInPlace in interface DoubleTensor
  - lessThan
```
public BooleanTensor lessThan(double that)
```
    Specified by:
    
    lessThan in interface DoubleTensor
  - lessThanOrEqual
```
public BooleanTensor lessThanOrEqual(double that)
```
    Specified by:
    
    lessThanOrEqual in interface DoubleTensor
  - lessThan
```
public BooleanTensor lessThan(DoubleTensor that)
```
    Specified by:
    
    lessThan in interface NumberTensor<java.lang.Double,DoubleTensor>
  - lessThanOrEqual
```
public BooleanTensor lessThanOrEqual(DoubleTensor that)
```
    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
  - greaterThan
```
public BooleanTensor greaterThan(DoubleTensor that)
```
    Specified by:
    
    greaterThan in interface NumberTensor<java.lang.Double,DoubleTensor>
  - greaterThanOrEqual
```
public BooleanTensor greaterThanOrEqual(DoubleTensor that)
```
    Specified by:
    
    greaterThanOrEqual in interface NumberTensor<java.lang.Double,DoubleTensor>
  - getFlattenedView
```
public Tensor.FlattenedView<java.lang.Double> getFlattenedView()
```
    Specified by:
    
    getFlattenedView in interface Tensor<java.lang.Double>
  - 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>
  - 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>
  - 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

Class ScalarDoubleTensor

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

ScalarDoubleTensor

ScalarDoubleTensor

Method Detail

getRank

getShape

getLength

isShapePlaceholder

duplicate

getValue

setValue

sum

toDouble

toInteger

scalar

reshape

permute

diag

transpose

sum

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

times

div

unaryMinus

getGreaterThanMask

getGreaterThanOrEqualToMask

getLessThanMask

getLessThanOrEqualToMask

setWithMaskInPlace

setWithMask

abs

apply

matrixInverse

max

min

argMax

argMax

average

standardDeviation

equalsWithinEpsilon

standardize

replaceNaN

clamp

ceil

floor