@Override public DRes<SBool> xnor(DRes<SBool> left, boolean right) { if (right) { return left; } else { return builder.binary().not(left); } }
@Override public DRes<SBool> buildComputation(ProtocolBuilderBinary builder) { if (inB) { return inA; } else { return builder.binary().known(false); } } }
@Override public DRes<SBool> buildComputation(ProtocolBuilderBinary builder) { if (inB) { return builder.binary().known(true); } else { return inA; } } }
@Override public DRes<SBool> buildComputation(ProtocolBuilderBinary builder) { return builder.seq(seq -> { int round = 0; DRes<SBool> xor = seq.binary().xor(inA.get(length - 1), inB.get(length - 1)); round++; DRes<SBool> outC = seq.binary().and(inA.get(length - 1), xor); round++; return new IterationState(round, outC); }).whileLoop( (state) -> state.round <= length, (seq, state) -> { int i = length - state.round; DRes<SBool> xor = seq.binary().xor(inA.get(i), inB.get(i)); DRes<SBool> tmp = seq.binary().xor(inA.get(i), state.value); tmp = seq.binary().and(tmp, xor); DRes<SBool> outC = seq.binary().xor(state.value, tmp); return new IterationState(state.round + 1, outC); }).seq((state, seq) -> { return seq.value; }); }
@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()); }); } }
@Override public DRes<SBool> buildComputation(ProtocolBuilderBinary builder) { Binary binary = builder.binary(); DRes<SBool> x = binary.xor(a, b); DRes<SBool> y = binary.and(selector, x); return binary.xor(y, b); }
@Override public void test() throws Exception { Application<List<Boolean>, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { AdvancedBinary prov = seq.advancedBinary(); DRes<SBool> increment = seq.binary().known(true); List<DRes<SBool>> large = rawLarge.stream().map(seq.binary()::known).collect(Collectors.toList()); DRes<List<DRes<SBool>>> adder = prov.bitIncrement(large, increment); return adder; }).seq((seq, dat) -> { List<DRes<Boolean>> out = new ArrayList<>(); for (DRes<SBool> o : dat) { out.add(seq.binary().open(o)); } return () -> out.stream().map(DRes::out).collect(Collectors.toList()); }); List<Boolean> outputs = runApplication(app); Assert.assertThat(ByteAndBitConverter.toHex(outputs), Is.is(expected)); Assert.assertThat(outputs.size(), Is.is(rawLarge.size() + 1)); } };
@Override public void test() throws Exception { Application<List<Boolean>, ProtocolBuilderBinary> app = producer -> { ProtocolBuilderBinary builder = (ProtocolBuilderBinary) producer; return builder.seq(seq -> { AdvancedBinary prov = seq.advancedBinary(); List<DRes<SBool>> first = rawFirst.stream().map(seq.binary()::known).collect(Collectors.toList()); DRes<List<DRes<SBool>>> log = prov.logProtocol(first); return log::out; }).seq((seq, dat) -> { List<DRes<Boolean>> out = new ArrayList<DRes<Boolean>>(); for (DRes<SBool> o : dat) { out.add(seq.binary().open(o)); } return () -> out.stream().map(DRes::out).collect(Collectors.toList()); }); }; List<Boolean> outputs = runApplication(app); Assert.assertThat(ByteAndBitConverter.toHex(outputs), Is.is(expected)); } };
@Override public void test() throws Exception { Boolean[] comp1 = new Boolean[] {false, true, false, true, false}; Boolean[] comp2 = new Boolean[] {false, true, true, true, false}; Application<List<Boolean>, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { List<DRes<SBool>> in1 = BooleanHelper.known(comp1, seq.binary()); List<DRes<SBool>> in2 = BooleanHelper.known(comp2, seq.binary()); DRes<SBool> res1 = seq.comparison().greaterThan(in1, in2); DRes<SBool> res2 = seq.comparison().greaterThan(in2, in1); DRes<Boolean> open1 = seq.binary().open(res1); DRes<Boolean> open2 = seq.binary().open(res2); return () -> Arrays.asList(open1, open2); }).seq( (seq, opened) -> () -> opened.stream().map(DRes::out).collect(Collectors.toList())); List<Boolean> res = runApplication(app); if (doAsserts) { Assert.assertEquals(false, res.get(0)); Assert.assertEquals(true, res.get(1)); } } };
@Override public void test() throws Exception { Application<Boolean, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { DRes<SBool> in = seq.binary().input(true, 2); DRes<Boolean> open = seq.binary().open(in); return open; }).seq((seq, out) -> { return () -> out; }); boolean output = runApplication(app); if (doAsserts) { Assert.assertEquals(true, output); } } };
@Override public void test() throws Exception { Application<Boolean, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { DRes<SBool> in = seq.binary().input(true, 1); DRes<Boolean> open = seq.binary().open(in); return open; }).seq((seq, out) -> { return () -> out; }); boolean output = runApplication(app); if (doAsserts) { Assert.assertEquals(true, output); } } };
@Override public void test() throws Exception { Application<Boolean, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { DRes<SBool> in = seq.binary().randomBit(); DRes<Boolean> open = seq.binary().open(in); return open; }).seq((seq, out) -> { return () -> out; }); boolean output = runApplication(app); if (doAsserts) { Assert.assertEquals(true, output); } } };
@Override public void test() throws Exception { Application<List<Boolean>, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { Binary builder = seq.binary(); DRes<SBool> falseBool = builder.known(false); DRes<SBool> trueBool = builder.known(true); List<DRes<Boolean>> list = new ArrayList<>(); list.add(builder.open(builder.not(falseBool))); list.add(builder.open(builder.not(trueBool))); return () -> list; }).seq((seq, list) -> { return () -> list.stream().map(DRes::out).collect(Collectors.toList()); }); List<Boolean> outs = runApplication(app); if (doAsserts) { Assert.assertEquals(true, outs.get(0)); Assert.assertEquals(false, outs.get(1)); } } };
@Override public void test() throws Exception { Application<Void, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { List<DRes<SBool>> toPrint = BooleanHelper.known(new Boolean[] {true, false, false, true}, seq.binary()); return () -> toPrint; }).seq((seq, inputs) -> { seq.debug().openAndPrint("test", inputs, stream); seq.debug().marker("test", stream); return null; }); runApplication(app); String output = bytes.toString("UTF-8"); Assert.assertEquals("test\n1001\ntest\n", output.replace("\r", "")); } };
@Override public void test() throws Exception { Application<Void, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { List<DRes<SBool>> toPrint = BooleanHelper.known(new Boolean[] {true, false, false, true}, seq.binary()); return () -> toPrint; }).seq((seq, inputs) -> { seq.debug().openAndPrint("test", inputs); seq.debug().marker("test"); return null; }); runApplication(app); } };