@Override public DRes<SInt> mult(DRes<SInt> a, DRes<SInt> b) { this.multCount++; return this.delegate.mult(a, b); }
@Override public DRes<SInt> mult(BigInteger a, DRes<SInt> b) { return this.delegate.mult(a, b); }
/** * Convenience implementation of {@link #mult(BigInteger, DRes)} */ default DRes<SInt> mult(long a, DRes<SInt> b) { return mult(BigInteger.valueOf(a), b); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { return builder.par(parallel -> { List<DRes<SInt>> result = new ArrayList<>(vectorA.size()); Numeric numericBuilder = parallel.numeric(); for (int i = 0; i < vectorA.size(); i++) { BigInteger nextA = vectorA.get(i); DRes<SInt> nextB = vectorB.get(i); result.add(numericBuilder.mult(nextA, nextB)); } return () -> result; }).seq((seq, list) -> seq.advancedNumeric().sum(list)); } }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { Numeric numeric = builder.numeric(); DRes<SInt> sub = numeric.sub(left, right); DRes<SInt> mult = numeric.mult(condition, sub); return numeric.add(mult, right); } }
private DRes<SInt> or(ProtocolBuilderNumeric builder, DRes<SInt> a, DRes<SInt> b) { Numeric numeric = builder.numeric(); DRes<SInt> product = numeric.mult(a, b); DRes<SInt> add = numeric.add(a, b); return numeric.sub(add, product); }
@Override public DRes<SInt> sign(DRes<SInt> x) { Numeric input = builder.numeric(); // TODO create a compareLeqOrEqZero on comparison builder DRes<SInt> compare = compareLEQ(input.known(BigInteger.ZERO), x); BigInteger oint = BigInteger.valueOf(2); Numeric numericBuilder = builder.numeric(); DRes<SInt> twice = numericBuilder.mult(oint, compare); return numericBuilder.sub(twice, BigInteger.valueOf(1)); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { return builder.par((par) -> { List<DRes<SInt>> terms = new ArrayList<>(data.size()); for (DRes<SInt> value : data) { DRes<SInt> term = par.seq((seq) -> { Numeric numeric = seq.numeric(); DRes<SInt> tmp = numeric.sub(value, mean); return numeric.mult(tmp, tmp); }); terms.add(term); } return () -> terms; }).seq((seq, terms) -> seq.seq(new Mean(terms, data.size() - 1)) ); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { AdvancedNumeric advancedNumericBuilder = builder.advancedNumeric(); DRes<SInt> divisionResult = advancedNumericBuilder.div(dividend, divisor); Numeric numeric = builder.numeric(); return numeric.sub(dividend, numeric.mult(divisor, divisionResult)); } }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { Numeric numeric = builder.numeric(); DRes<SInt> random = numeric.randomElement(); DRes<SInt> product = numeric.mult(value, random); DRes<BigInteger> open = numeric.open(product); return builder.seq((seq) -> { BigInteger value = open.out(); BigInteger inverse = value.modInverse(seq.getBasicNumericContext().getModulus()); return seq.numeric().mult(inverse, random); }); } }
@Override public DRes<Result> buildComputation(ProtocolBuilderNumeric builder) { ArrayList<DRes<SInt>> row = updateMatrix.getRow(updateMatrix.getHeight() - 1); ArrayList<DRes<SInt>> column = new ArrayList<>(row.size()); column.addAll(tableau.getB()); column.add(tableau.getZ()); AdvancedNumeric advanced = builder.advancedNumeric(); DRes<SInt> numerator = advanced.innerProduct(row, column); DRes<SInt> invDenominator = advanced.invert(pivot); DRes<SInt> mult = builder.numeric().mult(numerator, invDenominator); return () -> new Result(mult.out(), numerator.out(), pivot.out()); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { int degree = polynomial.getMaxDegree(); /* * We use Horner's method, p(x) = (( ... ((p_{n-1} x + p_{n-2})x + * p_{n-3}) ... )x + a_1)x + a_0 */ DRes<SInt> tmp = polynomial.getCoefficient(degree - 1); for (int i = degree - 2; i >= 0; i--) { tmp = builder.numeric().mult(tmp, valueX); tmp = builder.numeric().add(tmp, polynomial.getCoefficient(i)); } return tmp; }
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> input = numeric.input(value, 1); DRes<SInt> result = numeric.mult(constant, input); return numeric.open(result); }; BigInteger output = runApplication(app); Assert.assertEquals(BigInteger.valueOf(40), output); } };
@Override public DRes<SReal> mult(BigDecimal a, DRes<SReal> b) { return builder.seq(seq -> { SFixed floatB = (SFixed) b.out(); int precision = defaultPrecision + floatB.getPrecision(); BigInteger unscaledA = unscaled(a, defaultPrecision); DRes<SInt> unscaled = seq.numeric().mult(unscaledA, floatB.getSInt()); if (precision > maxPrecision) { unscaled = scale(seq, unscaled, defaultPrecision - precision); precision = defaultPrecision; } return new SFixed(unscaled, precision); }); }
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> firstClosed = numeric.known(first); DRes<SInt> secondClosed = numeric.known(second); DRes<SInt> add = numeric.add(firstClosed, secondClosed); DRes<SInt> mult = numeric.mult(firstClosed, add); return numeric.open(mult); }; BigInteger output = runApplication(app); Assert.assertEquals(first.add(second).multiply(first), output); } };
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> left = numeric.input(leftValue, 1); DRes<SInt> right = numeric.input(rightValue, 1); DRes<SInt> result = numeric.mult(left, right); return numeric.open(result); }; BigInteger output = runApplication(app); Assert.assertEquals(leftValue.multiply(rightValue), output); } };
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> left = numeric.input(leftValue, 1); DRes<SInt> right = numeric.input(rightValue, 1); DRes<SInt> result = numeric.mult(left, right); return numeric.open(result); }; BigInteger output = runApplication(app); Assert.assertEquals(BigInteger.ZERO, output); } };
@Override public void test() { Application<SInt, ProtocolBuilderNumeric> testApplication = root -> { DRes<SInt> left = root.numeric().known(BigInteger.ZERO); DRes<SInt> right = root.numeric().known(BigInteger.ONE); return root.numeric().mult(left, right); }; // this test verifies that the round synchronization logic works when the threshold for // open values is exceeded runApplication(testApplication); Assert.assertFalse( "There should be no unchecked opened values after the evaluation has finished", conf.getResourcePool().getOpenedValueStore().hasPendingValues()); } };
@Override public void test() { Application<SInt, ProtocolBuilderNumeric> testApplication = root -> { DRes<SInt> left = root.numeric().known(BigInteger.ZERO); DRes<SInt> right = root.numeric().known(BigInteger.ONE); return root.numeric().mult(left, right); }; // this tests verifies that the round synchronization logic works correctly when we // do not have output protocols in our application but still open values during // multiplication runApplication(testApplication); Assert.assertFalse( "There should be no unchecked opened values after the evaluation has finished", conf.getResourcePool().getOpenedValueStore().hasPendingValues()); } };