public void SetFail2Test() { // Should fail if set to bigger than 62 bits SmallModulus sm = new SmallModulus(); sm.Set(0x7FFFFFFFFFFFFFFFul); }
public void SaveLoadTest() { SmallModulus sm1 = new SmallModulus(65537ul); SmallModulus sm2 = new SmallModulus(); Assert.AreNotSame(sm1, sm2); Assert.AreNotEqual(sm1, sm2); Assert.AreNotEqual(sm1.IsPrime, sm2.IsPrime); using (MemoryStream stream = new MemoryStream()) { sm1.Save(stream); stream.Seek(offset: 0, loc: SeekOrigin.Begin); sm2.Load(stream); } Assert.AreNotSame(sm1, sm2); Assert.AreEqual(sm1, sm2); Assert.AreEqual(sm1.BitCount, sm2.BitCount); Assert.AreEqual(sm1.UInt64Count, sm2.UInt64Count); Assert.AreEqual(sm1.ConstRatio.Item1, sm2.ConstRatio.Item1); Assert.AreEqual(sm1.ConstRatio.Item2, sm2.ConstRatio.Item2); Assert.AreEqual(sm1.ConstRatio.Item3, sm2.ConstRatio.Item3); Assert.AreEqual(sm1.IsPrime, sm2.IsPrime); }
public void SetFail2Test() { // Should fail if set to bigger than 62 bits SmallModulus sm = new SmallModulus(); Utilities.AssertThrows <ArgumentException>(() => sm.Set(0x7FFFFFFFFFFFFFFFul)); }
public void BinaryFractionalEncodeDecodeNET() { var polyModulus = new BigPoly("1x^1024 + 1"); var modulus = new SmallModulus(0x10000); var encoder = new BinaryFractionalEncoder(modulus, polyModulus, 500, 50, MemoryPoolHandle.New()); var poly = encoder.Encode(0.0); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0.0, encoder.Decode(poly)); var poly1 = encoder.Encode(-1.0); Assert.AreEqual(-1.0, encoder.Decode(poly1)); var poly2 = encoder.Encode(0.1); Assert.IsTrue(Math.Abs(encoder.Decode(poly2) - 0.1) / 0.1 < 0.000001); var poly3 = encoder.Encode(3.123); Assert.IsTrue(Math.Abs(encoder.Decode(poly3) - 3.123) / 3.123 < 0.000001); var poly4 = encoder.Encode(-123.456); Assert.IsTrue(Math.Abs(encoder.Decode(poly4) + 123.456) / (-123.456) < 0.000001); var poly5 = encoder.Encode(12345.98765); Assert.IsTrue(Math.Abs(encoder.Decode(poly5) - 12345.98765) / 12345.98765 < 0.000001); }
public void ValueConstructorTest() { SmallModulus sm = new SmallModulus(5); Assert.IsNotNull(sm); Assert.IsFalse(sm.IsZero); Assert.AreEqual(5ul, sm.Value); Assert.AreEqual(3, sm.BitCount); Assert.IsTrue(sm.IsPrime); // Value is exactly 62 bits SmallModulus sm2 = new SmallModulus(0x3FFFFFFFFFFFFFFFul); Assert.IsNotNull(sm2); Assert.IsFalse(sm2.IsZero); Assert.AreEqual(0x3FFFFFFFFFFFFFFFul, sm2.Value); Assert.AreEqual(62, sm2.BitCount); Assert.AreEqual(1ul, sm2.UInt64Count); Assert.IsFalse(sm2.IsPrime); SmallModulus sm3 = new SmallModulus(0xF00000F000079ul); Assert.IsNotNull(sm3); Assert.IsFalse(sm3.IsZero); Assert.AreEqual(0xF00000F000079ul, sm3.Value); Assert.AreEqual(52, sm3.BitCount); Assert.AreEqual(1ul, sm3.UInt64Count); Assert.IsTrue(sm3.IsPrime); }
public void SetFail1Test() { // Should faile if set to 1 SmallModulus sm = new SmallModulus(); Utilities.AssertThrows <ArgumentException>(() => sm.Set(1)); }
public void SetFail1Test() { // Should faile if set to 1 SmallModulus sm = new SmallModulus(); sm.Set(1); }
public void ExplicitCreateTest() { SmallModulus sm = (SmallModulus)34ul; Assert.IsNotNull(sm); Assert.AreEqual(34ul, sm.Value); }
public void SmallMods60BitTest() { SmallModulus sm = DefaultParams.SmallMods60Bit(45); Assert.IsNotNull(sm); Assert.AreEqual(60, sm.BitCount); Assert.AreEqual(0x0ffffffff1740001ul, sm.Value); }
public void CopyConstructorTest() { SmallModulus sm = new SmallModulus(10); SmallModulus copy = new SmallModulus(sm); Assert.IsNotNull(copy); Assert.IsFalse(copy.IsZero); Assert.AreEqual(10ul, copy.Value); }
public void EmptyConstructorTest() { SmallModulus sm = new SmallModulus(); Assert.IsNotNull(sm); Assert.IsTrue(sm.IsZero); Assert.AreEqual(0ul, sm.Value); Assert.AreEqual(0, sm.BitCount); Assert.AreEqual(1ul, sm.UInt64Count); }
public void ExceptionsTest() { SmallModulus sm = new SmallModulus(0x12345ul); Utilities.AssertThrows <ArgumentNullException>(() => sm = new SmallModulus(null)); Utilities.AssertThrows <ArgumentNullException>(() => sm.Set(null)); Utilities.AssertThrows <ArgumentNullException>(() => sm.Save(null)); Utilities.AssertThrows <ArgumentNullException>(() => sm.Load(null)); Utilities.AssertThrows <EndOfStreamException>(() => sm.Load(new MemoryStream())); }
public void SmallMods30BitTest() { SmallModulus sm = DefaultParams.SmallMods30Bit(20); Assert.IsNotNull(sm); Assert.AreEqual(30, sm.BitCount); Assert.AreEqual(0x3BE80001ul, sm.Value); Assert.ThrowsException <ArgumentOutOfRangeException>(() => DefaultParams.SmallMods30Bit(64)); }
public void EqualsTest() { SmallModulus sm1 = new SmallModulus(0x12345ul); SmallModulus sm2 = new SmallModulus(0x12345ul); Assert.AreEqual(sm1, sm2); Assert.AreEqual(sm1.GetHashCode(), sm2.GetHashCode()); Assert.IsTrue(sm1.Equals(0x12345ul)); Assert.IsFalse(sm1.Equals(0x1234ul)); Assert.IsFalse(sm1.Equals(null)); }
public void ExceptionsTest() { SmallModulus sm = new SmallModulus(0x12345ul); MemoryStream ms_empty = new MemoryStream(); Assert.ThrowsException <ArgumentNullException>(() => sm = new SmallModulus(null)); Assert.ThrowsException <ArgumentNullException>(() => sm.Set(null)); Assert.ThrowsException <ArgumentNullException>(() => sm.Save(null)); Assert.ThrowsException <ArgumentNullException>(() => sm.Load(null)); Assert.ThrowsException <ArgumentException>(() => sm.Load(ms_empty)); }
public void ConstRatioTest() { SmallModulus sm = new SmallModulus(); sm.Set(0x1234567890ABCDEFul); Tuple <ulong, ulong, ulong> ratio = sm.ConstRatio; Assert.IsNotNull(ratio); Assert.AreNotEqual(0ul, ratio.Item1); Assert.AreNotEqual(0ul, ratio.Item2); Assert.AreNotEqual(0ul, ratio.Item3); }
public void CreateSmallModulusNET() { var mod = new SmallModulus(); Assert.IsTrue(mod.IsZero); Assert.AreEqual(0UL, mod.Value); Assert.AreEqual(0, mod.BitCount); Assert.AreEqual(1, mod.UInt64Count); Assert.AreEqual(0UL, mod.ConstRatio.Item1); Assert.AreEqual(0UL, mod.ConstRatio.Item2); Assert.AreEqual(0UL, mod.ConstRatio.Item3); mod.Set(3); Assert.IsFalse(mod.IsZero); Assert.AreEqual(3UL, mod.Value); Assert.AreEqual(2, mod.BitCount); Assert.AreEqual(1, mod.UInt64Count); Assert.AreEqual(6148914691236517205UL, mod.ConstRatio.Item1); Assert.AreEqual(6148914691236517205UL, mod.ConstRatio.Item2); Assert.AreEqual(1UL, mod.ConstRatio.Item3); var mod2 = new SmallModulus(2); var mod3 = new SmallModulus(3); Assert.IsFalse(mod.Equals(mod2)); Assert.IsTrue(mod.Equals(mod3)); mod.Set(0); Assert.IsTrue(mod.IsZero); Assert.AreEqual(0UL, mod.Value); Assert.AreEqual(0, mod.BitCount); Assert.AreEqual(1, mod.UInt64Count); Assert.AreEqual(0UL, mod.ConstRatio.Item1); Assert.AreEqual(0UL, mod.ConstRatio.Item2); Assert.AreEqual(0UL, mod.ConstRatio.Item3); mod.Set(0xF00000F00000F); Assert.IsFalse(mod.IsZero); Assert.AreEqual(0xF00000F00000FUL, mod.Value); Assert.AreEqual(52, mod.BitCount); Assert.AreEqual(1, mod.UInt64Count); Assert.AreEqual(1224979098644774929UL, mod.ConstRatio.Item1); Assert.AreEqual(4369UL, mod.ConstRatio.Item2); Assert.AreEqual(281470698520321UL, mod.ConstRatio.Item3); }
public void SaveLoadSmallModulusNET() { var stream = new MemoryStream(); var mod = new SmallModulus(); stream.Seek(0, SeekOrigin.Begin); mod.Save(stream); var mod2 = new SmallModulus(); stream.Seek(0, SeekOrigin.Begin); mod2.Load(stream); Assert.AreEqual(mod2.Value, mod.Value); Assert.AreEqual(mod2.BitCount, mod.BitCount); Assert.AreEqual(mod2.UInt64Count, mod.UInt64Count); Assert.AreEqual(mod2.ConstRatio.Item1, mod.ConstRatio.Item1); Assert.AreEqual(mod2.ConstRatio.Item2, mod.ConstRatio.Item2); Assert.AreEqual(mod2.ConstRatio.Item3, mod.ConstRatio.Item3); mod.Set(3); stream.Seek(0, SeekOrigin.Begin); mod.Save(stream); stream.Seek(0, SeekOrigin.Begin); mod2.Load(stream); Assert.AreEqual(mod2.Value, mod.Value); Assert.AreEqual(mod2.BitCount, mod.BitCount); Assert.AreEqual(mod2.UInt64Count, mod.UInt64Count); Assert.AreEqual(mod2.ConstRatio.Item1, mod.ConstRatio.Item1); Assert.AreEqual(mod2.ConstRatio.Item2, mod.ConstRatio.Item2); Assert.AreEqual(mod2.ConstRatio.Item3, mod.ConstRatio.Item3); mod.Set(0xF00000F00000F); stream.Seek(0, SeekOrigin.Begin); mod.Save(stream); stream.Seek(0, SeekOrigin.Begin); mod2.Load(stream); Assert.AreEqual(mod2.Value, mod.Value); Assert.AreEqual(mod2.BitCount, mod.BitCount); Assert.AreEqual(mod2.UInt64Count, mod.UInt64Count); Assert.AreEqual(mod2.ConstRatio.Item1, mod.ConstRatio.Item1); Assert.AreEqual(mod2.ConstRatio.Item2, mod.ConstRatio.Item2); Assert.AreEqual(mod2.ConstRatio.Item3, mod.ConstRatio.Item3); }
public void ExceptionsTest() { SmallModulus sm = new SmallModulus(0x12345ul); MemoryStream ms_empty = new MemoryStream(); Assert.ThrowsException <ArgumentNullException>(() => sm = new SmallModulus(null)); Assert.ThrowsException <ArgumentNullException>(() => sm.Set(null)); Assert.ThrowsException <ArgumentNullException>(() => sm.Save(null)); Assert.ThrowsException <ArgumentNullException>(() => sm.Load(null)); Assert.ThrowsException <ArgumentException>(() => sm.Load(ms_empty)); MemoryStream ms = new MemoryStream(); using (BinaryWriter writer = new BinaryWriter(ms, Encoding.UTF8, leaveOpen: true)) { // Bit count writer.Write(16); // Uint64 count writer.Write(1ul); // Value that does not match bit count writer.Write(0x123456789ABCDul); } ms.Seek(offset: 0, loc: SeekOrigin.Begin); Assert.ThrowsException <InvalidOperationException>(() => sm.Load(ms)); ms = new MemoryStream(); using (BinaryWriter writer = new BinaryWriter(ms, Encoding.UTF8, leaveOpen: true)) { // Bit count writer.Write(16); // UInt64 count that does not match value writer.Write(2ul); // Value writer.Write(0xFABCul); } ms.Seek(offset: 0, loc: SeekOrigin.Begin); Assert.ThrowsException <InvalidOperationException>(() => sm.Load(ms)); }
public void SetTest() { SmallModulus sm1 = new SmallModulus(456); SmallModulus sm2 = new SmallModulus(); Assert.IsFalse(sm1.IsZero); Assert.AreEqual(456ul, sm1.Value); Assert.IsTrue(sm2.IsZero); Assert.AreEqual(0ul, sm2.Value); sm2.Set(sm1); Assert.IsFalse(sm2.IsZero); Assert.AreEqual(456ul, sm2.Value); sm2.Set(value: 123); Assert.IsFalse(sm2.IsZero); Assert.AreEqual(123ul, sm2.Value); }
public void ConstRatioTest() { SmallModulus sm = new SmallModulus(); sm.Set(0x1234567890ABCDEFul); Tuple <ulong, ulong, ulong> ratio = sm.ConstRatio; Assert.IsNotNull(ratio); Assert.AreNotEqual(0ul, ratio.Item1); Assert.AreNotEqual(0ul, ratio.Item2); Assert.AreNotEqual(0ul, ratio.Item3); sm.Set(0xF00000F000079ul); ratio = sm.ConstRatio; Assert.IsNotNull(ratio); Assert.AreEqual(1224979096621368355ul, ratio.Item1); Assert.AreEqual(4369ul, ratio.Item2); Assert.AreEqual(1144844808538997ul, ratio.Item3); }
public void CompareToTest() { SmallModulus sminv = null; SmallModulus sm0 = new SmallModulus(); SmallModulus sm2 = new SmallModulus(2); SmallModulus sm5 = new SmallModulus(5); SmallModulus smbig = new SmallModulus(0xFFFFFFF); Assert.AreEqual(1, sm0.CompareTo(sminv)); Assert.AreEqual(0, sm0.CompareTo(sm0)); Assert.AreEqual(-1, sm2.CompareTo(sm5)); Assert.AreEqual(-1, sm2.CompareTo(smbig)); Assert.AreEqual(1, sm2.CompareTo(sminv)); Assert.AreEqual(0, sm5.CompareTo(sm5)); Assert.AreEqual(0, smbig.CompareTo(smbig)); Assert.AreEqual(1, smbig.CompareTo(sm0)); Assert.AreEqual(1, smbig.CompareTo(sm5)); Assert.AreEqual(1, smbig.CompareTo(sminv)); Assert.AreEqual(-1, sm5.CompareTo(6)); Assert.AreEqual(0, sm5.CompareTo(5)); Assert.AreEqual(1, sm5.CompareTo(4)); Assert.AreEqual(1, sm5.CompareTo(0)); }
public void BalancedFractionalEncodeDecodeNET() { var polyModulus = new BigPoly("1x^1024 + 1"); var modulus = new SmallModulus(0x10000); var poly = new Plaintext(); var poly1 = new Plaintext(); var poly2 = new Plaintext(); var poly3 = new Plaintext(); var poly4 = new Plaintext(); var poly5 = new Plaintext(); for (ulong b = 3; b < 20; b += 2) { var encoder = new BalancedFractionalEncoder(modulus, polyModulus, 500, 50, b, MemoryPoolHandle.New()); poly = encoder.Encode(0.0); Assert.AreEqual(1, poly.CoeffCount); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0.0, encoder.Decode(poly)); poly1 = encoder.Encode(-1.0); Assert.AreEqual(-1.0, encoder.Decode(poly1)); poly2 = encoder.Encode(0.1); Assert.IsTrue(Math.Abs(encoder.Decode(poly2) - 0.1) / 0.1 < 0.000001); poly3 = encoder.Encode(3.123); Assert.IsTrue(Math.Abs(encoder.Decode(poly3) - 3.123) / 3.123 < 0.000001); poly4 = encoder.Encode(-123.456); Assert.IsTrue(Math.Abs(encoder.Decode(poly4) + 123.456) / (-123.456) < 0.000001); poly5 = encoder.Encode(12345.98765); Assert.IsTrue(Math.Abs(encoder.Decode(poly5) - 12345.98765) / 12345.98765 < 0.000001); } }
public void BinaryEncodeDecodeInt32NET() { var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF); var encoder = new BinaryEncoder(modulus, MemoryPoolHandle.New()); var poly = encoder.Encode(0); Assert.AreEqual(0, poly.SignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0, encoder.DecodeInt32(poly)); var poly1 = encoder.Encode(1); Assert.AreEqual(1, poly1.SignificantCoeffCount()); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(1, encoder.DecodeInt32(poly1)); var poly2 = encoder.Encode(2); Assert.AreEqual(2, poly2.SignificantCoeffCount()); Assert.AreEqual("1x^1", poly2.ToString()); Assert.AreEqual(2, encoder.DecodeInt32(poly2)); var poly3 = encoder.Encode(3); Assert.AreEqual(2, poly3.SignificantCoeffCount()); Assert.AreEqual("1x^1 + 1", poly3.ToString()); Assert.AreEqual(3, encoder.DecodeInt32(poly3)); var poly4 = encoder.Encode(-1); Assert.AreEqual(1, poly4.SignificantCoeffCount()); Assert.AreEqual("FFFFFFFFFFFFFFE", poly4.ToString()); Assert.AreEqual(-1, encoder.DecodeInt32(poly4)); var poly5 = encoder.Encode(-2); Assert.AreEqual(2, poly5.SignificantCoeffCount()); Assert.AreEqual("FFFFFFFFFFFFFFEx^1", poly5.ToString()); Assert.AreEqual(-2, encoder.DecodeInt32(poly5)); var poly6 = encoder.Encode(-3); Assert.AreEqual(2, poly6.SignificantCoeffCount()); Assert.AreEqual("FFFFFFFFFFFFFFEx^1 + FFFFFFFFFFFFFFE", poly6.ToString()); Assert.AreEqual(-3, encoder.DecodeInt32(poly6)); var poly7 = encoder.Encode(0x7FFFFFFF); Assert.AreEqual(31, poly7.SignificantCoeffCount()); for (int i = 0; i < 31; ++i) { Assert.AreEqual("1", poly7[i].ToString()); } Assert.AreEqual(0x7FFFFFFF, encoder.DecodeInt32(poly7)); var poly8 = encoder.Encode(unchecked ((int)0x80000000)); Assert.AreEqual(32, poly8.SignificantCoeffCount()); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly8[31]); for (int i = 0; i < 31; ++i) { Assert.IsTrue(poly8[i] == 0); } Assert.AreEqual(unchecked ((int)0x80000000), encoder.DecodeInt32(poly8)); var poly9 = encoder.Encode(0x80F02); Assert.AreEqual(20, poly9.SignificantCoeffCount()); for (int i = 0; i < 20; ++i) { if (i == 19 || (i >= 8 && i <= 11) || i == 1) { Assert.AreEqual("1", poly9[i].ToString()); } else { Assert.IsTrue(poly9[i] == 0); } } Assert.AreEqual(0x80F02, encoder.DecodeInt32(poly9)); var poly10 = encoder.Encode(-1073); Assert.AreEqual(11, poly10.SignificantCoeffCount()); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[10]); Assert.IsTrue(poly10[9] == 0); Assert.IsTrue(poly10[8] == 0); Assert.IsTrue(poly10[7] == 0); Assert.IsTrue(poly10[6] == 0); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[5]); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[4]); Assert.IsTrue(poly10[3] == 0); Assert.IsTrue(poly10[2] == 0); Assert.IsTrue(poly10[1] == 0); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[0]); Assert.AreEqual(-1073, encoder.DecodeInt32(poly10)); modulus.Set(0xFFFF); var encoder2 = new BinaryEncoder(modulus, MemoryPoolHandle.New()); var poly11 = new Plaintext(6); poly11[0] = 1; poly11[1] = 0xFFFE; // -1 poly11[2] = 0xFFFD; // -2 poly11[3] = 0x8000; // -32767 poly11[4] = 0x7FFF; // 32767 poly11[5] = 0x7FFE; // 32766 Assert.AreEqual(1 + -1 * 2 + -2 * 4 + -32767 * 8 + 32767 * 16 + 32766 * 32, encoder2.DecodeInt32(poly11)); }
public void BinaryEncodeDecodeBigUIntNET() { var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF); var encoder = new BinaryEncoder(modulus); var value = new BigUInt(64); value.Set("0"); var poly = encoder.Encode(value); Assert.AreEqual(0, poly.SignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(value, encoder.DecodeBigUInt(poly)); value.Set("1"); var poly1 = encoder.Encode(value); Assert.AreEqual(1, poly1.SignificantCoeffCount()); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(value, encoder.DecodeBigUInt(poly1)); value.Set("2"); var poly2 = encoder.Encode(value); Assert.AreEqual(2, poly2.SignificantCoeffCount()); Assert.AreEqual("1x^1", poly2.ToString()); Assert.AreEqual(value, encoder.DecodeBigUInt(poly2)); value.Set("3"); var poly3 = encoder.Encode(value); Assert.AreEqual(2, poly3.SignificantCoeffCount()); Assert.AreEqual("1x^1 + 1", poly3.ToString()); Assert.AreEqual(value, encoder.DecodeBigUInt(poly3)); value.Set("FFFFFFFFFFFFFFFF"); var poly4 = encoder.Encode(value); Assert.AreEqual(64, poly4.SignificantCoeffCount()); for (int i = 0; i < 64; ++i) { Assert.AreEqual("1", poly4[i].ToString()); } Assert.AreEqual(value, encoder.DecodeBigUInt(poly4)); value.Set("80F02"); var poly5 = encoder.Encode(value); Assert.AreEqual(20, poly5.SignificantCoeffCount()); for (int i = 0; i < 20; ++i) { if (i == 19 || (i >= 8 && i <= 11) || i == 1) { Assert.AreEqual("1", poly5[i].ToString()); } else { Assert.IsTrue(poly5[i] == 0); } } Assert.AreEqual(value, encoder.DecodeBigUInt(poly5)); var poly6 = new Plaintext(3); poly6[0] = 1; poly6[1] = 500; poly6[2] = 1023; value.Set(1 + 500 * 2 + 1023 * 4); Assert.AreEqual(value, encoder.DecodeBigUInt(poly6)); modulus.Set(1024); var encoder2 = new BinaryEncoder(modulus); var poly7 = new Plaintext(4); poly7[0] = 1023; // -1 (*1) poly7[1] = 512; // -512 (*2) poly7[2] = 511; // 511 (*4) poly7[3] = 1; // 1 (*8) value.Set(-1 + -512 * 2 + 511 * 4 + 1 * 8); Assert.AreEqual(value, encoder2.DecodeBigUInt(poly7)); }
public void ConstructorFail1Test() { // Should fail if value is 1 SmallModulus sm = new SmallModulus(1); }
public void BinaryEncodeDecodeUInt64NET() { var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF); var encoder = new BinaryEncoder(modulus, MemoryPoolHandle.New()); var poly = encoder.Encode(0UL); Assert.AreEqual(0, poly.SignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0UL, encoder.DecodeUInt64(poly)); var poly1 = encoder.Encode(1UL); Assert.AreEqual(1, poly1.SignificantCoeffCount()); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(1UL, encoder.DecodeUInt64(poly1)); var poly2 = encoder.Encode(2UL); Assert.AreEqual(2, poly2.SignificantCoeffCount()); Assert.AreEqual("1x^1", poly2.ToString()); Assert.AreEqual(2UL, encoder.DecodeUInt64(poly2)); var poly3 = encoder.Encode(3UL); Assert.AreEqual(2, poly3.SignificantCoeffCount()); Assert.AreEqual("1x^1 + 1", poly3.ToString()); Assert.AreEqual(3UL, encoder.DecodeUInt64(poly3)); var poly4 = encoder.Encode(0xFFFFFFFFFFFFFFFFUL); Assert.AreEqual(64, poly4.SignificantCoeffCount()); for (int i = 0; i < 64; ++i) { Assert.AreEqual("1", poly4[i].ToString()); } Assert.AreEqual(0xFFFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(poly4)); var poly5 = encoder.Encode(0x80F02UL); Assert.AreEqual(20, poly5.SignificantCoeffCount()); for (int i = 0; i < 20; ++i) { if (i == 19 || (i >= 8 && i <= 11) || i == 1) { Assert.AreEqual("1", poly5[i].ToString()); } else { Assert.IsTrue(poly5[i] == 0); } } Assert.AreEqual(0x80F02UL, encoder.DecodeUInt64(poly5)); var poly6 = new Plaintext(3); poly6[0] = 1; poly6[1] = 500; poly6[2] = 1023; Assert.AreEqual((1UL + 500 * 2 + 1023 * 4), encoder.DecodeUInt64(poly6)); modulus.Set(1024); var encoder2 = new BinaryEncoder(modulus, MemoryPoolHandle.New()); var poly7 = new Plaintext(4); poly7[0] = 1023; // -1 (*1) poly7[1] = 512; // -512 (*2) poly7[2] = 511; // 511 (*4) poly7[3] = 1; // 1 (*8) Assert.AreEqual((ulong)(-1 + -512 * 2 + 511 * 4 + 1 * 8), encoder2.DecodeUInt64(poly7)); }
public void BalancedEncodeDecodeInt32NET() { var modulus = new SmallModulus(0x10000); var encoder = new BalancedEncoder(modulus, 3, MemoryPoolHandle.New()); var poly = encoder.Encode(0); Assert.AreEqual(0, poly.SignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0, encoder.DecodeInt32(poly)); var poly1 = encoder.Encode(1); Assert.AreEqual(1, poly1.SignificantCoeffCount()); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(1, encoder.DecodeInt32(poly1)); var poly2 = encoder.Encode(2); Assert.AreEqual(2, poly2.SignificantCoeffCount()); Assert.AreEqual("1x^1 + FFFF", poly2.ToString()); Assert.AreEqual(2, encoder.DecodeInt32(poly2)); var poly3 = encoder.Encode(3); Assert.AreEqual(2, poly3.SignificantCoeffCount()); Assert.AreEqual("1x^1", poly3.ToString()); Assert.AreEqual(3, encoder.DecodeInt32(poly3)); var poly4 = encoder.Encode(-1); Assert.AreEqual(1, poly4.SignificantCoeffCount()); Assert.AreEqual("FFFF", poly4.ToString()); Assert.AreEqual(-1, encoder.DecodeInt32(poly4)); var poly5 = encoder.Encode(-2); Assert.AreEqual(2, poly5.SignificantCoeffCount()); Assert.AreEqual("FFFFx^1 + 1", poly5.ToString()); Assert.AreEqual(-2, encoder.DecodeInt32(poly5)); var poly6 = encoder.Encode(-3); Assert.AreEqual(2, poly6.SignificantCoeffCount()); Assert.AreEqual("FFFFx^1", poly6.ToString()); Assert.AreEqual(-3, encoder.DecodeInt32(poly6)); var poly7 = encoder.Encode(-0x2671); Assert.AreEqual(9, poly7.SignificantCoeffCount()); for (int i = 0; i < 9; ++i) { Assert.AreEqual(0xFFFFUL, poly7[i]); } Assert.AreEqual(-0x2671, encoder.DecodeInt32(poly7)); var poly8 = encoder.Encode(-4374); Assert.AreEqual(9, poly8.SignificantCoeffCount()); Assert.AreEqual(0xFFFFUL, poly8[8]); Assert.AreEqual(1UL, poly8[7]); for (int i = 0; i < 7; ++i) { Assert.IsTrue(poly8[i] == 0); } Assert.AreEqual(-4374, encoder.DecodeInt32(poly8)); var poly9 = encoder.Encode(-0xD4EB); Assert.AreEqual(11, poly9.SignificantCoeffCount()); for (int i = 0; i < 11; ++i) { if (i % 3 == 1) { Assert.AreEqual(0xFFFFUL, poly9[i]); } else if (i % 3 == 0) { Assert.IsTrue(poly9[i] == 0); } else { Assert.AreEqual(1UL, poly9[i]); } } Assert.AreEqual(-0xD4EB, encoder.DecodeInt32(poly9)); var poly10 = encoder.Encode(-30724); Assert.AreEqual(11, poly10.SignificantCoeffCount()); Assert.AreEqual(0xFFFFUL, poly10[10]); Assert.AreEqual(1UL, poly10[9]); Assert.AreEqual(1UL, poly10[8]); Assert.AreEqual(1UL, poly10[7]); Assert.IsTrue(poly10[6] == 0); Assert.IsTrue(poly10[5] == 0); Assert.AreEqual(0xFFFFUL, poly10[4]); Assert.AreEqual(0xFFFFUL, poly10[3]); Assert.IsTrue(poly10[2] == 0); Assert.AreEqual(1UL, poly10[1]); Assert.AreEqual(0xFFFFUL, poly10[0]); Assert.AreEqual(-30724, encoder.DecodeInt32(poly10)); modulus.Set(0xFFFF); var encoder2 = new BalancedEncoder(modulus, 7, MemoryPoolHandle.New()); var poly12 = new Plaintext(6); poly12[0] = 1; poly12[1] = 0xFFFE; // -1 poly12[2] = 0xFFFD; // -2 poly12[3] = 0x8000; // -32767 poly12[4] = 0x7FFF; // 32767 poly12[5] = 0x7FFE; // 32766 Assert.AreEqual(1 + -1 * 7 + -2 * 49 + -32767 * 343 + 32767 * 2401 + 32766 * 16807, encoder2.DecodeInt32(poly12)); var encoder4 = new BalancedEncoder(modulus, 6, MemoryPoolHandle.New()); poly8 = new Plaintext(4); poly8[0] = 5; poly8[1] = 4; poly8[2] = 3; poly8[3] = (modulus.Value - 2); Int32 value = 5 + 4 * 6 + 3 * 36 - 2 * 216; Assert.AreEqual(value, encoder4.DecodeInt32(poly8)); var encoder5 = new BalancedEncoder(modulus, 10, MemoryPoolHandle.New()); poly9 = new Plaintext(4); poly9[0] = 1; poly9[1] = 2; poly9[2] = 3; poly9[3] = 4; value = 4321; Assert.AreEqual(value, encoder5.DecodeInt32(poly9)); value = -1234; poly10.Set(encoder2.Encode(value)); Assert.AreEqual(5, poly10.SignificantCoeffCount()); Assert.IsTrue(value.Equals(encoder2.DecodeInt32(poly10))); value = -1234; var poly11 = encoder4.Encode(value); Assert.AreEqual(5, poly11.SignificantCoeffCount()); Assert.AreEqual(value, encoder4.DecodeInt32(poly11)); value = -1234; poly12.Set(encoder5.Encode(value)); Assert.AreEqual(4, poly12.SignificantCoeffCount()); Assert.IsTrue(value.Equals(encoder5.DecodeInt32(poly12))); }
public void ConstructorFail2Test() { // Should fail if value is larger than 62 bits SmallModulus sm = new SmallModulus(0x7FFFFFFFFFFFFFFFul); }
public void BalancedEncodeDecodeUInt32NET() { var modulus = new SmallModulus(0x10000); var encoder = new BalancedEncoder(modulus, 3, MemoryPoolHandle.New()); var poly = encoder.Encode(0U); Assert.AreEqual(0, poly.SignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0U, encoder.DecodeUInt32(poly)); var poly1 = encoder.Encode(1U); Assert.AreEqual(1, poly1.SignificantCoeffCount()); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(1U, encoder.DecodeUInt32(poly1)); var poly2 = encoder.Encode(2U); Assert.AreEqual(2, poly2.SignificantCoeffCount()); Assert.AreEqual("1x^1 + FFFF", poly2.ToString()); Assert.AreEqual(2U, encoder.DecodeUInt32(poly2)); var poly3 = encoder.Encode(3U); Assert.AreEqual(2, poly3.SignificantCoeffCount()); Assert.AreEqual("1x^1", poly3.ToString()); Assert.AreEqual(3U, encoder.DecodeUInt32(poly3)); var poly4 = encoder.Encode(0x2671U); Assert.AreEqual(9, poly4.SignificantCoeffCount()); for (int i = 0; i < 9; ++i) { Assert.AreEqual(1UL, poly4[i]); } Assert.AreEqual(0x2671U, encoder.DecodeUInt32(poly4)); var poly5 = encoder.Encode(0xD4EBU); Assert.AreEqual(11, poly5.SignificantCoeffCount()); for (int i = 0; i < 11; ++i) { if (i % 3 == 1) { Assert.AreEqual(1UL, poly5[i]); } else if (i % 3 == 0) { Assert.IsTrue(poly5[i] == 0); } else { Assert.AreEqual(0xFFFFUL, poly5[i]); } } Assert.AreEqual(0xD4EBU, encoder.DecodeUInt32(poly5)); var poly6 = new Plaintext(3); poly6[0] = 1; poly6[1] = 500; poly6[2] = 1023; Assert.AreEqual(1U + 500 * 3 + 1023 * 9, encoder.DecodeUInt32(poly6)); var encoder2 = new BalancedEncoder(modulus, 7, MemoryPoolHandle.New()); var poly7 = new Plaintext(4); poly7[0] = 123; // 123 (*1) poly7[1] = 0xFFFF; // -1 (*7) poly7[2] = 511; // 511 (*49) poly7[3] = 1; // 1 (*343) Assert.AreEqual((UInt32)(123 + -1 * 7 + 511 * 49 + 1 * 343), encoder2.DecodeUInt32(poly7)); var encoder3 = new BalancedEncoder(modulus, 6, MemoryPoolHandle.New()); var poly8 = new Plaintext(4); poly8[0] = 5; poly8[1] = 4; poly8[2] = 3; poly8[3] = 2; UInt64 value = 5 + 4 * 6 + 3 * 36 + 2 * 216; Assert.AreEqual(value, encoder3.DecodeUInt32(poly8)); var encoder4 = new BalancedEncoder(modulus, 10, MemoryPoolHandle.New()); var poly9 = new Plaintext(4); poly9[0] = 1; poly9[1] = 2; poly9[2] = 3; poly9[3] = 4; value = 4321; Assert.AreEqual(value, encoder4.DecodeUInt32(poly9)); value = 1234; var poly10 = encoder2.Encode(value); Assert.AreEqual(5, poly10.SignificantCoeffCount()); Assert.IsTrue(value.Equals(encoder2.DecodeUInt32(poly10))); value = 1234; var poly11 = encoder3.Encode(value); Assert.AreEqual(5, poly11.SignificantCoeffCount()); Assert.IsTrue(value.Equals(encoder3.DecodeUInt32(poly11))); value = 1234; var poly12 = encoder4.Encode(value); Assert.AreEqual(4, poly12.SignificantCoeffCount()); Assert.IsTrue(value.Equals(encoder4.DecodeUInt32(poly12))); }