public static async Task RunBenchmark(int deltaN, int max)
        {
            int currentSize = deltaN;

            var encoder      = new ConvolutionalEncoder();
            var decoder      = new ConvolutionalDecoder();
            var noisyChannel = new NoisyChannel(0.01);

            while (currentSize <= max)
            {
                var bmp   = new Bitmap(currentSize, currentSize);
                var bytes = BitmapHelper.GetColorBytes(bmp);

                var watch = System.Diagnostics.Stopwatch.StartNew();
                var resultWithEncoding = await MessageController.SendBytes(
                    bytes,
                    noisyChannel,
                    encoder,
                    decoder);

                watch.Stop();

                Console.WriteLine($"{currentSize},{watch.Elapsed}");

                currentSize += deltaN;
            }
        }
        private void AssertBits(IEnumerable <Bit> bitsToEncode, IEnumerable <Bit> expectedValues)
        {
            var bitsArray = bitsToEncode.ToArray();
            var bitStream = new BitStream(bitsArray);
            var encoder   = new ConvolutionalEncoder();

            var result = encoder.Encode(bitStream);

            var expectedStream = new BitStream(expectedValues.ToArray());

            // Resulting stream should always be 2 * n + 12 length
            Assert.True(((BitStream)result).Length == 2 * bitsArray.Length + 12);
            Assert.True(expectedStream == (BitStream)result);
        }
Example #3
0
        public static async Task RunBenchmark(double errorDelta, double expectedErrorCorrectionRate)
        {
            var bmp   = new Bitmap(100, 100);
            var bytes = BitmapHelper.GetColorBytes(bmp);

            double averageErrorCorrectionPercentage = 100;
            double currentErrorChance = 0;
            var    encoder            = new ConvolutionalEncoder();
            var    decoder            = new ConvolutionalDecoder();

            do
            {
                var noisyChannel = new NoisyChannel(currentErrorChance);

                double sum = 0;
                for (int i = 0; i < 10; i++)
                {
                    var resultWithoutEncoding = await MessageController.SendBytes(
                        bytes, noisyChannel
                        );


                    var resultWithEncoding = await MessageController.SendBytes(
                        bytes,
                        new NoisyChannel(currentErrorChance),
                        encoder,
                        decoder);

                    var Percentage =
                        MathHelper.CalculatePercentageWithPrecision(
                            resultWithEncoding.Errors,
                            resultWithoutEncoding.Errors,
                            2);

                    sum += Percentage;
                }

                averageErrorCorrectionPercentage = sum / 10;

                Console.WriteLine($"{currentErrorChance},{averageErrorCorrectionPercentage:F2}");

                currentErrorChance += errorDelta;
            } while(averageErrorCorrectionPercentage >= expectedErrorCorrectionRate);
        }