Пример #1
0
        public void CompleteDiameterTest()
        {
            // cluster is null
            {
                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var partition = Distance.CompleteDiameter((DoubleMatrix)null);
                },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "cluster");
            }

            // cluster is valid
            {
                var items         = IndexCollection.Range(0, 3);
                int numberOfItems = items.Count;
                var attributes    = IrisDataSet.GetAttributesAsDoubleMatrix()[items, ":"];

                var actual = Distance.CompleteDiameter(attributes);

                var expected = 0.6480741;

                Assert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy);
            }
        }
Пример #2
0
        public void EuclideanTest()
        {
            // cluster is null
            {
                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var partition = Distance.Euclidean((DoubleMatrix)null);
                },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "cluster");
            }

            // cluster is valid
            {
                var items         = IndexCollection.Range(0, 3);
                int numberOfItems = items.Count;
                var attributes    = IrisDataSet.GetAttributesAsDoubleMatrix()[items, ":"];

                var actual = Distance.Euclidean(attributes);

                var expected = DoubleMatrix.Dense(
                    numberOfItems,
                    numberOfItems,
                    new double[] {
                    0.0000000, 0.5385165, 0.5099020, 0.6480741,
                    0.5385165, 0.0000000, 0.3000000, 0.3316625,
                    0.5099020, 0.3000000, 0.0000000, 0.2449490,
                    0.6480741, 0.3316625, 0.2449490, 0.0000000
                },
                    StorageOrder.RowMajor);

                DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy);
            }
        }
Пример #3
0
        public void IndexPartitionDaviesBouldinTest()
        {
            // data is null
            {
                var target    = IrisDataSet.GetClassPredictions();
                var partition = IndexPartition.Create(target);

                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var actual = IndexPartition.DaviesBouldinIndex(null, partition);
                },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "data");
            }

            // partition is null
            {
                var data = IrisDataSet.GetAttributesAsDoubleMatrix();

                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var actual = IndexPartition.DaviesBouldinIndex(data, null);
                },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "partition");
            }

            // The first part contains an invalid index
            {
                var data      = IrisDataSet.GetAttributesAsDoubleMatrix();
                var target    = IrisDataSet.GetClassPredictions();
                var partition = IndexPartition.Create(target);

                partition[1][0] = 100000;

                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var actual = IndexPartition.DaviesBouldinIndex(data, partition);
                },
                    expectedType: typeof(ArgumentException),
                    expectedPartialMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_INP_PART_CONTAINS_INVALID_INDEX"),
                    expectedParameterName: "partition");
            }

            // The second part contains an invalid index
            {
                var data      = IrisDataSet.GetAttributesAsDoubleMatrix();
                var target    = IrisDataSet.GetClassPredictions();
                var partition = IndexPartition.Create(target);

                partition[2][0] = 100000;

                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var actual = IndexPartition.DaviesBouldinIndex(data, partition);
                },
                    expectedType: typeof(ArgumentException),
                    expectedPartialMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_INP_PART_CONTAINS_INVALID_INDEX"),
                    expectedParameterName: "partition");
            }

            // Valid input
            {
                var data      = IrisDataSet.GetAttributesAsDoubleMatrix();
                var target    = IrisDataSet.GetClassPredictions();
                var partition = IndexPartition.Create(target);

                var actual = IndexPartition.DaviesBouldinIndex(
                    data, partition);

                // The expected below was obtained in R as follows:
                //
                // library(clv)
                // data(iris)
                // iris.data < -iris[, 1:4]
                // # cluster data
                // agnes.mod < -agnes(iris.data) # create cluster tree
                // v.pred < - as.integer(cutree(agnes.mod, 5)) # "cut" the tree
                // intraclust = c("complete", "average", "centroid")
                // interclust = c("single", "complete", "average", "centroid", "aveToCent", "hausdorff")
                // cls.scatt < -cls.scatt.data(iris.data, v.pred, dist = "euclidean")
                // davies1 <- clv.Davies.Bouldin(cls.scatt, intraclust, interclust)

                // This is davies1[4,3], corresponding to
                // intra = "centroid",
                // inter = "centroid".
                double expected = 0.685838025870551;

                Assert.AreEqual(expected, actual, 1e-3);
            }
        }
