/** * A vertex that performs a user defined operation on a singe input vertex * * @param inputVertex the input vertex */ public IntegerUnaryOpVertex(IntegerVertex inputVertex) { this(inputVertex.getShape(), inputVertex); }
public IntegerVertex times(IntegerVertex that) { return multiply(that); }
@Test public void canObserveTensor() { IntegerVertex binomialVertex = new BinomialVertex(0.5, 20); IntegerTensor observation = Nd4jIntegerTensor.create(new int[]{1, 2, 3, 4}, new long[]{2, 2}); binomialVertex.observe(observation); assertArrayEquals(observation.asFlatIntegerArray(), binomialVertex.getValue().asFlatIntegerArray()); assertArrayEquals(observation.getShape(), binomialVertex.getShape()); }
@Test public void canConcat() { IntegerVertex A = new UniformIntVertex(0, 1); A.setValue(IntegerTensor.ones(2, 2)); IntegerVertex B = new UniformIntVertex(0, 1); B.setValue(IntegerTensor.ones(2, 2)); IntegerVertex concatDimZero = IntegerVertex.concat(0, A, B); assertArrayEquals(concatDimZero.getShape(), new long[]{4, 2}); IntegerVertex concatDimOne = IntegerVertex.concat(1, A, B); assertArrayEquals(concatDimOne.getShape(), new long[]{2, 4}); }
@Test public void canReshape() { IntegerVertex binomialVertex = new BinomialVertex(0, 1); binomialVertex.setAndCascade(IntegerTensor.ones(2, 2)); assertArrayEquals(binomialVertex.getShape(), new long[]{2, 2}); IntegerVertex reshaped = binomialVertex.reshape(4, 1); assertArrayEquals(reshaped.getShape(), new long[]{4, 1}); }
@Test public void canFindMinAndMax() { IntegerVertex A = ConstantVertex.of(1, 2, 3, 4); IntegerVertex B = ConstantVertex.of(2, 4, 1, 5); IntegerVertex min = IntegerVertex.min(A, B); IntegerVertex max = IntegerVertex.max(A, B); assertArrayEquals(new int[]{1, 2, 1, 4}, min.getValue().asFlatIntegerArray()); assertArrayEquals(new int[]{2, 4, 3, 5}, max.getValue().asFlatIntegerArray()); }
private IntegerCPTVertex integerCPTNetwork(boolean left, boolean right) { IntegerVertex A = new ConstantIntegerVertex(aValue); IntegerVertex B = new ConstantIntegerVertex(bValue); BooleanVertex leftPredicate = new BernoulliVertex(0.5); leftPredicate.observe(left); BooleanVertex rightPredicate = new BernoulliVertex(0.5); rightPredicate.observe(right); return ConditionalProbabilityTable.of(leftPredicate, rightPredicate) .when(true, true).then(A.times(B)) .when(true, false).then(A.div(B)) .when(false, true).then(A.plus(B)) .orDefault(B.minus(A)); }
@Test public void canSetAndCascadeAsScalarOnNonScalarVertex() { IntegerVertex binomialVertex = new BinomialVertex(new long[]{2, 1}, 0.5, 20); binomialVertex.setAndCascade(2); assertArrayEquals(new int[]{2}, binomialVertex.getValue().asFlatIntegerArray()); }
@Test public void doesEqualTo() { IntegerVertex v3 = ConstantVertex.of(3); assertFalse(v1.equalTo(v2).eval().scalar()); assertTrue(v1.notEqualTo(v2).eval().scalar()); assertFalse(v2.equalTo(v3).eval().scalar()); assertTrue(v2.notEqualTo(v3).eval().scalar()); }