コード例 #1
0
        /// <summary>
        ///   Computes the cumulative distribution function for distributions
        ///   up to two dimensions. For more than two dimensions, this method
        ///   is not supported.
        /// </summary>
        ///
        public override double DistributionFunction(params double[] x)
        {
            if (Dimension == 1)
            {
                double stdDev = Math.Sqrt(Covariance[0, 0]);

                if (stdDev == 0)
                {
                    return((x[0] == mean[0]) ? 1 : 0);
                }

                double z = (x[0] - mean[0]) / stdDev;

                return(Normal.Function(z));
            }

            if (Dimension == 2)
            {
                double sigma1 = Math.Sqrt(Covariance[0, 0]);
                double sigma2 = Math.Sqrt(Covariance[1, 1]);
                double rho    = Covariance[0, 1] / (sigma1 * sigma2);

                if (Double.IsNaN(rho))
                {
                    return((x.IsEqual(mean)) ? 1 : 0);
                }

                double z = (x[0] - mean[0]) / sigma1;
                double w = (x[1] - mean[1]) / sigma2;
                return(Normal.Bivariate(z, w, rho));
            }

            throw new NotSupportedException("The cumulative distribution "
                                            + "function is only available for up to two dimensions.");
        }
コード例 #2
0
        public void BivariateFunctionTest()
        {
            {
                double a = Normal.Bivariate(+0, +0, 0.0);
                double b = Normal.Bivariate(-1, +0, 0.0);
                double c = Normal.Bivariate(+0, -1, 0.0);
                double d = Normal.Bivariate(-1, -1, 0.0);

                Assert.AreEqual(a, 0.25);
                Assert.AreEqual(b, 0.07932762696572859, 1e-10);
                Assert.AreEqual(c, 0.07932762696572859, 1e-10);
                Assert.AreEqual(d, 0.02517148960005514, 1e-10);
            }

            {
                double a = Normal.Bivariate(0, 0, 0.0);
                double b = Normal.Bivariate(1, 0, 0.0);
                double c = Normal.Bivariate(0, 1, 0.0);
                double d = Normal.Bivariate(1, 1, 0.0);

                Assert.AreEqual(a, 0.25);
                Assert.AreEqual(b, 0.4206723730342714, 1e-10);
                Assert.AreEqual(c, 0.4206723730342714, 1e-10);
                Assert.AreEqual(d, 0.707860981737141, 1e-10);
            }

            {
                double a = Normal.Bivariate(+0, +0, 0.99);
                double b = Normal.Bivariate(-1, +0, 0.99);
                double c = Normal.Bivariate(+0, -1, 0.99);
                double d = Normal.Bivariate(-1, -1, 0.99);

                Assert.AreEqual(a, 0.477473293177794, 1e-6);
                Assert.AreEqual(b, 0.1586552539314527, 1e-10);
                Assert.AreEqual(c, 0.1586552539314527, 1e-10);
                Assert.AreEqual(d, 0.1450035348479944, 1e-8);
            }

            {
                double a = Normal.Bivariate(0, 0, 0.99);
                double b = Normal.Bivariate(1, 0, 0.99);
                double c = Normal.Bivariate(0, 1, 0.99);
                double d = Normal.Bivariate(1, 1, 0.99);

                Assert.AreEqual(a, 0.477473293177794, 1e-6);
                Assert.AreEqual(b, 0.4999999999999956, 1e-10);
                Assert.AreEqual(c, 0.4999999999999956, 1e-10);
                Assert.AreEqual(d, 0.8276930269850803, 1e-8);
            }

            {
                double a = Normal.Bivariate(0, 0, 0.42);
                double b = Normal.Bivariate(0, 1, 0.42);
                double c = Normal.Bivariate(1, 0, 0.42);
                double d = Normal.Bivariate(1, 1, 0.42);

                double e = Normal.Bivariate(-0, -1, 0.42);
                double f = Normal.Bivariate(-1, -0, 0.42);
                double g = Normal.Bivariate(-1, -1, 0.42);


                Assert.AreEqual(a, 0.3189849652491711, 1e-10);
                Assert.AreEqual(b, 0.4611405565191831, 1e-10);
                Assert.AreEqual(c, 0.4611405565191831, 1e-10);
                Assert.AreEqual(d, 0.7379699765574815, 1e-10);
                Assert.AreEqual(e, 0.1197958104506402, 1e-10);
                Assert.AreEqual(f, 0.1197958104506402, 1e-10);
                Assert.AreEqual(g, 0.05528048442039563, 1e-10);
            }
        }