io.improbable.keanu.vertices.dbl

Class DoubleVertex

java.lang.Object

io.improbable.keanu.vertices.Vertex<DoubleTensor>

io.improbable.keanu.vertices.dbl.DoubleVertex

All Implemented Interfaces:

Variable<DoubleTensor,VertexState<DoubleTensor>>, io.improbable.keanu.kotlin.DoubleOperators<DoubleVertex>, io.improbable.keanu.kotlin.NumberOperators<DoubleVertex>, Observable<DoubleTensor>

Direct Known Subclasses:

BetaVertex, CastToDoubleVertex, CauchyVertex, ChiSquaredVertex, ConcatenationVertex, ConstantDoubleVertex, DirichletVertex, DoubleBinaryOpLambda, DoubleBinaryOpVertex, DoubleCPTVertex, DoubleIfVertex, DoubleModelResultVertex, DoubleProxyVertex, DoubleSetWithMaskVertex, DoubleUnaryOpLambda, DoubleUnaryOpVertex, ExponentialVertex, GammaVertex, GaussianVertex, InverseGammaVertex, KDEVertex, LambdaModelVertex, LaplaceVertex, LogisticVertex, LogNormalVertex, LogProbGraph.DoublePlaceholderVertex, MultivariateGaussianVertex, ParetoVertex, ReduceVertex, SmoothUniformVertex, StudentTVertex, TriangularVertex, UniformVertex

public abstract class DoubleVertex
extends Vertex<DoubleTensor>
implements io.improbable.keanu.kotlin.DoubleOperators<DoubleVertex>

Constructor Summary

Constructors

Constructor and Description
DoubleVertex(long[] initialShape)

Method Summary

Modifier and Type	Method and Description
AbsVertex	abs()
ArcCosVertex	acos()
ArcSinVertex	asin()
ArcTanVertex	atan()
ArcTan2Vertex	atan2(DoubleVertex that)
CeilVertex	ceil()
static ConcatenationVertex	concat(int dimension, DoubleVertex... toConcat)
CosVertex	cos()
DivisionVertex	div(double that)
DivisionVertex	div(DoubleVertex that)
DivisionVertex	divideBy(double that)
DivisionVertex	divideBy(DoubleVertex that)
BooleanVertex	equalTo(DoubleVertex rhs)
ExpVertex	exp()
FloorVertex	floor()
double	getValue(int... index)
<T extends NumberTensor> BooleanVertex	greaterThan(Vertex<T> rhs)
<T extends NumberTensor> BooleanVertex	greaterThanOrEqualTo(Vertex<T> rhs)
DoubleUnaryOpLambda<DoubleTensor>	lambda(java.util.function.Function<DoubleTensor,DoubleTensor> op, java.util.function.Function<java.util.Map<Vertex,PartialDerivative>,PartialDerivative> forwardModeAutoDiffLambda, java.util.function.Function<PartialDerivative,java.util.Map<Vertex,PartialDerivative>> reverseModeAutoDiffLambda)
DoubleUnaryOpLambda<DoubleTensor>	lambda(long[] outputShape, java.util.function.Function<DoubleTensor,DoubleTensor> op, java.util.function.Function<java.util.Map<Vertex,PartialDerivative>,PartialDerivative> forwardModeAutoDiffLambda, java.util.function.Function<PartialDerivative,java.util.Map<Vertex,PartialDerivative>> reverseModeAutoDiffLambda)
<T extends NumberTensor> BooleanVertex	lessThan(Vertex<T> rhs)
<T extends NumberTensor> BooleanVertex	lessThanOrEqualTo(Vertex<T> rhs)
void	loadValue(NetworkLoader loader)
LogVertex	log()
LogGammaVertex	logGamma()
MatrixDeterminantVertex	matrixDeterminant()
MatrixInverseVertex	matrixInverse()
DoubleVertex	matrixMultiply(DoubleVertex that) Matrix product of two vertices
static MaxVertex	max(DoubleVertex a, DoubleVertex b)
static MinVertex	min(DoubleVertex a, DoubleVertex b)
DifferenceVertex	minus(double that)
DifferenceVertex	minus(DoubleVertex that)
MultiplicationVertex	multiply(double that)
MultiplicationVertex	multiply(DoubleVertex that)
<T extends Tensor> BooleanVertex	notEqualTo(Vertex<T> rhs)
void	observe(double value)
void	observe(double[] values)
PermuteVertex	permute(int... rearrange)
AdditionVertex	plus(double that)
AdditionVertex	plus(DoubleVertex that)
PowerVertex	pow(double that)
PowerVertex	pow(DoubleVertex exponent)
ReshapeVertex	reshape(long... proposedShape)
DivisionVertex	reverseDiv(double that)
DifferenceVertex	reverseMinus(double that)
RoundVertex	round()
void	saveValue(NetworkSaver netSaver)
void	setAndCascade(double value)
void	setAndCascade(double[] values)
void	setValue(double value)
void	setValue(double[] values)
DoubleVertex	setWithMask(DoubleVertex mask, double value)
DoubleVertex	setWithMask(DoubleVertex mask, DoubleVertex value)
SigmoidVertex	sigmoid()
SinVertex	sin()
SliceVertex	slice(int dimension, int index)
SumVertex	sum() Sum over all dimensions.
SumVertex	sum(int... sumOverDimensions) Sum over specified dimensions.
TakeVertex	take(long... index)
TanVertex	tan()
MultiplicationVertex	times(double that)
MultiplicationVertex	times(DoubleVertex that)
DoubleVertex	toGreaterThanMask(double rhs)
DoubleVertex	toGreaterThanMask(DoubleVertex rhs)
DoubleVertex	toGreaterThanOrEqualToMask(double rhs)
DoubleVertex	toGreaterThanOrEqualToMask(DoubleVertex rhs)
IntegerVertex	toInteger()
DoubleVertex	toLessThanMask(double rhs)
DoubleVertex	toLessThanMask(DoubleVertex rhs)
DoubleVertex	toLessThanOrEqualToMask(double rhs)
DoubleVertex	toLessThanOrEqualToMask(DoubleVertex rhs)
PermuteVertex	transpose()
MultiplicationVertex	unaryMinus()

