private void InitBoxes(int Seed)
        {
            FastRandom rnd = new FastRandom(Seed);

            for (int i = 0; i < DataSize; i++)
            {
                //set random values in Box B (The output box)
                byte[] TempValues = new byte[BOX_SIZE];
                for (int x = 0; x < BOX_SIZE; x++)
                    TempValues[x] = (byte)x;
                ShuffleValues(TempValues, Seed);

                for (int j = 0; j < BOX_SIZE; j++)
                {
                    BOX_B[i, j] = TempValues[j];
                }

                //Set in Box A where the index of Box B
                for (int j = 0; j < BOX_SIZE; j++)
                {
                    for (int x = 0; x < BOX_SIZE; x++)
                    {
                        if (BOX_B[i, x] == j)
                        {
                            BOX_A[i, j] = (byte)x;
                            break;
                        }
                    }
                }
            }
        }

 public static String RandomDecimalString(FastRandom r)
 {
     int count = r.NextValue(20) + 1;
       StringBuilder sb = new StringBuilder();
       if (r.NextValue(2) == 0) sb.Append('-');
       for (int i = 0; i < count; i++) {
     if (i == 0)
       sb.Append((char)('1' + r.NextValue(9)));
     else
       sb.Append((char)('0' + r.NextValue(10)));
       }
       if (r.NextValue(2) == 0) {
     sb.Append('.');
     count = r.NextValue(20) + 1;
     for (int i = 0; i < count; i++) {
       sb.Append((char)('0' + r.NextValue(10)));
     }
       }
       if (r.NextValue(2) == 0) {
     sb.Append('E');
     count = r.NextValue(20);
     if (count != 0) {
       sb.Append(r.NextValue(2) == 0 ? '+' : '-');
     }
     sb.Append(Convert.ToString(
       (int)count, CultureInfo.InvariantCulture));
       }
       return sb.ToString();
 }

    protected override Tuple<string[], string[]> GenerateInputOutput() {
      FastRandom rand = new FastRandom();
      List<List<int>> vectors = GetHardcodedTrainingSamples();
      var zeros = GetHardcodedZeros();
      var trainZeros = zeros.SampleRandomWithoutRepetition(rand, 30).ToList();
      var testZeros = zeros.Except<List<int>>(trainZeros, new EnumerableValueEqualityComparer<int>()).ToList();
      var help1 = GetDistinctPermutations(new int[4] { 0, 5, -8, 9 });
      var trainHelp1 = help1.SampleRandomWithoutRepetition(rand, 20).ToList();
      var testHelp1 = help1.Except<List<int>>(trainHelp1, new EnumerableValueEqualityComparer<int>()).ToList();
      var help2 = GetDistinctPermutations(new int[4] { 0, 0, -8, 9 });
      var trainHelp2 = help2.SampleRandomWithoutRepetition(rand, 10).ToList();
      var testHelp2 = help2.Except<List<int>>(trainHelp2, new EnumerableValueEqualityComparer<int>()).ToList();
      var help3 = GetDistinctPermutations(new int[4] { 0, 0, 0, 9 });

      vectors.AddRange(trainZeros);
      vectors.AddRange(trainHelp1);
      vectors.AddRange(trainHelp2);
      vectors.AddRange(help3);

      vectors.AddRange(GetRandomVectors(78, rand).ToList());

      vectors = vectors.Shuffle(rand).ToList();

      vectors.AddRange(testZeros);
      vectors.AddRange(testHelp1);
      vectors.AddRange(testHelp2);
      vectors.AddRange(GetRandomVectors(974, rand).ToList());

      var input = vectors.Select(x => String.Format("[{0}]", String.Join(", ", x))).ToArray();
      var output = vectors.Select(x => x.LastIndexOf(0).ToString()).ToArray();
      return new Tuple<string[], string[]>(input, output);
    }

        /// <summary>
        /// Initializes a new instance of the <see cref="NeuralColorQuantizer"/> class.
        /// </summary>
        public NeuralColorQuantizer()
        {
            Quality = DefaultQuality;

            random = new FastRandom(0);
            uniqueColors = new ConcurrentDictionary<Int32, Boolean>();
        }

 public MsgKeepAlive()
     : base()
 {
     FastRandom fastRand = new FastRandom();
     this.Payload = new byte[fastRand.Next(32, 256)];
     fastRand.NextBytes(this.Payload);
 }

 public MarkovChainSampler()
 {
     this.sampleCache = new Stack<Sample>(100);
     rnd = new FastRandom();
     TotalSamples = 0L;
     samplesInPass = 0;
 }

 /// <summary>
 /// Constructs with the provided world parameter arguments.
 /// </summary>
 public PreyCaptureWorld(int gridSize, int preyInitMoves, double preySpeed, double sensorRange, int maxTimesteps)
 {
     _gridSize = gridSize;
     _preyInitMoves = preyInitMoves;
     _preySpeed = preySpeed;
     _sensorRange = sensorRange;
     _maxTimesteps = maxTimesteps;
     _rng = new FastRandom();
 }

 public void InitNoise() {
     var RNG = new FastRandom();
     NoiseTable = new float[NoiseDim + 1, NoiseDim + 1, NoiseDim + 1];
     int i, j, k;
     for (i = 0; i < NoiseDim; i++)
         for (j = 0; j < NoiseDim; j++)
             for (k = 0; k < NoiseDim; k++)
                 NoiseTable[i, j, k] = RNG.NextFloat();
 }

 /// <summary>
 /// Initializes a new instance from an existing one (copy constructor).
 /// </summary>
 /// <param name="original">The original <see cref="FastRandom"/> instance which is used to initialize the new instance.</param>
 /// <param name="cloner">A <see cref="Cloner"/> which is used to track all already cloned objects in order to avoid cycles.</param>
 private FastRandom(FastRandom original, Cloner cloner)
   : base(original, cloner) {
   x = original.x;
   y = original.y;
   z = original.z;
   w = original.w;
   bitBuffer = original.bitBuffer;
   bitMask = original.bitMask;
 }

 public PathGenerator(uint seed, GetHeight getHeight)
 {
     m_getHeight = getHeight;
     var fastRandom = new FastRandom(seed);
     m_cellNoise = new CellNoise2D(fastRandom.NextUInt());
     m_sources = new Dictionary<uint, PathGraphNode>();
     m_sinks = new Dictionary<uint, PathGraphNode>();
     m_general = new Dictionary<uint, PathGraphNode>();
     m_paths = new List<PathNodeList>();
 }

        public MarkovChain(MarkovChainNode[] nodes, int stepsPerActivation, FastRandom random)
        {
            _nodes = nodes;
            _stepsPerActivation = stepsPerActivation;
            _random = random;

            _rouletteWheels = new RouletteWheelLayout[nodes.Length];
            for (int i = 0; i < nodes.Length; i++)
                _rouletteWheels[i] = new RouletteWheelLayout(nodes[i].TransitionProbabilities);
        }

 private IEnumerable<List<int>> GetRandomVectors(int n, FastRandom rand) {
   for (int i = 0; i < n; i++) {
     int length = rand.Next(1, 50);
     List<int> cur = new List<int>(length) { 0 };
     for (int j = 0; j < length - 1; j++) {
       cur.Add(rand.Next(-50, 50));
     }
     yield return cur.Shuffle(rand).ToList();
   }
 }

        public FiniteAppertureCamera(Point eye, Vector dirt, Vector up, int width, int height, float fov)
        {
            rnd = new FastRandom();
            this.fieldOfView = fov;
            this.Height = height;
            this.Width = width;
            this.Position = eye;
            this.Target = dirt;
            this.Up = up;

            this.Update();
        }

 public void TestCBORObjectDecimal()
 {
     FastRandom rand = new FastRandom();
       for (int i = 0; i <= 28; i++) { // Try a random decimal with a given exponent
     for (int j = 0; j < 8; j++) {
       decimal d = RandomDecimal(rand, i);
       CBORObject obj = CBORObject.FromObject(d);
       TestCommon.AssertRoundTrip(obj);
       Assert.AreEqual(d, obj.AsDecimal());
     }
       }
 }

 public static String RandomBigIntString(FastRandom r)
 {
     int count = r.NextValue(50) + 1;
       StringBuilder sb = new StringBuilder();
       if (r.NextValue(2) == 0) sb.Append('-');
       for (int i = 0; i < count; i++) {
     if (i == 0)
       sb.Append((char)('1' + r.NextValue(9)));
     else
       sb.Append((char)('0' + r.NextValue(10)));
       }
       return sb.ToString();
 }

    //protected override IEnumerable<int> GenerateTraining() {
    //  var x0 = new List<int>() { 1, 2, 3, 4, 5, 100 };
    //  x0.AddRange(ValueGenerator.SampleRandomWithoutRepetition(numbers, 44, rand));
    //  return x0;
    //}

    //protected override IEnumerable<int> GenerateTest() {
    //  return numbers.Except(GenerateTraining());
    //}

    //protected override Tuple<string[], string[]> GenerateInputOutput(IEnumerable<int> x0) {
    //  var input = x0.Select(x => x.ToString()).ToArray();
    //  var output = x0.Select(x => CalcSumOfSquares(x).ToString()).ToArray();
    //  return new Tuple<string[], string[]>(input, output);
    //}

    protected override Tuple<string[], string[]> GenerateInputOutput() {
      FastRandom rand = new FastRandom();
      var x0 = new List<int>() { 1, 2, 3, 4, 5, 100 };
      x0.AddRange(ValueGenerator.SampleRandomWithoutRepetition(numbers, 44, rand));

      x0 = x0.Shuffle(rand).ToList();

      x0.AddRange(numbers.Except(x0));

      var input = x0.Select(x => x.ToString()).ToArray();
      var output = x0.Select(x => CalcSumOfSquares(x).ToString()).ToArray();
      return new Tuple<string[], string[]>(input, output);
    }

        public MazeWallMover (Maze maze, Maze secondMaze, GameState state,
            Func<int, int, bool> containsPortal)
        {
            Maze = maze;
            SecondMaze = secondMaze;
            this.GameState = state;
            rand = new FastRandom(maze.Seed);
            this.containsPortal = containsPortal;

            ValidMessages = new[] { (int) MessageId.Update };

            this.GameState.MessageProxy.RegisterMessageConsumer(this);
            this.GameState.MessageProxy.AddMessageCreator (this);
        }

        public TriangleMeshLight(LightMaterial mt, RayEngineScene scene, TriangleMeshInfo mesh) : base(mt)
        {
            this.scene = scene;
            this.mesh = mesh;
            this.rnd = new FastRandom();

            triangleSampleData = new TriangleSample[this.mesh.TrianglesCount];

            for (int i = mesh.StartTriangle, j = 0; i < mesh.EndTriangle; i++, j++)
            {
                triangleSampleData[j] = new TriangleSample(scene.Triangles[i].AreaV(scene.Vertices), NormalModifier * scene.Triangles[i].ComputeNormal(scene.Vertices));
            }

            triangleSampleData.PartialSort((a, b) => a.Item1.CompareTo(a.Item1), 0, triangleSampleData.Length);

        }

        private void InitGen()
        {
            
            if (GenInit)
                return;

            GenInit = true;

            _Gen1 = new PerlinNoise(_Seed);
            _Gen2 = new PerlinNoise(_Seed + 1);
            _Gen3 = new PerlinNoise(_Seed + 2);
            _Gen4 = new PerlinNoise(_Seed + 3);
            _Gen5 = new PerlinNoise(_Seed + 4);
            _Gen6 = new PerlinNoise(_Seed + 5);
            _FastRandom = new FastRandom(_Seed);
        }

    public Problem()
      : base() {
      Parameters.Add(new FixedValueParameter<IntValue>(LawnWidthParameterName, "Width of the lawn.", new IntValue(8)));
      Parameters.Add(new FixedValueParameter<IntValue>(LawnLengthParameterName, "Length of the lawn.", new IntValue(8)));

      var g = new SimpleSymbolicExpressionGrammar();
      g.AddSymbols(new string[] { "Sum", "Prog" }, 2, 2);
      g.AddSymbols(new string[] { "Frog" }, 1, 1);
      g.AddTerminalSymbols(new string[] { "Left", "Forward" });
      // initialize 20 ephemeral random constants in [0..32[
      var fastRand = new FastRandom(314159);
      for (int i = 0; i < 20; i++) {
        g.AddTerminalSymbol(string.Format("{0},{1}", fastRand.Next(0, 32), fastRand.Next(0, 32)));
      }

      Encoding = new SymbolicExpressionTreeEncoding(g, 1000, 17);
    }