public static List<PatternClass> Create2DimTeachingVectors(double p1, double p2, IContinuousDistribution generatorFirstFeature1, IContinuousDistribution generatorFirstFeature2, IContinuousDistribution generatorSecondFeature1, IContinuousDistribution generatorSecondFeature2, int nrOfTeachingVectors)
        {
            List<PatternClass> createdTeachingVectors = new List<PatternClass>();
             if (probabilityGenerator == null)
             {
                 probabilityGenerator = new ContinuousUniform(0, 1);
                 probabilityGenerator.RandomSource = new Random(DateTime.Now.Millisecond + 10);
             }

             for (int i = 0; i < nrOfTeachingVectors; i++)
             {
                 double value = 0;
                 double value1 = 0;
                 int classNumber = CreateClass(p1, p2);

                 if (classNumber == 1)
                 {
                     value = generatorFirstFeature1.Sample();
                     value1 = generatorSecondFeature1.Sample();
                 }
                 else if (classNumber == 2)
                 {
                     value = generatorFirstFeature2.Sample();
                     value1 = generatorSecondFeature2.Sample();
                 }

                 createdTeachingVectors.Add(new PatternClass(new FeatureVector(value,value1), classNumber));
             }

             return createdTeachingVectors;
        }

        static ZergCharacter()
        {
            GOAL_PRIORITIES = new Dictionary<State, byte>(){
                {State.AttackGoal, 16},
                {State.FeedGoal, 8},
                {State.RetreatGoal, 1},
                {State.ServeGoal, 2}
            };

            var goals = new Stack<State>();

            var goalEnums = (State[])Enum.GetValues(typeof(State));
            foreach (var enumValue in goalEnums)
            {
                for (int i = 0; i < GOAL_PRIORITIES[enumValue]; i++)
                {
                    goals.Push(enumValue);
                }
            }

            int count = goals.Count;
            RND = new DiscreteUniform(0, count - 1);
            GOALS_LOOKUP_TABLE = new State[count];

            var rnd = new ContinuousUniform(0.0, 1.0);

            while (goals.Any())
            {
                int idx = (int)Math.Round(rnd.Sample() * (--count), 0);
                GOALS_LOOKUP_TABLE[idx] = goals.Pop();
            }
        }

        /// <summary>
        /// Build linear samples.
        /// </summary>
        /// <param name="x">X sample values.</param>
        /// <param name="y">Y samples values.</param>
        /// <param name="xtest">X test values.</param>
        /// <param name="ytest">Y test values.</param>
        /// <param name="samples">Sample values.</param>
        /// <param name="sampleOffset">Sample offset.</param>
        /// <param name="slope">Slope number.</param>
        /// <param name="intercept">Intercept criteria.</param>
        public static void Build(out double[] x, out double[] y, out double[] xtest, out double[] ytest, int samples = 3, double sampleOffset = -0.5, double slope = 2.0, double intercept = -1.0)
        {
            // Fixed-seed "random" distribution to ensure we always test with the same data
            var uniform = new ContinuousUniform(0.0, 1.0, new SystemRandomSource(42));

            // build linear samples
            x = new double[samples];
            y = new double[samples];
            for (int i = 0; i < x.Length; i++)
            {
                x[i] = i + sampleOffset;
                y[i] = (x[i]*slope) + intercept;
            }

            // build linear test vectors randomly between the sample points
            xtest = new double[samples + 1];
            ytest = new double[samples + 1];
            if (samples == 1)
            {
                // y = const
                xtest[0] = sampleOffset - uniform.Sample();
                xtest[1] = sampleOffset + uniform.Sample();
                ytest[0] = ytest[1] = (sampleOffset*slope) + intercept;
            }
            else
            {
                for (int i = 0; i < xtest.Length; i++)
                {
                    xtest[i] = (i - 1) + sampleOffset + uniform.Sample();
                    ytest[i] = (xtest[i]*slope) + intercept;
                }
            }
        }

        public void RejectTest()
        {
            var uniform = new ContinuousUniform(0.0, 1.0, new SystemRandomSource(1));
            var rs = new RejectionSampler<double>(x => Math.Pow(x, 1.7)*Math.Pow(1.0 - x, 5.3), x => 0.021, uniform.Sample);
            Assert.IsNotNull(rs.RandomSource);

            rs.RandomSource = uniform.RandomSource;
            Assert.IsNotNull(rs.RandomSource);
        }

        public void NullRandomNumberGenerator()
        {
            var uniform = new ContinuousUniform(0.0, 1.0);
            uniform.RandomSource = new MersenneTwister();

            var rs = new RejectionSampler<double>(x => System.Math.Pow(x, 1.7) * System.Math.Pow(1.0 - x, 5.3),
                                                  x => System.Double.NegativeInfinity,
                                                  uniform.Sample);
            rs.RandomSource = null;
        }

        public void NoUpperBound()
        {
            var uniform = new ContinuousUniform(0.0, 1.0);
            uniform.RandomSource = new MersenneTwister();

            var rs = new RejectionSampler<double>(x => System.Math.Pow(x, 1.7) * System.Math.Pow(1.0 - x, 5.3),
                                                  x => System.Double.NegativeInfinity,
                                                  uniform.Sample);
            double s = rs.Sample();
        }

        public void SampleArrayTest()
        {
            var uniform = new ContinuousUniform(0.0, 1.0, new SystemRandomSource(1));

            var rs = new RejectionSampler<double>(x => Math.Pow(x, 1.7)*Math.Pow(1.0 - x, 5.3), x => 0.021, uniform.Sample)
                {
                    RandomSource = uniform.RandomSource
                };

            rs.Sample(5);
        }

        public void SetupDistributions()
        {
            dists = new IDistribution[8];

            dists[0] = new Beta(1.0, 1.0);
            dists[1] = new ContinuousUniform(0.0, 1.0);
            dists[2] = new Gamma(1.0, 1.0);
            dists[3] = new Normal(0.0, 1.0);
            dists[4] = new Bernoulli(0.6);
            dists[5] = new Weibull(1.0, 1.0);
            dists[6] = new DiscreteUniform(1, 10);
            dists[7] = new LogNormal(1.0, 1.0);
        }

        public static List<PatternClass> Create2dimSampleObject(IContinuousDistribution generator, IContinuousDistribution generator1, int count, int classNumber)
        {
            List<PatternClass> sampleObjects = new List<PatternClass>();

                         probabilityGenerator = new ContinuousUniform(0, 1);
             probabilityGenerator.RandomSource = new Random(DateTime.Now.Millisecond + 10);

            for (int i = 0; i < count; i++)
            {
                sampleObjects.Add(new PatternClass(new FeatureVector(generator.Sample(), generator1.Sample()), classNumber));
            }
            return sampleObjects;
        }

        public void RejectTest()
        {
            var uniform = new ContinuousUniform(0.0, 1.0);
            uniform.RandomSource = new MersenneTwister();

            var rs = new RejectionSampler<double>(x => System.Math.Pow(x, 1.7) * System.Math.Pow(1.0 - x, 5.3),
                                                  x => 0.021,
                                                  uniform.Sample);
            Assert.IsNotNull(rs.RandomSource);

            rs.RandomSource = uniform.RandomSource;
            Assert.IsNotNull(rs.RandomSource);
        }

        /// <summary>
        /// Run example
        /// </summary>
        public void Run()
        {
            // 1. Get 10 random samples of f(x) = (x * x) / 2 using continuous uniform distribution on [-10, 10]
            var uniform = new ContinuousUniform(-10, 10);
            var result = Generate.RandomMap(10, uniform, Function);
            Console.WriteLine(@" 1. Get 10 random samples of f(x) = (x * x) / 2 using continuous uniform distribution on [-10, 10]");
            for (var i = 0; i < result.Length; i++)
            {
                Console.Write(result[i].ToString("N") + @" ");
            }

            Console.WriteLine();
            Console.WriteLine();

            // 2. Get 10 random samples of f(x) = (x * x) / 2 using Exponential(1) distribution and retrieve sample points
            var exponential = new Exponential(1);
            double[] samplePoints = Generate.Random(10, exponential);
            result = Generate.Map(samplePoints, Function);
            Console.WriteLine(@"2. Get 10 random samples of f(x) = (x * x) / 2 using Exponential(1) distribution and retrieve sample points");
            Console.Write(@"Points: ");
            for (var i = 0; i < samplePoints.Length; i++)
            {
                Console.Write(samplePoints[i].ToString("N") + @" ");
            }

            Console.WriteLine();
            Console.Write(@"Values: ");
            for (var i = 0; i < result.Length; i++)
            {
                Console.Write(result[i].ToString("N") + @" ");
            }

            Console.WriteLine();
            Console.WriteLine();

            // 3. Get 10 random samples of f(x, y) = (x * y) / 2 using ChiSquare(10) distribution
            var chiSquare = new ChiSquared(10);
            result = Generate.RandomMap2(10, chiSquare, TwoDomainFunction);
            Console.WriteLine(@" 3. Get 10 random samples of f(x, y) = (x * y) / 2 using ChiSquare(10) distribution");
            for (var i = 0; i < result.Length; i++)
            {
                Console.Write(result[i].ToString("N") + @" ");
            }

            Console.WriteLine();
        }

        /// <summary>
        /// Uses Infer3DExactLMS to infer a random world point from a number of different projections of the point.
        /// It writes out the squared errors corresponding to different number of projections into a file.
        /// </summary>
        /// <param name="numProjections">the max number of projections to use.</param>
        /// <param name="gaussianNoiseSigma">the standard deviation of the gaussian noise to be added to the projected points.</param>
        public static void ShowErrorInfer3DExactLMS(int numProjections, double gaussianNoiseSigma, string fileName)
        {
            ContinuousUniform dist = new ContinuousUniform(0, 1);
            Normal gaussianNoise = new Normal(0, gaussianNoiseSigma);
            DenseMatrix worldPoint = new DenseMatrix(4,1);
            worldPoint = (DenseMatrix) worldPoint.Random(4,1, dist);
            ProjectedPoint[] projections = new ProjectedPoint[numProjections];

            for (int i = 0; i < projections.Length; i++)
            {
                projections[i] = new ProjectedPoint();
                projections[i].worldToImage = new DenseMatrix(3, 4);
                projections[i].worldToImage = (DenseMatrix)projections[i].worldToImage.Random(3, 4, dist);
                projections[i].projectedPoint = (projections[i].worldToImage * worldPoint);
                projections[i].projectedPoint += (DenseMatrix)projections[i].projectedPoint.Random(3, 1, gaussianNoise);
            }

            File.WriteAllLines(fileName,
                Enumerable.Range(2, numProjections)
                    .Select(i => String.Format("{0}\t{1}", i, (worldPoint - Infer3DExactLMS(projections.Take(i))).L2Norm())));
        }

        public void DenseDiagonalMatrixTransposeAndMultiply()
        {
            var dist = new ContinuousUniform(-1.0, 1.0, new SystemRandomSource(1));
            Assert.IsInstanceOf<DiagonalMatrix>(Matrix<Complex>.Build.DiagonalIdentity(3, 3));

            var tall = Matrix<Complex>.Build.Random(8, 3, dist);
            Assert.IsTrue(tall.TransposeAndMultiply(Matrix<Complex>.Build.DiagonalIdentity(3).Multiply(2d)).Equals(tall.Multiply(2d)));
            Assert.IsTrue(tall.TransposeAndMultiply(Matrix<Complex>.Build.Diagonal(5, 3, 2d)).Equals(tall.Multiply(2d).Append(Matrix<Complex>.Build.Dense(8, 2))));
            Assert.IsTrue(tall.TransposeAndMultiply(Matrix<Complex>.Build.Diagonal(2, 3, 2d)).Equals(tall.Multiply(2d).SubMatrix(0, 8, 0, 2)));

            var wide = Matrix<Complex>.Build.Random(3, 8, dist);
            Assert.IsTrue(wide.TransposeAndMultiply(Matrix<Complex>.Build.DiagonalIdentity(8).Multiply(2d)).Equals(wide.Multiply(2d)));
            Assert.IsTrue(wide.TransposeAndMultiply(Matrix<Complex>.Build.Diagonal(10, 8, 2d)).Equals(wide.Multiply(2d).Append(Matrix<Complex>.Build.Dense(3, 2))));
            Assert.IsTrue(wide.TransposeAndMultiply(Matrix<Complex>.Build.Diagonal(2, 8, 2d)).Equals(wide.Multiply(2d).SubMatrix(0, 3, 0, 2)));
        }

 public void ValidateInverseCumulativeDistribution(double lower, double upper)
 {
     var n = new ContinuousUniform(lower, upper);
     for (var i = 0; i < 11; i++)
     {
         var x = i - 5.0;
         if (x <= lower)
         {
             Assert.AreEqual(lower, n.InverseCumulativeDistribution(0.0), 1e-12);
             Assert.AreEqual(lower, ContinuousUniform.InvCDF(lower, upper, 0.0), 1e-12);
         }
         else if (x >= upper)
         {
             Assert.AreEqual(upper, n.InverseCumulativeDistribution(1.0), 1e-12);
             Assert.AreEqual(upper, ContinuousUniform.InvCDF(lower, upper, 1.0), 1e-12);
         }
         else
         {
             Assert.AreEqual(x, n.InverseCumulativeDistribution((x - lower)/(upper - lower)), 1e-12);
             Assert.AreEqual(x, ContinuousUniform.InvCDF(lower, upper, (x - lower)/(upper - lower)), 1e-12);
         }
     }
 }

        /// <summary>
        /// Creates the list of objects with specified class
        /// </summary>
        /// <param name="generator"></param>
        /// <param name="count"></param>
        /// <param name="classNumber"></param>
        /// <returns></returns>
        public static List<PatternClass> CreateSampleObject(int p1,int p2 ,IContinuousDistribution generator1,IContinuousDistribution generator2,int count)
        {
            List<PatternClass> sampleObjects = new List<PatternClass>();
            probabilityGenerator = new ContinuousUniform(0, 1);
            probabilityGenerator.RandomSource = new Random(DateTime.Now.Millisecond + 10);

            int counter = 0; ;
            for (; counter < count; )
            {
                //sampleObjects.Add(new PatternClass(new FeatureVector(generator.Sample()), classNumber));
            }
            return sampleObjects;
        }

 public void ValidateMode(double lower, double upper)
 {
     var n = new ContinuousUniform(lower, upper);
     Assert.AreEqual((lower + upper) / 2.0, n.Mode);
 }

 public void ValidateMinimum(double lower, double upper)
 {
     var n = new ContinuousUniform(lower, upper);
     Assert.AreEqual(lower, n.Minimum);
 }

 public void CanSampleSequence()
 {
     var n = new ContinuousUniform();
     var ied = n.Samples();
     ied.Take(5).ToArray();
 }

 public void NoUpperBound()
 {
     var uniform = new ContinuousUniform(0.0, 1.0, new SystemRandomSource(1));
     var rs = new RejectionSampler<double>(x => Math.Pow(x, 1.7)*Math.Pow(1.0 - x, 5.3), x => Double.NegativeInfinity, uniform.Sample);
     Assert.That(() => rs.Sample(), Throws.ArgumentException);
 }

 public void NullRandomNumberGenerator()
 {
     var uniform = new ContinuousUniform(0.0, 1.0, new SystemRandomSource(1));
     var rs = new RejectionSampler<double>(x => Math.Pow(x, 1.7)*Math.Pow(1.0 - x, 5.3), x => Double.NegativeInfinity, uniform.Sample);
     Assert.That(() => rs.RandomSource = null, Throws.TypeOf<ArgumentNullException>());
 }