Methods inherited from class io.improbable.keanu.vertices.Vertex

addChild, addParent, addParents, equals, eval, getChildren, getConnectedGraph, getDegree, getId, getIndentation, getLabel, getObservedValue, getParents, getRank, getReference, getShape, getState, getValue, hashCode, hasValue, isDifferentiable, isObserved, isProbabilistic, lazyEval, observe, observeOwnValue, print, print, removeLabel, save, setAndCascade, setLabel, setLabel, setParents, setParents, setState, setValue, toString, unobserve

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

DoubleVertex

public DoubleVertex(long[] initialShape)

Method Detail

concat

public static ConcatenationVertex concat(int dimension,
                                         DoubleVertex... toConcat)

Parameters:

dimension - dimension to concat along. Negative dimension indexing is not supported.

toConcat - array of things to concat. Must match in all dimensions except for the provided dimension

Returns:

a vertex that represents the concatenation of the toConcat

min

public static MinVertex min(DoubleVertex a,
                            DoubleVertex b)

max

public static MaxVertex max(DoubleVertex a,
                            DoubleVertex b)

minus

public DifferenceVertex minus(DoubleVertex that)

Specified by:

minus in interface io.improbable.keanu.kotlin.NumberOperators<DoubleVertex>

plus

public AdditionVertex plus(DoubleVertex that)

Specified by:

plus in interface io.improbable.keanu.kotlin.NumberOperators<DoubleVertex>

multiply

public MultiplicationVertex multiply(DoubleVertex that)

matrixMultiply

public DoubleVertex matrixMultiply(DoubleVertex that)

Matrix product of two vertices

Parameters:

that - a double vertex representing a matrix or a vector to matrix multiply

Returns:

a vertex that represents the matrix multiplication of two vertices. - If both left and right operands are rank 1, they are promoted to a matrix by prepending a 1 to its dimensions. After matrix multiplication, it is reshaped to be a scalar. This is essentially a dot product. This returns a ReshapeVertex. - If only one of the operands is rank 1 (and the other operand is rank 2), it is promoted to a matrix by prepending a 1 to its dimensions. After matrix multiplication, the appended 1 is removed. This is essentially a matrix-vector product. This returns a ReshapeVertex. - Otherwise, they are multiplied like conventional matrices. This returns a MatrixMultiplicationVertex.

matrixInverse

public MatrixInverseVertex matrixInverse()

matrixDeterminant

public MatrixDeterminantVertex matrixDeterminant()

divideBy

public DivisionVertex divideBy(DoubleVertex that)

pow

public PowerVertex pow(DoubleVertex exponent)

Specified by:

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

minus

public DifferenceVertex minus(double that)

Specified by:

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

reverseMinus

public DifferenceVertex reverseMinus(double that)

Specified by:

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

plus

public AdditionVertex plus(double that)

Specified by:

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

multiply

public MultiplicationVertex multiply(double that)

divideBy

public DivisionVertex divideBy(double that)

pow

public PowerVertex pow(double that)

Specified by:

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

abs

public AbsVertex abs()

floor

public FloorVertex floor()

ceil

public CeilVertex ceil()

round

public RoundVertex round()

exp

public ExpVertex exp()

Specified by:

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

log

public LogVertex log()

Specified by:

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

logGamma

public LogGammaVertex logGamma()

sigmoid

public SigmoidVertex sigmoid()

sin

public SinVertex sin()

Specified by:

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

cos

