Accord.Tests.Statistics.CircularDescriptiveAnalysisTest.test C# (CSharp) Method

test() private static method

private static test ( CircularDescriptiveAnalysis analysis ) : void
analysis CircularDescriptiveAnalysis
return void
        private static void test(CircularDescriptiveAnalysis analysis)
        {
            double[] expectedMean;
            double[] expectedStdDev;
            double[] expectedVar;
            double[] expectedMed;
            double[] expectedError;

            expectedValues(analysis,
                out expectedMean, out expectedStdDev,
                out expectedVar, out expectedMed,
                out expectedError);

            var angles = analysis.Angles;
            var cos = analysis.CosineSum;
            var sin = analysis.SineSum;
            var columnNames = analysis.ColumnNames;
            var distinct = analysis.Distinct;
            var means = analysis.Means;
            var medians = analysis.Medians;
            var ranges = analysis.Ranges;
            var samples = analysis.Samples;
            var standardDeviation = analysis.StandardDeviations;
            var sums = analysis.Sums;
            var variables = analysis.Variables;
            var variances = analysis.Variances;
            var quartiles = analysis.Quartiles;
            var inner = analysis.InnerFences;
            var outer = analysis.OuterFences;
            var error = analysis.StandardErrors;

            Assert.IsTrue(columnNames.IsEqual(new string[] 
            {
                "Column 0",
                "Column 1",
                "Column 2",
            }));


            Assert.IsTrue(distinct.IsEqual(new int[] { 8, 7, 5 }));
            Assert.IsTrue(means.IsEqual(expectedMean));
            Assert.IsTrue(medians.IsEqual(expectedMed, 1e-14));
            Assert.IsTrue(error.IsEqual(expectedError, 1e-14));


            Assert.AreEqual(3, ranges.Length);
            Assert.AreEqual(0, ranges[0].Min);
            Assert.AreEqual(24, ranges[0].Max);
            Assert.AreEqual(0, ranges[1].Min);
            Assert.AreEqual(60, ranges[1].Max);
            Assert.AreEqual(0, ranges[2].Min);
            Assert.AreEqual(7, ranges[2].Max);

            Assert.IsTrue(samples == 8);

            // string str = angles.ToString(CSharpJaggedMatrixFormatProvider.InvariantCulture);

            var expectedAngles = new double[][] 
            {
                new double[] { -1.30899693899575, -2.35619449019234, 2.87979326579064, 2.35619449019234, -1.83259571459405, 0.785398163397448, -1.5707963267949, -1.0471975511966 },
                new double[] { 2.30383461263252, -1.88495559215388, -1.88495559215388, 1.25663706143592, -1.78023583703422, -1.46607657167524, -2.30383461263252, -0.837758040957278 },
                new double[] { -2.24399475256414, 1.34639685153848, 0.448798950512828, 2.24399475256414, 1.34639685153848, 2.24399475256414, -3.14159265358979, 1.34639685153848 } 
            };

            Assert.IsTrue(angles.IsEqual(expectedAngles, 1e-10));

            Assert.IsTrue(standardDeviation.IsEqual(expectedStdDev, 1e-14));
            Assert.IsTrue(sums.IsEqual(new double[] { 88.0, 177.0, 32.0 }));
            Assert.IsTrue(sin.IsEqual(new double[] { -2.831951230073507, -3.6668708378746273, 4.1404989581310589 }, 1e-14));
            Assert.IsTrue(cos.IsEqual(new double[] { -1.1730326074756157, -1.0815308282839116, -1.3019377358048381 }, 1e-14));
            Assert.IsTrue(variables == 3);
            Assert.IsTrue(variances.IsEqual(expectedVar, 1e-14));

            Assert.AreEqual(3, quartiles.Length);
            Assert.AreEqual(23, quartiles[0].Min);
            Assert.AreEqual(7.5, quartiles[0].Max);
            Assert.AreEqual(8, quartiles[1].Min);
            Assert.AreEqual(19, quartiles[1].Max);
            Assert.AreEqual(5, quartiles[2].Min);
            Assert.AreEqual(6.5, quartiles[2].Max);

            Assert.AreEqual(22.25, inner[0].Min);
            Assert.AreEqual(8.25, inner[0].Max);

            Assert.AreEqual(51.5, inner[1].Min);
            Assert.AreEqual(35.5, inner[1].Max);

            Assert.AreEqual(21.5, outer[0].Min);
            Assert.AreEqual(9, outer[0].Max);

            Assert.AreEqual(35, outer[1].Min);
            Assert.AreEqual(52, outer[1].Max);

            Assert.AreEqual(5.0, quartiles[2].Min);
            Assert.AreEqual(6.5, quartiles[2].Max);
        }