Пример #4
0
        public void IndexPartitionMinimumCentroidTest()
        {
            // data is null
            {
                var target    = IrisDataSet.GetClassPredictions();
                var partition = IndexPartition.Create(target);

                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var actual = IndexPartition.MinimumCentroidLinkage(null, partition);
                },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "data");
            }

            // partition is null
            {
                var data = IrisDataSet.GetAttributesAsDoubleMatrix();

                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var actual = IndexPartition.MinimumCentroidLinkage(data, null);
                },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "partition");
            }

            // The first part contains an invalid index
            {
                var data      = IrisDataSet.GetAttributesAsDoubleMatrix();
                var target    = IrisDataSet.GetClassPredictions();
                var partition = IndexPartition.Create(target);

                partition[1][0] = 100000;

                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var actual = IndexPartition.MinimumCentroidLinkage(data, partition);
                },
                    expectedType: typeof(ArgumentException),
                    expectedPartialMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_INP_PART_CONTAINS_INVALID_INDEX"),
                    expectedParameterName: "partition");
            }

            // The second part contains an invalid index
            {
                var data      = IrisDataSet.GetAttributesAsDoubleMatrix();
                var target    = IrisDataSet.GetClassPredictions();
                var partition = IndexPartition.Create(target);

                partition[2][0] = 100000;

                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    var actual = IndexPartition.MinimumCentroidLinkage(data, partition);
                },
                    expectedType: typeof(ArgumentException),
                    expectedPartialMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_INP_PART_CONTAINS_INVALID_INDEX"),
                    expectedParameterName: "partition");
            }

            // Valid input
            {
                var data      = IrisDataSet.GetAttributesAsDoubleMatrix();
                var target    = IrisDataSet.GetClassPredictions();
                var partition = IndexPartition.Create(target);

                var actual = IndexPartition.MinimumCentroidLinkage(
                    data, partition);

                List <double> linkages = new();
                foreach (var leftId in partition.Identifiers)
                {
                    var leftPart = partition[leftId];
                    var left     = data[leftPart, ":"];
                    foreach (var rightId in partition.Identifiers)
                    {
                        if (rightId != leftId)
                        {
                            var rightPart = partition[rightId];
                            var right     = data[rightPart, ":"];
                            linkages.Add(Distance.CentroidLinkage(left, right));
                        }
                    }
                }

                double expected = linkages.Min();

                Assert.AreEqual(expected, actual, 1e-4);
            }
        }
Пример #5
0
        public void AverageLinkageTest()
        {
            // left is null
            {
                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    Distance.AverageLinkage(
                        left: (DoubleMatrix)null,
                        right: DoubleMatrix.Identity(2));
                },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "left");
            }

            // right is null
            {
                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    Distance.AverageLinkage(
                        left: DoubleMatrix.Identity(2),
                        right: (DoubleMatrix)null);
                },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "right");
            }

            // right and left have not the same number of columns
            {
                ArgumentExceptionAssert.Throw(
                    () =>
                {
                    Distance.AverageLinkage(
                        left: DoubleMatrix.Identity(2),
                        right: DoubleMatrix.Identity(3));
                },
                    expectedType: typeof(ArgumentException),
                    expectedPartialMessage: string.Format(
                        ImplementationServices.GetResourceString(
                            "STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS"),
                        "left"),
                    expectedParameterName: "right");
            }

            // input is valid
            {
                var items         = IndexCollection.Range(0, 3);
                int numberOfItems = items.Count;
                var attributes    = IrisDataSet.GetAttributesAsDoubleMatrix();
                var classes       = IrisDataSet.GetClasses();
                var partition     = IndexPartition.Create(classes);
                var left          = attributes[partition["virginica"], ":"][items, ":"];
                var right         = attributes[partition["setosa"], ":"][items, ":"];

                var actual = Distance.AverageLinkage(left, right);

                var expected = 4.932325;

                Assert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy);
            }
        }