private Double dilutionRate = 1; // ml/sec
public CultureSimulator(TurbidoAlgorithmLibrary _library)
{
library = _library;
lastTime = new DoubleRef();
lastOD = new DoubleArrayRef(numberOfCultures);
GrowthTimer = new System.Timers.Timer(dataPointPeriod * 1000);
GrowthTimer.Elapsed += this.GrowthTick;
var rng = new CryptoRandomSource();
// initialize cultures
for (int i = 0; i < 4; i++)
{
if (culture_set == 'A')
{
lastOD.values[i] = rng.NextDouble() * initialOD;
lastOD.values[8 + i] = rng.NextDouble() * initialOD;
lastOD.values[4 + i] = lastOD.values[12 + i] = 0;
}
else
{
lastOD.values[4 + i] = rng.NextDouble() * initialOD;
lastOD.values[12 + i] = rng.NextDouble() * initialOD;
lastOD.values[i] = lastOD.values[8 + i] = 0;
}
}
}
private double GenerateRandom()
{
CryptoRandomSource random = new CryptoRandomSource();
double value = random.NextDouble();
bool negate = random.NextBoolean();
return(negate ? -value : value);
}
public void CryptoRandomSource_32ByteResults()
{
var source = new CryptoRandomSource(32);
var result = source.GetEntropyAsync(EntropyPriority.Normal).GetAwaiter().GetResult();
Assert.AreEqual(result.Length, 32);
Assert.IsFalse(result.All(b => b == 0));
}
private void CreateNew()
{
Size s = GetRenderSize();
if (Double.TryParse(MeanTb.Text, out double m1) && Double.TryParse(StdDevTb.Text, out double m2) && SwitchTryParse(DefaultToTb.Text, out Switch m3))
{
CryptoRandomSource r = new CryptoRandomSource();
Normal n = new Normal(m1, m2);
double[] samp = new double[s.Width * s.Height];
n.Samples(samp);
samp = samp.OrderBy(x => r.Next()).ToArray();
Cur = Voxel.GenerateVoxels(s.Width, s.Height, samp, externalWeights, wt, GetChoiceType(), m3);
}
else
{
MessageBox.Show("Render failed: inappropriate text for weights.");
}
}
static public int TestMethod(int totalLength, int sampleLength)
{
//初始化部分，zeroOneMeasure是个MeasureMatrixH类型，里面有两个元素{1 0;0 0}, {0 0;0 1}
//plusminusMeasure是个MeasureMatrixH类型，里面有两个元素{1/2 1/2;1/2 1/2}, {1/2 -1/2;-1/2 1/2}
var matrixArray0 = new Matrix[2];
Complex[,] array0 =
{
{ 1, 0 },
{ 0, 0 }
};
matrixArray0[0] = (Matrix)Matrix.Build.DenseOfArray(array0);
Complex[,] array1 =
{
{ 0, 0 },
{ 0, 1 }
};
matrixArray0[1] = (Matrix)Matrix.Build.DenseOfArray(array1);
var zeroOneMeasure = new MeasureMatrixH(matrixArray0);
var matrixArray1 = new Matrix[2];
Complex[,] array2 =
{
{ 0.5, 0.5 },
{ 0.5, 0.5 }
};
matrixArray1[0] = (Matrix)Matrix.Build.DenseOfArray(array2);
Complex[,] array3 =
{
{ 0.5, -0.5 },
{ -0.5, 0.5 }
};
matrixArray1[1] = (Matrix)Matrix.Build.DenseOfArray(array3);
var plusminusMeasure = new MeasureMatrixH(matrixArray1);
//-------------Alice----------------------
//Debug Console.Write("Input Array Length:");
//Debug var arrayLengthStr = Console.ReadLine();
int arrayLength = totalLength;
//-------------------------check length----------------
int checkLengthPercent = sampleLength;
var RandomGen = new CryptoRandomSource();
//生成一个rawKeyArray[10],是bool数组类型,每一个item,从0,1这两个中选择
//Produce raw key array 0,1
var rawKeyArray = new byte[arrayLength];
//生成一个basisRawArray[10]，是bool数组类型,每一个item,从0,1这两个中选择
//0表示0,1基，1表示{+,-}基
var basisRawArray = new byte[arrayLength];
//生成一个ketEncArray[10]是ket数组类型.每一位由rawKeyArray和basisRawArray共同决定。
//if basisRawArray里面的值是0，rawKeyArray里面的值是0，则 ketEncArray里面的值是ket(0)
//if basisRawArray里面的值是0，rawKeyArray里面的值是1，则 ketEncArray里面的值是ket(1)
// if basisRawArray里面的值是1，rawKeyArray里面的值是0，则 ketEncArray里面的值是ket(1/Sqrt(2),1/Sqrt(2))
// if basisRawArray里面的值是1，rawKeyArray里面的值是1，则 ketEncArray里面的值是ket(1/Sqrt(2),-1/Sqrt(2))
var ketEncArray = new Ket[arrayLength];
var complexArray = new Complex[2];
for (var i = 0; i < arrayLength; i++)
{
rawKeyArray[i] = (byte)RandomGen.Next(2);
basisRawArray[i] = (byte)RandomGen.Next(2);
if (basisRawArray[i] == 0 && rawKeyArray[i] == 0)
{
complexArray[0] = new Complex(1, 0);
complexArray[1] = new Complex(0, 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 0 && rawKeyArray[i] == 1)
{
complexArray[0] = new Complex(0, 0);
complexArray[1] = new Complex(1, 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 1 && rawKeyArray[i] == 0)
{
complexArray[0] = new Complex(1 / Sqrt(2), 0);
complexArray[1] = new Complex(1 / Sqrt(2), 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 1 && rawKeyArray[i] == 1)
{
complexArray[0] = new Complex(1 / Sqrt(2), 0);
complexArray[1] = new Complex(-1 / Sqrt(2), 0);
ketEncArray[i] = new Ket(complexArray);
}
}
// -----------alice end---------------------
////--------------Quantum Channel begins, ignoring EVE ----------
var densityopEncArray = new DensityOperator[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
densityopEncArray[i] = new DensityOperator(ketEncArray[i], new Bra(ketEncArray[i]));
}
QuantumChannelProcess(densityopEncArray);
//---------------Quantum Channel End-------Eve end---------------------
//---------------------Bob begin--------------------
//Bob 生成一个measureRawArray，是bool数组类型随机{0,1}------------
var measureRawArray = new byte[arrayLength];
//生成结果数组 resultMeasureArray,是bool数组类型，其中的值由 measureRawArray和 densityopEncArray共同决定
// foreach item in densityopEncArray
//if measureRawArray[index]=0则用 zeroOneMeasure 作为调用的参数传递到 densityopEncArray的本位,ket[index].MeasuHResultIndex(zeroOneMeasure )
//if measureRawArray[index]=1则用 plusminusMeasure 作为调用的参数传递到 densityopEncArray的本位,ket[index].MeasuHResultIndex(plusminusMeasure )
var resultMeasureArray = new byte[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
measureRawArray[i] = (byte)RandomGen.Next(2);
if (measureRawArray[i] == 0)
{
if (densityopEncArray[i].MeasuHResultIndex(zeroOneMeasure) != 0)
{
resultMeasureArray[i] = 1;
}
}
else
{
if (densityopEncArray[i].MeasuHResultIndex(plusminusMeasure) != 0)
{
resultMeasureArray[i] = 1;
}
}
}
// ---------------------Bob end--------------------
//--------------公共信道广播不做--------
//--------------公共信道结束----------
// --------------ALice begin---------------
//生成应答数组,correctBroadArray,bool数组类型。
//foreach item in measureRawArray
//if measureRawArray[index]== basisRawArray[index], correctBroadArray[index]==1. else correctBroadArray[index]==0
var correctBroadArray = new byte[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
if (measureRawArray[i] == basisRawArray[i])
{
correctBroadArray[i] = 1;
}
}
// 生成finalAliceKey数组是bool数组类型，
// foreach item in correctBroadArray
// if correctBroadArray[index]==1 , push(rawKeyArray[index]),即把 correctBroadArray[index]==1的那些位置的 rawKeyArray[index]取出来放一起finalAliceKey。
var finalAliceKeyList = new List <byte>();
for (var i = 0; i < arrayLength; i++)
{
if (correctBroadArray[i] != 0)
{
finalAliceKeyList.Add(rawKeyArray[i]);
}
}
var finalAliceKey = finalAliceKeyList.ToArray();
//------------Alice end--------------------
//------------公共信道开始-----------------------
//-----------公共信道结束------------------------
//--------------Bob开始-------------------------
//生成finalBobKey数组是bool数组类型
// foreach item in correctBroadArray
// if correctBroadArray[index]==1 , push(resultMeasureArray[index]),即把 correctBroadArray[index]==1的那些位置的 resultMeasureArray[index]取出来放一起存到finalBobKey。
var finalBobKeyList = new List <byte>();
for (var i = 0; i < arrayLength; i++)
{
if (correctBroadArray[i] != 0)
{
finalBobKeyList.Add(resultMeasureArray[i]);
}
}
var finalBobKey = finalBobKeyList.ToArray();
//----------------Bob结束----------------------
//Check start
//Check the alice and bob's length is equal
var check = true;
if (finalAliceKey.Length != finalBobKey.Length)
{
check = false;
}
if (check)
{
// Console.WriteLine("Length: Success");
}
else
{
//Console.WriteLine("Length: Failed");
}
//Sampling start
var samplingLength = (checkLengthPercent * finalAliceKey.Length) / 100;
//Console.WriteLine($"Sampling {samplingLength} bits");
var samplingAliceKey = new List <byte>(finalAliceKey);
var samplingBobKey = new List <byte>(finalBobKey);
var samplingAliceKeySample = new List <byte>();
var samplingBobKeySample = new List <byte>();
for (var i = 0; i < samplingLength; i++)
{
var position = RandomGen.Next(samplingAliceKey.Count); //shuffle here, sample from agreement key and then delete it
samplingAliceKeySample.Add(samplingAliceKey[position]);
samplingAliceKey.RemoveAt(position);
samplingBobKeySample.Add(samplingBobKey[position]);
samplingBobKey.RemoveAt(position);
}
for (var i = 0; i < samplingLength; i++)
{
if (samplingAliceKeySample[i] != samplingBobKeySample[i])
{
check = false;
}
}
if (check)
{
//Console.WriteLine("Sampling process: Success");
return(1); //Add success times here
}
else
{
//Console.WriteLine("Sampling process: Failed");
return(0);
}
}
/// <summary>
/// Executes the example.
/// </summary>
/// <seealso cref="http://en.wikipedia.org/wiki/Random_number_generation">Random number generation</seealso>
/// <seealso cref="http://en.wikipedia.org/wiki/Linear_congruential_generator">Linear congruential generator</seealso>
/// <seealso cref="http://en.wikipedia.org/wiki/Mersenne_twister">Mersenne twister</seealso>
/// <seealso cref="http://en.wikipedia.org/wiki/Lagged_Fibonacci_generator">Lagged Fibonacci generator</seealso>
/// <seealso cref="http://en.wikipedia.org/wiki/Xorshift">Xorshift</seealso>
public override void ExecuteExample()
{
// All RNG classes in MathNet have the following counstructors:
// - RNG(int seed, bool threadSafe): initializes a new instance using a specific seed value and thread
// safe property
// - RNG(int seed): initializes a new instance using a specific seed value. Thread safe property is set
// to Control.ThreadSafeRandomNumberGenerators
// - RNG(bool threadSafe) : initializes a new instance with the seed value set to DateTime.Now.Ticks and
// specific thread safe property
// - RNG(bool threadSafe) : initializes a new instance with the seed value set to DateTime.Now.Ticks and
// thread safe property set to Control.ThreadSafeRandomNumberGenerators
// All RNG classes in MathNet have next methods to produce random values:
// - double[] NextDouble(int n): returns an "n"-size array of uniformly distributed random doubles in
// the interval [0.0,1.0];
// - int Next(): returns a nonnegative random number;
// - int Next(int maxValue): returns a random number less then a specified maximum;
// - int Next(int minValue, int maxValue): returns a random number within a specified range;
// - void NextBytes(byte[] buffer): fills the elements of a specified array of bytes with random numbers;
// All RNG classes in MathNet have next extension methods to produce random values:
// - long NextInt64(): returns a nonnegative random number less than "Int64.MaxValue";
// - int NextFullRangeInt32(): returns a random number of the full Int32 range;
// - long NextFullRangeInt64(): returns a random number of the full Int64 range;
// - decimal NextDecimal(): returns a nonnegative decimal floating point random number less than 1.0;
// 1. Multiplicative congruential generator using a modulus of 2^31-1 and a multiplier of 1132489760
var mcg31M1 = new Mcg31m1(1);
MathDisplay.WriteLine(@"1. Generate 10 random double values using Multiplicative congruential generator with a
modulus of 2^31-1 and a multiplier of 1132489760");
var randomValues = mcg31M1.NextDoubles(10);
for (var i = 0; i < randomValues.Length; i++)
{
MathDisplay.Write(randomValues[i].ToString("N") + @" ");
}
MathDisplay.FlushBuffer();
MathDisplay.WriteLine();
MathDisplay.WriteLine();
// 2. Multiplicative congruential generator using a modulus of 2^59 and a multiplier of 13^13
var mcg59 = new Mcg59(1);
MathDisplay.WriteLine(@"2. Generate 10 random integer values using Multiplicative congruential generator with a
modulus of 2^59 and a multiplier of 13^13");
for (var i = 0; i < 10; i++)
{
MathDisplay.Write(mcg59.Next() + @" ");
}
MathDisplay.FlushBuffer();
MathDisplay.WriteLine();
MathDisplay.WriteLine();
// 3. Random number generator using Mersenne Twister 19937 algorithm
var mersenneTwister = new MersenneTwister(1);
MathDisplay.WriteLine(@"3. Generate 10 random integer values less then 100 using Mersenne Twister 19937 algorithm");
for (var i = 0; i < 10; i++)
{
MathDisplay.Write(mersenneTwister.Next(100) + @" ");
}
MathDisplay.FlushBuffer();
MathDisplay.WriteLine();
MathDisplay.WriteLine();
// 4. Multiple recursive generator with 2 components of order 3
var mrg32K3A = new Mrg32k3a(1);
MathDisplay.WriteLine(@"4. Generate 10 random integer values in range [50;100] using multiple recursive generator
with 2 components of order 3");
for (var i = 0; i < 10; i++)
{
MathDisplay.Write(mrg32K3A.Next(50, 100) + @" ");
}
MathDisplay.FlushBuffer();
MathDisplay.WriteLine();
MathDisplay.WriteLine();
// 5. Parallel Additive Lagged Fibonacci pseudo-random number generator
var palf = new Palf(1);
MathDisplay.WriteLine(@"5. Generate 10 random bytes using Parallel Additive Lagged Fibonacci pseudo-random number
generator");
var bytes = new byte[10];
palf.NextBytes(bytes);
for (var i = 0; i < bytes.Length; i++)
{
MathDisplay.Write(bytes[i] + @" ");
}
MathDisplay.FlushBuffer();
MathDisplay.WriteLine();
MathDisplay.WriteLine();
// 6. A random number generator based on "System.Security.Cryptography.RandomNumberGenerator" class in
// the .NET library
var systemCrypto = new CryptoRandomSource();
MathDisplay.WriteLine(@"6. Generate 10 random decimal values using RNG based on
'System.Security.Cryptography.RandomNumberGenerator'");
for (var i = 0; i < 10; i++)
{
MathDisplay.Write(systemCrypto.NextDecimal().ToString("N") + @" ");
}
MathDisplay.WriteLine();
MathDisplay.WriteLine();
// 7. Wichmann-Hill’s 1982 combined multiplicative congruential generator
var rngWh1982 = new WH1982();
MathDisplay.WriteLine(@"7. Generate 10 random full Int32 range values using Wichmann-Hill’s 1982 combined
multiplicative congruential generator");
for (var i = 0; i < 10; i++)
{
MathDisplay.Write(rngWh1982.NextFullRangeInt32() + @" ");
}
MathDisplay.FlushBuffer();
MathDisplay.WriteLine();
MathDisplay.WriteLine();
// 8. Wichmann-Hill’s 2006 combined multiplicative congruential generator.
var rngWh2006 = new WH2006();
MathDisplay.WriteLine(@"8. Generate 10 random full Int64 range values using Wichmann-Hill’s 2006 combined
multiplicative congruential generator");
for (var i = 0; i < 10; i++)
{
MathDisplay.Write(rngWh2006.NextFullRangeInt32() + @" ");
}
MathDisplay.FlushBuffer();
MathDisplay.WriteLine();
MathDisplay.WriteLine();
// 9. Multiply-with-carry Xorshift pseudo random number generator
var xorshift = new Xorshift();
MathDisplay.WriteLine(@"9. Generate 10 random nonnegative values less than Int64.MaxValue using
Multiply-with-carry Xorshift pseudo random number generator");
for (var i = 0; i < 10; i++)
{
MathDisplay.Write(xorshift.NextInt64() + @" ");
}
MathDisplay.FlushBuffer();
MathDisplay.WriteLine();
}
static public void TestMethod()
{
//Initilization，zeroOneMeasureis a MeasureMatrixH class. {1 0;0 0}, {0 0;0 1}
//plusminusMeasure is MeasureMatrixH class，{1/2 1/2;1/2 1/2}, {1/2 -1/2;-1/2 1/2}
var matrixArray0 = new Matrix[2];
Complex[,] array0 =
{
{ 1, 0 },
{ 0, 0 }
};
matrixArray0[0] = (Matrix)Matrix.Build.DenseOfArray(array0);
Complex[,] array1 =
{
{ 0, 0 },
{ 0, 1 }
};
matrixArray0[1] = (Matrix)Matrix.Build.DenseOfArray(array1);
var zeroOneMeasure = new MeasureMatrixH(matrixArray0);
var matrixArray1 = new Matrix[2];
Complex[,] array2 =
{
{ 0.5, 0.5 },
{ 0.5, 0.5 }
};
matrixArray1[0] = (Matrix)Matrix.Build.DenseOfArray(array2);
Complex[,] array3 =
{
{ 0.5, -0.5 },
{ -0.5, 0.5 }
};
matrixArray1[1] = (Matrix)Matrix.Build.DenseOfArray(array3);
var plusminusMeasure = new MeasureMatrixH(matrixArray1);
//-------------Alice----------------------
Console.Write("Input Array Length:");
var arrayLengthStr = Console.ReadLine();
int arrayLength;
if (!int.TryParse(arrayLengthStr, out arrayLength))
{
Console.WriteLine("Must input integer, use default(10)");
arrayLength = 10;
}
var RandomGen = new CryptoRandomSource();
//Produce raw key array 0,1
var rawKeyArray = new byte[arrayLength];
//0 is {|0>,|1>}，1 is {|+>,|->} basis.
var basisRawArray = new byte[arrayLength];
//Every KetEncArray is decided by rawKeyArray and basisRawArray
//if basisRawArray is 0，rawKeyArray is 0，then ketEncArray is ket(0)
//if basisRawArray is 0，rawKeyArray is 1，then ketEncArray is ket(1)
// if basisRawArray is 1，rawKeyArray is 0，then ketEncArray is ket(1/Sqrt(2),1/Sqrt(2))
// if basisRawArray is 1，rawKeyArray is 1，then ketEncArray ket(1/Sqrt(2),-1/Sqrt(2))
var ketEncArray = new Ket[arrayLength];
var complexArray = new Complex[2];
for (var i = 0; i < arrayLength; i++)
{
rawKeyArray[i] = (byte)RandomGen.Next(2);
basisRawArray[i] = (byte)RandomGen.Next(2);
if (basisRawArray[i] == 0 && rawKeyArray[i] == 0)
{
complexArray[0] = new Complex(1, 0);
complexArray[1] = new Complex(0, 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 0 && rawKeyArray[i] == 1)
{
complexArray[0] = new Complex(0, 0);
complexArray[1] = new Complex(1, 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 1 && rawKeyArray[i] == 0)
{
complexArray[0] = new Complex(1 / Sqrt(2), 0);
complexArray[1] = new Complex(1 / Sqrt(2), 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 1 && rawKeyArray[i] == 1)
{
complexArray[0] = new Complex(1 / Sqrt(2), 0);
complexArray[1] = new Complex(-1 / Sqrt(2), 0);
ketEncArray[i] = new Ket(complexArray);
}
}
// -----------alice end---------------------
////--------------Quantum Channel begins, ignoring EVE ----------
var densityopEncArray = new DensityOperator[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
densityopEncArray[i] = new DensityOperator(ketEncArray[i], new Bra(ketEncArray[i]));
}
QuantumChannelProcess(densityopEncArray);
//---------------Quantum Channel End-------Eve end---------------------
//---------------------Bob begin--------------------
//Bob produces measureRawArray，randomly {0,1}------------
var measureRawArray = new byte[arrayLength];
// resultMeasureArray is bool array. The value is decided by measureRawArray and ketEncArray.
// foreach item in ketEncArray
//if measureRawArray[index]=0 then zeroOneMeasure would be transferred to ketEncArray ,ket[index].MeasuHResultIndex(zeroOneMeasure )
//if measureRawArray[index]=1 then plusminusMeasure would be transferred to ketEncArray,ket[index].MeasuHResultIndex(plusminusMeasure )
var resultMeasureArray = new byte[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
measureRawArray[i] = (byte)RandomGen.Next(2);
if (measureRawArray[i] == 0)
{
if (densityopEncArray[i].MeasuHResultIndex(zeroOneMeasure) != 0)
{
resultMeasureArray[i] = 1;
}
}
else
{
if (densityopEncArray[i].MeasuHResultIndex(plusminusMeasure) != 0)
{
resultMeasureArray[i] = 1;
}
}
}
// ---------------------Bob end--------------------
// --------------ALice begin---------------
//Produce answer array,correctBroadArray,bool array class.
//foreach item in measureRawArray
//if measureRawArray[index]== basisRawArray[index], correctBroadArray[index]==1. else correctBroadArray[index]==0
var correctBroadArray = new byte[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
if (measureRawArray[i] == basisRawArray[i])
{
correctBroadArray[i] = 1;
}
}
// foreach item in correctBroadArray
// if correctBroadArray[index]==1 , push(rawKeyArray[index]),i.e. correctBroadArray[index]==1 position rawKeyArray[index]is taken out and storage into finalAliceKey.
var finalAliceKeyList = new List <byte>();
for (var i = 0; i < arrayLength; i++)
{
if (correctBroadArray[i] != 0)
{
finalAliceKeyList.Add(rawKeyArray[i]);
}
}
var finalAliceKey = finalAliceKeyList.ToArray();
//------------Alice end--------------------
//--------------Bob begins-------------------------
//Produce finalBobKey array is bool array
// foreach item in correctBroadArray
// if correctBroadArray[index]==1 , push(resultMeasureArray[index]),i.e. correctBroadArray[index]==1 position, resultMeasureArray[index] is taken out and storage into finalBobKey.
var finalBobKeyList = new List <byte>();
for (var i = 0; i < arrayLength; i++)
{
if (correctBroadArray[i] != 0)
{
finalBobKeyList.Add(resultMeasureArray[i]);
}
}
var finalBobKey = finalBobKeyList.ToArray();
//----------------Bob END----------------------
//Check Begin
//check finalAliceKey is equal to finalBobKey
bool check = true;
if (finalAliceKey.Length != finalBobKey.Length)
{
check = false;
}
for (var i = 0; i < finalAliceKey.Length; i++)
{
if (finalAliceKey[i] != finalBobKey[i])
{
check = false;
}
}
//if (check)
//{
// Console.WriteLine("Success");
//}
//else
//{
// Console.WriteLine("Failed");
//}
////check end
Console.WriteLine($"zeroOneMeasure:\n{zeroOneMeasure.Value[0].ToComplexString()}\n{zeroOneMeasure.Value[1].ToComplexString()}");
Console.WriteLine($"plusMinusMeasure:\n{plusminusMeasure.Value[0].ToComplexString()}\n{plusminusMeasure.Value[1].ToComplexString()}");
Console.Write("rawKeyArray\t");
foreach (var b in rawKeyArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("basisRawArray\t");
foreach (var b in basisRawArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.WriteLine();
Console.Write("measureRawArray\t\t");
foreach (var b in measureRawArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("resultMeasureArray\t");
foreach (var b in resultMeasureArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("correctBroadArray\t");
foreach (var b in correctBroadArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("finalAliceKey\t\t");
foreach (var b in finalAliceKey)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("finalBobKey\t\t");
foreach (var b in finalBobKey)
{
Console.Write(b);
}
if (check)
{
Console.WriteLine("\nThe protocol: Success");
}
else
{
Console.WriteLine("\nThe protocol: Failed");
}
//check end
Console.WriteLine();
}
public static Voxel[,] GenerateVoxels(int xs, int ys, Double[] weights, Double[,] extrWeights, WeightType[,] extrWeightsType, int ChoiceType, Switch Default = Switch.Indeterminate)
{
int x = 0;
int y = 0;
Voxel[,] section = new Voxel[xs, ys];
CryptoRandomSource r = new CryptoRandomSource();
int x2 = 0;
int y2 = 0;
int ind = 0;
while (y2 < ys)
{
while (x2 < xs)
{
section[x2, y2] = new Voxel(weights[ind], Switch.Indeterminate, x2, y2);
++x2;
++ind;
}
++y2;
x2 = 0;
}
Voxel TopLeft = new Voxel(0.0, 0.0, 0, 0);
Voxel TopCenter = new Voxel(0.0, 0.0, 0, 0);
Voxel TopRight = new Voxel(0.0, 0.0, 0, 0);
Voxel CenterLeft = new Voxel(0.0, 0.0, 0, 0);
Voxel CenterRight = new Voxel(0.0, 0.0, 0, 0);
Voxel BottomLeft = new Voxel(0.0, 0.0, 0, 0);
Voxel BottomCenter = new Voxel(0.0, 0.0, 0, 0);
Voxel BottomRight = new Voxel(0.0, 0.0, 0, 0);
double d = 0;
while (y < ys)
{
while (x < xs)
{
if (x > 0)
{
CenterLeft = section[x - 1, y];
if (y > 0)
{
TopLeft = section[x - 1, y - 1];
}
if (y < ys - 1)
{
BottomLeft = section[x - 1, y + 1];
}
}
if (x < xs - 1)
{
CenterRight = section[x + 1, y];
if (y > 0)
{
TopRight = section[x + 1, y - 1];
}
if (y < ys - 1)
{
BottomRight = section[x + 1, y + 1];
}
}
if (y > 0)
{
TopCenter = section[x, y - 1];
}
if (y < ys - 1)
{
BottomCenter = section[x, y + 1];
}
d = CalculateValue(extrWeightsType, extrWeights, TopLeft, TopCenter, TopRight, CenterLeft, CenterRight, BottomLeft, BottomCenter, BottomRight);
if (d == 0)
{
if (ChoiceType == 0)
{
if (r.Next(-1, 0) == 0)
{
d = 1;
}
else
{
d = -1;
}
}
else
{
d = (int)Default;
}
}
if (d < 0)
{
section[x, y].Value = Switch.Off;
}
else
{
section[x, y].Value = Switch.On;
}
++x;
}
++y;
x = 0;
}
return(section);
}
