public void FitTest6()
        {
            MultivariateContinuousDistribution target = CreateMultivariateContinuousDistribution(); // TODO: Initialize to an appropriate value

            double[][] observations =
            {
                new double[] { 1, 2 },
                new double[] { 3, 2 },
                new double[] { 2, 3 },
                new double[] { 1, 2 },
            };

            target.Fit(observations);

            double[] expectedMean = { 1.75, 2.25 };
            double[,] expectedCov =
            {
                {  0.91666666666666663, 0.083333333333333329 },
                { 0.083333333333333329,                 0.25 },
            };

            Assert.IsTrue(expectedMean.IsEqual(target.Mean));
            Assert.IsTrue(expectedCov.IsEqual(target.Covariance));

            Assert.IsTrue(expectedCov.Diagonal().IsEqual(target.Variance));

            double[] x        = { 0.4, 2 };
            double   expected = 0.120833904312578;
            double   actual   = target.ProbabilityDensityFunction(x);

            Assert.AreEqual(expected, actual, 1e-10);
        }
        public void FitTest7()
        {
            MultivariateContinuousDistribution target = CreateMultivariateContinuousDistribution();

            double[][] observations =
            {
                new double[] { 1, 2 },
                new double[] { 3, 2 },
                new double[] { 2, 3 },
                new double[] { 1, 2 },
            };

            double[] weights = { 0.125, 0.125, 0.25, 0.5 };

            target.Fit(observations, weights);

            double[] expectedMean = { 1.5, 2.25 };
            double[,] expectedCov =
            {
                { 0.76190476190476186, 0.19047619047619047 },
                { 0.19047619047619047,  0.2857142857142857 },
            };

            Assert.IsTrue(expectedMean.IsEqual(target.Mean));
            Assert.IsTrue(expectedCov.IsEqual(target.Covariance));


            Assert.IsTrue(Matrix.Diagonal(expectedCov).IsEqual(target.Variance));

            double[] x        = { 0.4, 2 };
            double   expected = 0.168681501947055;
            double   actual   = target.ProbabilityDensityFunction(x);

            Assert.AreEqual(expected, actual, 1e-10);
        }
        public void DimensionTest()
        {
            MultivariateContinuousDistribution target = CreateMultivariateContinuousDistribution();
            int actual   = target.Dimension;
            int expected = 2;

            Assert.AreEqual(expected, actual);
        }
        public void MeanTest()
        {
            MultivariateContinuousDistribution target = CreateMultivariateContinuousDistribution();

            double[] actual   = target.Mean;
            double[] expected = { 0.2, 4.2 };
            Assert.IsTrue(expected.IsEqual(actual));
        }
        public void VarianceTest()
        {
            MultivariateContinuousDistribution target = CreateMultivariateContinuousDistribution();

            double[] actual   = target.Variance;
            double[] expected = { 1.2, 2.3 };
            Assert.IsTrue(expected.IsEqual(actual));
        }
        public void ProbabilityDensityFunctionTest()
        {
            MultivariateContinuousDistribution target = CreateMultivariateContinuousDistribution();

            double[] x        = { 0.4, 2 };
            double   expected = 0.032309150392899;
            double   actual   = target.ProbabilityDensityFunction(x);

            Assert.AreEqual(expected, actual, 1e-10);
        }
        public void CovarianceTest()
        {
            MultivariateContinuousDistribution target = CreateMultivariateContinuousDistribution();

            double[,] actual   = target.Covariance;
            double[,] expected =
            {
                { 1.2, 0.1 },
                { 0.1, 2.3 },
            };
            Assert.IsTrue(expected.IsEqual(actual));
        }
        public void FitTest5()
        {
            MultivariateContinuousDistribution target = CreateMultivariateContinuousDistribution(); // TODO: Initialize to an appropriate value

            double[][] observations =
            {
                new double[] { 1, 1 },
                new double[] { 1, 1 },
            };

            double[] weights = { 0.50, 0.50 };

            bool thrown;

            IFittingOptions options = new NormalOptions()
            {
                Regularization = 0.1
            };

            thrown = false;
            try
            {
                target.Fit(observations, weights);
            }
            catch
            {
                thrown = true;
            }

            Assert.AreEqual(true, thrown);


            thrown = false;
            try
            {
                target.Fit(observations, weights, options);
            }
            catch
            {
                thrown = true;
            }

            Assert.AreEqual(false, thrown);
        }
        public void FitTest2()
        {
            IDistribution target = CreateMultivariateContinuousDistribution();

            double[][] observations =
            {
                new double[] { 1, 2 },
                new double[] { 3, 2 },
                new double[] { 2, 3 },
                new double[] { 1, 2 },
            };

            target.Fit(observations);

            double[]   expectedMean = Measures.Mean(observations, dimension: 0);
            double[][] expectedCov  = Measures.Covariance(observations, expectedMean);

            MultivariateContinuousDistribution actual = target as MultivariateContinuousDistribution;

            Assert.IsTrue(expectedMean.IsEqual(actual.Mean));
            Assert.IsTrue(expectedCov.IsEqual(actual.Covariance));
        }
        public void FitTest3()
        {
            IDistribution target = CreateMultivariateContinuousDistribution();

            double[][] observations =
            {
                new double[] { 1, 2 },
                new double[] { 3, 2 },
                new double[] { 2, 3 },
                new double[] { 1, 2 },
            };

            target.Fit(observations);

            double[] expectedMean = Accord.Statistics.Tools.Mean(observations);
            double[,] expectedCov = Accord.Statistics.Tools.Covariance(observations, expectedMean);

            MultivariateContinuousDistribution actual = target as MultivariateContinuousDistribution;

            Assert.IsTrue(expectedMean.IsEqual(actual.Mean));
            Assert.IsTrue(expectedCov.IsEqual(actual.Covariance));
        }