Accord.Tests.Statistics.ReceiverOperatingCharacteristicTest.ComputeTest C# (CSharp) Method

        public void ComputeTest()
        {
            // Example from
            // http://faculty.vassar.edu/lowry/roc1.html

            double[,] data = 
            { 
                { 4,  1 },                { 4,  1 },
                { 4,  1 },                { 4,  1 },
                { 4,  1 },                { 4,  1 },
                { 4,  1 },                { 4,  1 },
                { 4,  1 },                { 4,  1 },
                { 4,  1 },                { 4,  1 },
                { 4,  1 },                { 4,  1 },
                { 4,  1 },                { 4,  1 },
                { 4,  1 },                { 4,  1 }, // 18
                { 4,  0 },

                { 6,  1 },                 { 6,  1 }, 
                { 6,  1 },                 { 6,  1 }, 
                { 6,  1 },                 { 6,  1 }, 
                { 6,  1 }, // 7

                { 6,  0 },                 { 6,  0 },
                { 6,  0 },                 { 6,  0 },
                { 6,  0 },                 { 6,  0 },
                { 6,  0 },                 { 6,  0 },
                { 6,  0 },                 { 6,  0 },
                { 6,  0 },                 { 6,  0 },
                { 6,  0 },                 { 6,  0 },
                { 6,  0 },                 { 6,  0 },
                { 6,  0 }, // 17

                { 8,  1 },                { 8,  1 },
                { 8,  1 },                { 8,  1 }, // 4

                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 },
                { 8,  0 },                { 8,  0 }, // 36

                { 9, 1 },                 { 9, 1 },
                { 9, 1 }, // 3

                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 },
                { 9, 0 },                { 9, 0 }, 
                { 9, 0 },                { 9, 0 }, 
                { 9, 0 }, // 39
            };


            double[] measurement = data.GetColumn(1);
            double[] prediction = data.GetColumn(0);

            var roc = new ReceiverOperatingCharacteristic(measurement, prediction);
            double[] cutpoints = { 5, 7, 9, double.PositiveInfinity };

            roc.Compute(cutpoints);

            Assert.AreEqual(32, roc.Positives);
            Assert.AreEqual(93, roc.Negatives);

            Assert.AreEqual(4, roc.Points.Count);
            var p1 = roc.Points[0];
            var p2 = roc.Points[1];
            var p3 = roc.Points[2];
            var p4 = roc.Points[3];

            Assert.AreEqual(18, p1.FalseNegatives);
            Assert.AreEqual(18 + 7, p2.FalseNegatives);
            Assert.AreEqual(18 + 7 + 4, p3.FalseNegatives);
            Assert.AreEqual(18 + 7 + 4 + 3, p4.FalseNegatives);

            Assert.AreEqual(1, p1.TrueNegatives);
            Assert.AreEqual(1 + 17, p2.TrueNegatives);
            Assert.AreEqual(1 + 17 + 36, p3.TrueNegatives);
            Assert.AreEqual(1 + 17 + 36 + 39, p4.TrueNegatives);


            double area = roc.Area;
            double error = roc.StandardError;

            // Area should be near 0.87
            Assert.AreEqual(0.87, area, 0.011);
            Assert.IsFalse(Double.IsNaN(area));

            // Assert.AreEqual(0.043781206163219656, error); // HanleyMcNeil
            Assert.AreEqual(0.04485087617325112, error); // DeLong estimate
        }