public CosVertex cos()

Specified by:

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

tan

public TanVertex tan()

asin

public ArcSinVertex asin()

Specified by:

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

acos

public ArcCosVertex acos()

Specified by:

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

atan

public ArcTanVertex atan()

atan2

public ArcTan2Vertex atan2(DoubleVertex that)

sum

public SumVertex sum()

Sum over all dimensions. This will always result in a scalar.

Returns:

a vertex representing the summation result

sum

public SumVertex sum(int... sumOverDimensions)

Sum over specified dimensions.

Parameters:

sumOverDimensions - dimensions to sum over. Negative dimension indexing is not supported

Returns:

a vertex representing the summation result

reshape

public ReshapeVertex reshape(long... proposedShape)

permute

public PermuteVertex permute(int... rearrange)

transpose

public PermuteVertex transpose()

lambda

public DoubleUnaryOpLambda<DoubleTensor> lambda(long[] outputShape,
                                                java.util.function.Function<DoubleTensor,DoubleTensor> op,
                                                java.util.function.Function<java.util.Map<Vertex,PartialDerivative>,PartialDerivative> forwardModeAutoDiffLambda,
                                                java.util.function.Function<PartialDerivative,java.util.Map<Vertex,PartialDerivative>> reverseModeAutoDiffLambda)

lambda

public DoubleUnaryOpLambda<DoubleTensor> lambda(java.util.function.Function<DoubleTensor,DoubleTensor> op,
                                                java.util.function.Function<java.util.Map<Vertex,PartialDerivative>,PartialDerivative> forwardModeAutoDiffLambda,
                                                java.util.function.Function<PartialDerivative,java.util.Map<Vertex,PartialDerivative>> reverseModeAutoDiffLambda)

times

public MultiplicationVertex times(DoubleVertex that)

Specified by:

times in interface io.improbable.keanu.kotlin.NumberOperators<DoubleVertex>

div

public DivisionVertex div(DoubleVertex that)

Specified by:

div in interface io.improbable.keanu.kotlin.NumberOperators<DoubleVertex>

times

public MultiplicationVertex times(double that)

Specified by:

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

div

public DivisionVertex div(double that)

Specified by:

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

reverseDiv

public DivisionVertex reverseDiv(double that)

Specified by:

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

unaryMinus

public MultiplicationVertex unaryMinus()

Specified by:

unaryMinus in interface io.improbable.keanu.kotlin.NumberOperators<DoubleVertex>

equalTo

public BooleanVertex equalTo(DoubleVertex rhs)

toInteger

public IntegerVertex toInteger()

notEqualTo

public <T extends Tensor> BooleanVertex notEqualTo(Vertex<T> rhs)

greaterThan

public <T extends NumberTensor> BooleanVertex greaterThan(Vertex<T> rhs)

toGreaterThanMask

public DoubleVertex toGreaterThanMask(DoubleVertex rhs)

toGreaterThanMask

public DoubleVertex toGreaterThanMask(double rhs)

greaterThanOrEqualTo

public <T extends NumberTensor> BooleanVertex greaterThanOrEqualTo(Vertex<T> rhs)

toGreaterThanOrEqualToMask

public DoubleVertex toGreaterThanOrEqualToMask(DoubleVertex rhs)

toGreaterThanOrEqualToMask

public DoubleVertex toGreaterThanOrEqualToMask(double rhs)

lessThan

public <T extends NumberTensor> BooleanVertex lessThan(Vertex<T> rhs)

toLessThanMask

public DoubleVertex toLessThanMask(DoubleVertex rhs)

toLessThanMask

public DoubleVertex toLessThanMask(double rhs)

lessThanOrEqualTo

public <T extends NumberTensor> BooleanVertex lessThanOrEqualTo(Vertex<T> rhs)

toLessThanOrEqualToMask

public DoubleVertex toLessThanOrEqualToMask(DoubleVertex rhs)

toLessThanOrEqualToMask

public DoubleVertex toLessThanOrEqualToMask(double rhs)

setWithMask

public DoubleVertex setWithMask(DoubleVertex mask,
                                double value)

setWithMask

public DoubleVertex setWithMask(DoubleVertex mask,
                                DoubleVertex value)

take

public TakeVertex take(long... index)

slice

public SliceVertex slice(int dimension,
                         int index)

setValue

public void setValue(double value)

setValue

public void setValue(double[] values)

setAndCascade

public void setAndCascade(double value)

setAndCascade

public void setAndCascade(double[] values)

observe

public void observe(double value)

observe

public void observe(double[] values)

getValue

public double getValue(int... index)

loadValue

public void loadValue(NetworkLoader loader)

Overrides:

loadValue in class Vertex<DoubleTensor>

saveValue

public void saveValue(NetworkSaver netSaver)

Overrides:

saveValue in class Vertex<DoubleTensor>