@Override public DRes<List<List<DRes<SBool>>>> buildComputation(ProtocolBuilderBinary builder) { return builder.seq(seq -> { return seq.comparison().greaterThan(right, left); }).par((par, data) -> { List<DRes<SBool>> first = left.stream() .map(e -> {return par.advancedBinary().condSelect(data, e, right.get(left.indexOf(e)));}) .collect(Collectors.toList()); List<DRes<SBool>> second = right.stream() .map(e -> {return par.advancedBinary().condSelect(data, e, left.get(right.indexOf(e)));}) .collect(Collectors.toList()); List<List<DRes<SBool>>> result = new ArrayList<List<DRes<SBool>>>(); result.add(first); result.add(second); return () -> result; }); } }
}).par((par, means) -> {
}).par((par, inputs) -> { List<DRes<List<SBool>>> aesResults = new ArrayList<>(); for (List<DRes<SBool>> set : inputs.set1) {
comparisons.add(numericBuilder.sub(BigInteger.ONE, lastComparison)); return () -> comparisons; }).par((parallelBuilder, comparisons) -> {
.collect(Collectors.toList()); return () -> upColumn; }).par((innerPar, upColumn) -> { upColumn.remove(upColumn.size() - 1); List<DRes<SInt>> basisValues = upColumn.stream() .map(n -> innerPar.numeric().mult(invPivot, n)).collect(Collectors.toList()); return () -> basisValues; }).par((innerPar, basisValues) -> { List<DRes<SInt>> above = lpOutput.basis.stream().map(n -> innerPar.comparison().compareLEQ(firstPeer, n)) newState.add(basisValues); return () -> newState; }).par((innerPar, state) -> { List<DRes<SInt>> inRange = IntStream.range(0, lpOutput.basis.size()) .mapToObj(n -> innerPar.numeric().mult(state.get(0).get(n), state.get(1).get(n))) newState.add(state.get(2)); return () -> newState; }).par((innerPar, state) -> { List<DRes<SInt>> peers = IntStream.range(0, lpOutput.basis.size()) .mapToObj(n -> innerPar.numeric().mult(lpOutput.basis.get(n), state.get(0).get(n))) newState.add(peerValues); return () -> newState; }).par((innerPar, state) -> { List<DRes<SInt>> peersFromZero = state.get(0).stream() .map(n -> innerPar.numeric().sub(n, f)).collect(Collectors.toList());
@Override public void test() { Application<List<BigInteger>, ProtocolBuilderNumeric> app = producer -> producer.par(par -> { Numeric numeric = par.numeric(); List<DRes<SInt>> result = openInputs.stream().map(numeric::known).collect(Collectors.toList()); return () -> result; }).par((par, closed) -> { Numeric numeric = par.numeric(); List<DRes<BigInteger>> result = closed.stream().map(numeric::open).collect(Collectors.toList()); return () -> result.stream().map(DRes::out).collect(Collectors.toList()); }); List<BigInteger> output = runApplication(app); Assert.assertEquals(openInputs, output); } };
}).par((par, powers) -> {
}).par((par, powers) -> { List<DRes<SReal>> terms = powers.stream() .map(
@Override public void test() throws Exception { Application<List<BigInteger>, ProtocolBuilderNumeric> app = builder -> { Numeric input = builder.numeric(); List<DRes<SInt>> unsorted = values.stream().map(input::known) .collect(Collectors.toList()); return builder.seq(seq -> { new SortingHelperUtility().sort(seq, unsorted); return () -> unsorted; }).par((par, list) -> { Numeric numeric = par.numeric(); List<DRes<BigInteger>> openList = list.stream().map(numeric::open) .collect(Collectors.toList()); return () -> openList.stream().map(DRes::out).collect(Collectors.toList()); }); }; List<BigInteger> outputs = runApplication(app); Assert.assertEquals(sorted, outputs); }
).par((par, means) -> { SInt mean1 = means.getFirst(); SInt mean2 = means.getSecond();
@Override public void test() throws Exception { Application<List<BigInteger>, ProtocolBuilderNumeric> app = builder -> { Numeric input = builder.numeric(); DRes<SInt> zero = input.known(BigInteger.ZERO); SIntListofTuples list1 = new SIntListofTuples(2); SIntListofTuples list2 = new SIntListofTuples(2); list1.add(values.get(0).stream().map(input::known).collect(Collectors.toList()), zero); list1.add(values.get(1).stream().map(input::known).collect(Collectors.toList()), zero); list1.add(values.get(2).stream().map(input::known).collect(Collectors.toList()), zero); list2.add(values.get(2).stream().map(input::known).collect(Collectors.toList()), zero); list2.add(values.get(3).stream().map(input::known).collect(Collectors.toList()), zero); list2.add(values.get(4).stream().map(input::known).collect(Collectors.toList()), zero); return builder.par(par -> { new FindDuplicatesHelper().findDuplicates(par, list1, list2); return () -> list1; }).par((par, list) -> { Numeric numeric = par.numeric(); List<DRes<BigInteger>> openDuplicates = Arrays.asList(numeric.open(list.getDuplicate(0)), numeric.open(list.getDuplicate(1)), numeric.open(list.getDuplicate(2))); return () -> openDuplicates.stream().map(DRes::out).collect(Collectors.toList()); }); }; List<BigInteger> outputs = runApplication(app); Assert.assertEquals(BigInteger.ZERO, outputs.get(0)); Assert.assertEquals(BigInteger.ZERO, outputs.get(1)); Assert.assertEquals(BigInteger.ONE, outputs.get(2)); } };
@Override public DRes<Pair<SBool, SBool>> buildComputation(ProtocolBuilderBinary builder) { return builder.par(par -> { xor1 = par.binary().xor(valueA, valueB); and1 = par.binary().and(valueA, valueB); return () -> (par); }).par((par, pair) -> { xor2 = par.binary().xor(xor1, carry); and2 = par.binary().and(xor1, carry); return () -> (par); }).par((par, pair) -> { xor3 = par.binary().xor(and2, and1); return () -> new Pair<SBool, SBool>(xor2.out(), xor3.out()); }); } }
DRes<SInt> secondClosed = numeric.known(second); return Pair.lazy(firstClosed, secondClosed); }).par((par, pair) -> { DRes<SInt> firstClosed = pair.getFirst(); DRes<SInt> secondClosed = pair.getSecond(); }).par((par, computations) -> { Numeric numeric = par.numeric(); List<DRes<BigInteger>> opened =
DRes<SBool> trueBool = builder.known(true); return () -> new Pair<>(falseBool, trueBool); }).par((par, boolPair) -> { Binary builder = par.binary(); DRes<SBool> falseBool = boolPair.getFirst(); }).par((par, list) -> { List<DRes<Boolean>> openList = new ArrayList<>(list.size()); for (DRes<SBool> s : list) { }).par((par, list) -> { return () -> list.stream().map(DRes::out).collect(Collectors.toList()); });
}).par((par, pipes) -> { List<DRes<BigInteger>> output = pipes.stream() .map(v -> v.out())
DRes<SInt> secondClosed = numeric.known(second); return Pair.lazy(firstClosed, secondClosed); }).par((par, pair) -> { DRes<SInt> firstClosed = pair.getFirst(); DRes<SInt> secondClosed = pair.getSecond();
BigInteger[] maskedPowers = seq.getBigIntegerHelper().getExpFromOInt(maskedO, maxLength); return () -> new Pair<>(expPipe, maskedPowers); }).par((par, pair) -> { List<DRes<SInt>> expPipe = pair.getFirst(); BigInteger[] maskedPowers = pair.getSecond();