public void SaveLoadEvaluationKeysNET()
{
var stream = new MemoryStream();
var keys = new EvaluationKeys(3);
keys[0].Resize(3, 32);
keys[0][0].Set(1);
keys[0][1].Set(2);
keys[0][2].Set(3);
keys[1].Resize(2, 96);
keys[1][0].Set(4);
keys[1][1].Set(5);
keys[2].Resize(1, 24);
keys[2][0].Set(6);
var keys2 = new EvaluationKeys();
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
keys2.Load(stream);
Assert.AreEqual(3, keys2.Count);
Assert.AreEqual(keys[0], keys2[0]);
Assert.AreEqual(keys[1], keys2[1]);
Assert.AreEqual(keys[2], keys2[2]);
}
public void FVKeyGenerationNET()
{
var parms = new EncryptionParameters();
{
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^64 + 1";
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods60Bit(0)
};
parms.PlainModulus = 1 << 6;
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
Assert.IsTrue(keygen.PublicKey.HashBlock.Equals(parms.HashBlock));
Assert.IsTrue(keygen.SecretKey.HashBlock.Equals(parms.HashBlock));
var evk = new EvaluationKeys();
keygen.GenerateEvaluationKeys(60, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(2, evk.Key(2)[0].Size);
keygen.GenerateEvaluationKeys(30, 1, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(4, evk.Key(2)[0].Size);
keygen.GenerateEvaluationKeys(2, 2, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(60, evk.Key(2)[0].Size);
}
{
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^256 + 1";
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods60Bit(0), DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods30Bit(1)
};
parms.PlainModulus = 1 << 6;
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
Assert.AreEqual(keygen.PublicKey.HashBlock, parms.HashBlock);
Assert.AreEqual(keygen.SecretKey.HashBlock, parms.HashBlock);
var evk = new EvaluationKeys();
keygen.GenerateEvaluationKeys(60, 2, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(2, evk.Key(2)[0].Size);
keygen.GenerateEvaluationKeys(30, 2, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(4, evk.Key(2)[0].Size);
keygen.GenerateEvaluationKeys(4, 1, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(30, evk.Key(2)[0].Size);
}
}
/// <summary>
/// Creates a new instance of a ParcelEvaluation class, initializes it with the specified arguments.
/// </summary>
/// <param name="parcel"></param>
/// <param name="date"></param>
/// <param name="key"></param>
/// <param name="value"></param>
public ParcelEvaluation(Parcel parcel, DateTime date, EvaluationKeys key, decimal value)
{
this.ParcelId = parcel?.Id ??
throw new ArgumentNullException(nameof(parcel));
this.Parcel = parcel;
this.Date = date;
this.Key = key;
this.Value = value;
}
/// <summary>
/// Creates a new instance of a BuildingEvaluation class, initializes it with the specified arguments.
/// </summary>
/// <param name="building"></param>
/// <param name="date"></param>
/// <param name="key"></param>
/// <param name="value"></param>
public BuildingEvaluation(Building building, DateTime date, EvaluationKeys key, decimal value)
{
this.BuildingId = building?.Id ??
throw new ArgumentNullException(nameof(building));
this.Building = building;
this.Date = date;
this.Key = key;
this.Value = value;
}
public void EvaluationKeysTestNET()
{
var keys = new EvaluationKeys();
Assert.AreEqual(0, keys.Count);
keys.Clear();
Assert.AreEqual(0, keys.Count);
keys.Resize(2);
Assert.AreEqual(2, keys.Count);
keys[0].Resize(2, 32);
keys[0][0].Set(1);
keys[0][1].Set(2);
keys[1].Resize(3, 32);
keys[1][0].Set(3);
keys[1][1].Set(4);
keys[1][2].Set(5);
Assert.AreEqual("2x^1 + 1", keys[0].ToString());
Assert.AreEqual("5x^2 + 4x^1 + 3", keys[1].ToString());
var keys2 = new EvaluationKeys();
Assert.AreEqual(0, keys2.Count);
keys2.Set(keys);
Assert.AreEqual(2, keys2.Count);
Assert.AreEqual("2x^1 + 1", keys2[0].ToString());
Assert.AreEqual("5x^2 + 4x^1 + 3", keys2[1].ToString());
keys2[1].SetZero();
Assert.AreEqual("5x^2 + 4x^1 + 3", keys[1].ToString());
keys.Resize(3);
Assert.AreEqual(3, keys.Count);
Assert.AreEqual("2x^1 + 1", keys[0].ToString());
Assert.AreEqual("5x^2 + 4x^1 + 3", keys[1].ToString());
Assert.IsTrue(keys[2].IsZero);
keys.Resize(1);
Assert.AreEqual(1, keys.Count);
Assert.AreEqual("2x^1 + 1", keys[0].ToString());
keys.Clear();
Assert.AreEqual(0, keys.Count);
}
public void EvaluationKeysNETSaveLoad()
{
var stream = new MemoryStream();
var arr1 = new BigPolyArray(3, 5, 10);
arr1[0][0].Set(1);
arr1[0][1].Set(2);
arr1[0][2].Set(3);
arr1[1][0].Set(4);
arr1[1][1].Set(5);
arr1[2][0].Set(6);
var arr2 = new BigPolyArray(3, 5, 10);
arr2[0][0].Set(7);
arr2[0][1].Set(8);
arr2[0][2].Set(9);
arr2[1][0].Set(10);
arr2[1][1].Set(11);
arr2[2][0].Set(12);
var pair1 = new Tuple <BigPolyArray, BigPolyArray>(arr1, arr2);
var list1 = new List <System.Tuple <Microsoft.Research.SEAL.BigPolyArray, Microsoft.Research.SEAL.BigPolyArray> >();
list1.Add(pair1);
var keys1 = new EvaluationKeys(list1);
stream.Seek(0, SeekOrigin.Begin);
keys1.Save(stream);
var keys2 = new EvaluationKeys();
stream.Seek(0, SeekOrigin.Begin);
keys2.Load(stream);
Assert.AreEqual(keys1[0].Item1[0].ToString(), keys2[0].Item1[0].ToString());
}
public EncCal(string polyMod, int coeffDefault, ulong plainMod, int dbc, int noOfEvaluationKeys)
{
// Create encryption parameters.
parms = new EncryptionParameters();
parms.PolyModulus.Set(polyMod);
parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[coeffDefault]);
parms.PlainModulus.Set(plainMod);
// Generate keys.
generator = new KeyGenerator(parms);
generator.Generate(noOfEvaluationKeys); //Integer
// Generator contains the keys
publicKey = generator.PublicKey;
secretKey = generator.SecretKey;
evaluationKeys = generator.EvaluationKeys;
// Create encoder (for encoding and decoding)
encoder = new IntegerEncoder(parms.PlainModulus); //Integer
//Create Encryptor
encryptor = new Encryptor(parms, publicKey);
//Create Decryptor
decryptor = new Decryptor(parms, secretKey);
//Create Evaluator for arithmatic operations
evaluator = new Evaluator(parms);
CrtBuilder = new PolyCRTBuilder(parms);
}
/// <summary>
/// Get the current evaluation date for the specified 'key'.
/// </summary>
/// <param name="building"></param>
/// <param name="key"></param>
/// <returns></returns>
public static DateTime?GetCurrentEvaluationDate(this Building building, EvaluationKeys key)
{
return(building.Evaluations.FirstOrDefault(e => e.Date.Year == DateTime.Now.Year && e.Key == key)?.Date);
}
/// <summary>
/// Get the most recent evaluation date for the specified 'key'.
/// </summary>
/// <param name="building"></param>
/// <param name="key"></param>
/// <returns></returns>
public static DateTime?GetMostRecentEvaluationDate(this Building building, EvaluationKeys key)
{
return(building.Evaluations.OrderByDescending(f => f.Date).FirstOrDefault(f => f.Key == key)?.Date);
}
/// <summary>
/// Get the current evaluation date for the specified 'key'.
/// </summary>
/// <param name="building"></param>
/// <param name="key"></param>
/// <returns></returns>
public static DateTime?GetCurrentEvaluationDate(this Parcel parcel, EvaluationKeys key)
{
return(parcel.Evaluations.FirstOrDefault(e => e.Date.Year == DateTime.Now.Year && e.Key == key)?.Date);
}
/// <summary>
/// Get the most recent evaluation for the specified 'key'.
/// </summary>
/// <param name="parcel"></param>
/// <param name="key"></param>
/// <returns></returns>
public static decimal?GetMostRecentEvaluation(this Parcel parcel, EvaluationKeys key)
{
return(parcel.Evaluations.OrderByDescending(f => f.Date).FirstOrDefault(f => f.Key == key)?.Value);
}
public void BFVKeyGenerationNET()
{
var parms = new EncryptionParameters();
{
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^64 + 1";
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods60Bit(0)
};
parms.PlainModulus = 1 << 6;
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
Assert.IsTrue(keygen.PublicKey.HashBlock.Equals(parms.HashBlock));
Assert.IsTrue(keygen.SecretKey.HashBlock.Equals(parms.HashBlock));
var evk = new EvaluationKeys();
keygen.GenerateEvaluationKeys(60, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(2, evk.Key(2)[0].Size);
keygen.GenerateEvaluationKeys(30, 1, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(4, evk.Key(2)[0].Size);
keygen.GenerateEvaluationKeys(2, 2, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(60, evk.Key(2)[0].Size);
var galks = new GaloisKeys();
keygen.GenerateGaloisKeys(60, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.AreEqual(2, galks.Key(3)[0].Size);
Assert.AreEqual(10, galks.Size);
keygen.GenerateGaloisKeys(30, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.AreEqual(4, galks.Key(3)[0].Size);
Assert.AreEqual(10, galks.Size);
keygen.GenerateGaloisKeys(2, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.AreEqual(60, galks.Key(3)[0].Size);
Assert.AreEqual(10, galks.Size);
keygen.GenerateGaloisKeys(60, new List <UInt64> {
1, 3, 5, 7
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsTrue(galks.HasKey(1));
Assert.IsTrue(galks.HasKey(3));
Assert.IsTrue(galks.HasKey(5));
Assert.IsTrue(galks.HasKey(7));
Assert.IsFalse(galks.HasKey(9));
Assert.IsFalse(galks.HasKey(127));
Assert.AreEqual(2, galks.Key(1)[0].Size);
Assert.AreEqual(2, galks.Key(3)[0].Size);
Assert.AreEqual(2, galks.Key(5)[0].Size);
Assert.AreEqual(2, galks.Key(7)[0].Size);
Assert.AreEqual(4, galks.Size);
keygen.GenerateGaloisKeys(30, new List <UInt64> {
1, 3, 5, 7
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsTrue(galks.HasKey(1));
Assert.IsTrue(galks.HasKey(3));
Assert.IsTrue(galks.HasKey(5));
Assert.IsTrue(galks.HasKey(7));
Assert.IsFalse(galks.HasKey(9));
Assert.IsFalse(galks.HasKey(127));
Assert.AreEqual(4, galks.Key(1)[0].Size);
Assert.AreEqual(4, galks.Key(3)[0].Size);
Assert.AreEqual(4, galks.Key(5)[0].Size);
Assert.AreEqual(4, galks.Key(7)[0].Size);
Assert.AreEqual(4, galks.Size);
keygen.GenerateGaloisKeys(2, new List <UInt64> {
1, 3, 5, 7
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsTrue(galks.HasKey(1));
Assert.IsTrue(galks.HasKey(3));
Assert.IsTrue(galks.HasKey(5));
Assert.IsTrue(galks.HasKey(7));
Assert.IsFalse(galks.HasKey(9));
Assert.IsFalse(galks.HasKey(127));
Assert.AreEqual(60, galks.Key(1)[0].Size);
Assert.AreEqual(60, galks.Key(3)[0].Size);
Assert.AreEqual(60, galks.Key(5)[0].Size);
Assert.AreEqual(60, galks.Key(7)[0].Size);
Assert.AreEqual(4, galks.Size);
keygen.GenerateGaloisKeys(30, new List <UInt64> {
1
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsTrue(galks.HasKey(1));
Assert.IsFalse(galks.HasKey(3));
Assert.IsFalse(galks.HasKey(127));
Assert.AreEqual(4, galks.Key(1)[0].Size);
Assert.AreEqual(1, galks.Size);
keygen.GenerateGaloisKeys(30, new List <UInt64> {
127
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsFalse(galks.HasKey(1));
Assert.IsTrue(galks.HasKey(127));
Assert.AreEqual(4, galks.Key(127)[0].Size);
Assert.AreEqual(1, galks.Size);
}
{
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^256 + 1";
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods60Bit(0), DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods30Bit(1)
};
parms.PlainModulus = 1 << 6;
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
Assert.AreEqual(keygen.PublicKey.HashBlock, parms.HashBlock);
Assert.AreEqual(keygen.SecretKey.HashBlock, parms.HashBlock);
var evk = new EvaluationKeys();
keygen.GenerateEvaluationKeys(60, 2, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(2, evk.Key(2)[0].Size);
keygen.GenerateEvaluationKeys(30, 2, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(4, evk.Key(2)[0].Size);
keygen.GenerateEvaluationKeys(4, 1, evk);
Assert.AreEqual(evk.HashBlock, parms.HashBlock);
Assert.AreEqual(30, evk.Key(2)[0].Size);
var galks = new GaloisKeys();
keygen.GenerateGaloisKeys(60, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.AreEqual(2, galks.Key(3)[0].Size);
Assert.AreEqual(14, galks.Size);
keygen.GenerateGaloisKeys(30, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.AreEqual(4, galks.Key(3)[0].Size);
Assert.AreEqual(14, galks.Size);
keygen.GenerateGaloisKeys(2, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.AreEqual(60, galks.Key(3)[0].Size);
Assert.AreEqual(14, galks.Size);
keygen.GenerateGaloisKeys(60, new List <UInt64> {
1, 3, 5, 7
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsTrue(galks.HasKey(1));
Assert.IsTrue(galks.HasKey(3));
Assert.IsTrue(galks.HasKey(5));
Assert.IsTrue(galks.HasKey(7));
Assert.IsFalse(galks.HasKey(9));
Assert.IsFalse(galks.HasKey(511));
Assert.AreEqual(2, galks.Key(1)[0].Size);
Assert.AreEqual(2, galks.Key(3)[0].Size);
Assert.AreEqual(2, galks.Key(5)[0].Size);
Assert.AreEqual(2, galks.Key(7)[0].Size);
Assert.AreEqual(4, galks.Size);
keygen.GenerateGaloisKeys(30, new List <UInt64> {
1, 3, 5, 7
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsTrue(galks.HasKey(1));
Assert.IsTrue(galks.HasKey(3));
Assert.IsTrue(galks.HasKey(5));
Assert.IsTrue(galks.HasKey(7));
Assert.IsFalse(galks.HasKey(9));
Assert.IsFalse(galks.HasKey(511));
Assert.AreEqual(4, galks.Key(1)[0].Size);
Assert.AreEqual(4, galks.Key(3)[0].Size);
Assert.AreEqual(4, galks.Key(5)[0].Size);
Assert.AreEqual(4, galks.Key(7)[0].Size);
Assert.AreEqual(4, galks.Size);
keygen.GenerateGaloisKeys(2, new List <UInt64> {
1, 3, 5, 7
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsTrue(galks.HasKey(1));
Assert.IsTrue(galks.HasKey(3));
Assert.IsTrue(galks.HasKey(5));
Assert.IsTrue(galks.HasKey(7));
Assert.IsFalse(galks.HasKey(9));
Assert.IsFalse(galks.HasKey(511));
Assert.AreEqual(60, galks.Key(1)[0].Size);
Assert.AreEqual(60, galks.Key(3)[0].Size);
Assert.AreEqual(60, galks.Key(5)[0].Size);
Assert.AreEqual(60, galks.Key(7)[0].Size);
Assert.AreEqual(4, galks.Size);
keygen.GenerateGaloisKeys(30, new List <UInt64> {
1
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsTrue(galks.HasKey(1));
Assert.IsFalse(galks.HasKey(3));
Assert.IsFalse(galks.HasKey(511));
Assert.AreEqual(4, galks.Key(1)[0].Size);
Assert.AreEqual(1, galks.Size);
keygen.GenerateGaloisKeys(30, new List <UInt64> {
511
}, galks);
Assert.AreEqual(galks.HashBlock, parms.HashBlock);
Assert.IsFalse(galks.HasKey(1));
Assert.IsTrue(galks.HasKey(511));
Assert.AreEqual(4, galks.Key(511)[0].Size);
Assert.AreEqual(1, galks.Size);
}
}
public void EvaluationKeysSaveLoadNET()
{
var stream = new MemoryStream();
{
var parms = new EncryptionParameters();
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^64 + 1";
parms.PlainModulus = 1 << 6;
parms.CoeffModulus = new List<SmallModulus> { DefaultParams.SmallMods60Bit(0) };
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var keys = new EvaluationKeys();
Assert.AreEqual(keys.DecompositionBitCount, 0);
var test_keys = new EvaluationKeys();
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
Assert.AreEqual(0, keys.Size);
keygen.GenerateEvaluationKeys(1, 1, keys);
Assert.AreEqual(keys.DecompositionBitCount, 1);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(2, 1, keys);
Assert.AreEqual(keys.DecompositionBitCount, 2);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(59, 2, keys);
Assert.AreEqual(keys.DecompositionBitCount, 59);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(60, 5, keys);
Assert.AreEqual(keys.DecompositionBitCount, 60);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
}
{
var parms = new EncryptionParameters();
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^256 + 1";
parms.PlainModulus = 1 << 6;
parms.CoeffModulus = new List<SmallModulus> {
DefaultParams.SmallMods60Bit(0), DefaultParams.SmallMods50Bit(0) };
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var keys = new EvaluationKeys();
Assert.AreEqual(keys.DecompositionBitCount, 0);
var test_keys = new EvaluationKeys();
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
Assert.AreEqual(0, keys.Size);
keygen.GenerateEvaluationKeys(8, 1, keys);
Assert.AreEqual(keys.DecompositionBitCount, 8);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(8, 2, keys);
Assert.AreEqual(keys.DecompositionBitCount, 8);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(59, 2, keys);
Assert.AreEqual(keys.DecompositionBitCount, 59);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(60, 5, keys);
Assert.AreEqual(keys.DecompositionBitCount, 60);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
}
}
