sonic-the-hedgehog-lnk1123 / reedsolomon Goto Github PK

using System;
using System.Collections.Generic;

namespace ReedSolomonTest
{
    class MainClass
    {
        /// <summary>
        /// Creating Galois field
        /// </summary>
        /// <returns>The GenericGF object</returns>
        static STH1123.ReedSolomon.GenericGF GenGF(int NumOfBits)
        {
            int PrimPoly = 0;
            switch (NumOfBits)
            {
                case 4: PrimPoly = 16 + 2 + 1; break;
                case 8: PrimPoly = 256 + 16 + 8 + 4 + 1; break;
                case 12: PrimPoly = 4096 + 64 + 16 + 2 + 1; break;
                case 16: PrimPoly = 65536 + 32 + 8 + 4 + 1; break;
                case 20: PrimPoly = 1048576 + 8 + 1; break;
                case 24: PrimPoly = 16777216 + 16 + 8 + 2 + 1; break;
                default: throw new Exception("Unsupported number of bits");
            }

            return new STH1123.ReedSolomon.GenericGF((int)PrimPoly, (int)Math.Pow(2, NumOfBits), 1);
        }


        public static void Main(string[] args)
        {
            // Number of bits per symbol
            int NumOfBits = 8;

            // Raw data block size
            int DataSize = 223;

            // Reed-Solomon code block size
            int CodeSize = 32;

            // Maximum value of element (2^n)-1, where n=1,2,3...
            int ValMax = ((int)Math.Pow(2, NumOfBits) - 1);

            // Number of randomly generated errors
            int TestErrCount = 30;

            // Determine if error locations is known
            bool KnownErrors = true;

            // Data structure with correction code
            int[] TestData1 = new int[DataSize + CodeSize];
            int[] TestData2 = new int[DataSize + CodeSize];
            int[] TestData3 = new int[DataSize + CodeSize];

            // Creating pseudo-random number generator
            Random R = new Random();

            // Maximum used value
            int MaxCodeVal = 0;

            // Good and bad result counter
            int ResultGood = 0;
            int ResultBad = 0;
            int ResultFailure = 0;

            // Number of test iterations
            int TestIterations = 1000000;

            // Iterative repeat test
            for (int TestI = 0; TestI < TestIterations; TestI++)
            {
                // Clearing data
                for (int i = 0; i < (DataSize + CodeSize); i++)
                {
                    TestData1[i] = 0;
                    TestData2[i] = 0;
                    TestData3[i] = 0;
                }

                // Creating three instances of the same raw data
                for (int i = 0; i < DataSize; i++)
                {
                    TestData1[i] = R.Next(0, ValMax);
                    TestData2[i] = TestData1[i];
                    TestData3[i] = TestData1[i];
                }

                // Encoding
                STH1123.ReedSolomon.ReedSolomonEncoder RSE = new STH1123.ReedSolomon.ReedSolomonEncoder(GenGF(NumOfBits));
                RSE.Encode(TestData2, CodeSize);


                // Making random errors with storing locations
                int TestErr = TestErrCount;
                List<int> TestErrPos = new List<int>();
                while (TestErr > 0)
                {
                    int P = R.Next(DataSize - 1);
                    if (!TestErrPos.Contains(P))
                    {
                        TestErrPos.Add(P);
                        int D = R.Next(ValMax);
                        if (TestData2[P] != D)
                        {
                            TestData2[P] = D;
                            TestData3[P] = D;
                            TestErr--;
                        }
                    }
                }

                // Trying to recovery original data
                STH1123.ReedSolomon.ReedSolomonDecoder RSD = new STH1123.ReedSolomon.ReedSolomonDecoder(GenGF(NumOfBits));
                bool DecodeResult = RSD.Decode(TestData2, CodeSize, KnownErrors ? TestErrPos.ToArray() : null);


                // Encounting differences in raw data instances
                int Diff12 = 0;
                int Diff13 = 0;
                for (int i = 0; i < DataSize; i++)
                {
                    if (TestData1[i] != TestData2[i])
                    {
                        Diff12++;
                    }
                    if (TestData1[i] != TestData3[i])
                    {
                        Diff13++;
                    }
                }

                // Reading the maximum value
                for (int i = 0; i < (DataSize + CodeSize); i++)
                {
                    if (MaxCodeVal < TestData2[i])
                    {
                        MaxCodeVal = TestData2[i];
                    }
                }

                // If there is not difference, this test result is good,
                // otherwise the test result is bad
                if (Diff13 == TestErrCount)
                {
                    if (Diff12 == 0)
                    {
                        ResultGood++;
                    }
                    else
                    {
                        ResultBad++;
                    }
                }
                else
                {
                    ResultFailure++;
                }


                // Printing the test progress
                if ((TestI % (TestIterations / 100)) == 0)
                {
                    Console.WriteLine("Progress: " + (TestI / (TestIterations / 100)) + "%");
                }
            }

            // Printing the test results
            Console.WriteLine("Maximum existing value: " + MaxCodeVal.ToString());
            Console.WriteLine("Good: " + ResultGood);
            Console.WriteLine("Bad: " + ResultBad);
            Console.WriteLine("Failed: " + ResultFailure);
            Console.WriteLine("Total: " + (ResultGood + ResultBad + ResultFailure));
            Console.ReadLine();
        }


    }
}