C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using Accord.MachineLearning;
using Accord.Math.Distances;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;



using Xunit;

using Accord.MachineLearning;
using Accord.Math.Distances;
using System;
using System.Collections.Generic;
using System.Linq;

public class KMeansClustering
{
    public static int[] ClusterWithCapacity(double[][] data, int k, int capacity)
    {
        // --- Input Validation ---
        if (data == null || data.Length == 0)
        {
            throw new ArgumentException("Input data cannot be null or empty.", nameof(data));
        }

        if (k <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(k), "The number of clusters (k) must be greater than 0.");
        }

        if (capacity <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(capacity), "The capacity must be greater than 0.");
        }

        if (data.Length < k)
        {
            throw new ArgumentException("The number of data points must be greater than or equal to the number of clusters.", nameof(data));
        }
        if (data.Any(row => row == null || row.Length == 0))
        {
            throw new ArgumentException("Data rows cannot be null or empty.", nameof(data));
        }
        //All rows must have the same length.
        int firstRowLength = data[0].Length;
        if (data.Any(row => row.Length != firstRowLength))
        {
             throw new ArgumentException("All data rows must have the same length.", nameof(data));
        }
      
        // --- Initialization ---
        KMeans kmeans = new KMeans(k);
        //No need to specify a distance, since default is Euclidean, also default is KMeans++ initialization.

        // --- Initial Clustering (without capacity constraints) ---
        KMeansClusterCollection clusters = kmeans.Learn(data);
        int[] initialLabels = clusters.Decide(data);  // Get initial cluster assignments

        // --- Capacity Enforcement ---
        int[] clusterAssignments = new int[data.Length];
        int[] clusterCounts = new int[k];

        // Keep track of unassigned data points
        List<Tuple<int, double[]>> unassignedData = new List<Tuple<int, double[]>>();

        // Assign points based on initial clustering, respecting capacity
        for (int i = 0; i < data.Length; i++)
        {
            int clusterIndex = initialLabels[i];

            if (clusterCounts[clusterIndex] < capacity)
            {
                clusterAssignments[i] = clusterIndex;
                clusterCounts[clusterIndex]++;
            }
            else
            {
                unassignedData.Add(new Tuple<int, double[]>(i, data[i]));
            }
        }

        // --- Handle Unassigned Data ---
        // Assign remaining data points to the nearest cluster with available capacity
        foreach (var dataPoint in unassignedData)
        {
            int nearestCluster = -1;
            double minDistance = double.MaxValue;

            for (int j = 0; j < k; j++)
            {
                if (clusterCounts[j] < capacity)
                {
                    double distance = new Euclidean().Distance(dataPoint.Item2, kmeans.Centroids[j]);
                    if (distance < minDistance)
                    {
                        minDistance = distance;
                        nearestCluster = j;
                    }
                }
            }

            // If a cluster with capacity is found, assign the point
            if (nearestCluster != -1)
            {
                clusterAssignments[dataPoint.Item1] = nearestCluster;
                clusterCounts[nearestCluster]++;
            }
            else //All clusters reached their capacity limit
            {
                //Find the closest cluster to assign the point to.
                nearestCluster = -1;
                minDistance = double.MaxValue;

                for (int j = 0; j < k; j++)
                {
                     double distance = new Euclidean().Distance(dataPoint.Item2, kmeans.Centroids[j]);
                     if(distance < minDistance)
                     {
                         minDistance = distance;
                         nearestCluster = j;
                     }
                }
                clusterAssignments[dataPoint.Item1] = nearestCluster; //Assign to nearest cluster.

            }
        }

        return clusterAssignments;
    }
	
	static void Main(string[] args)
    {
        // Get the test class type
        Type testClassType = typeof(KMeansClusteringTests);

        // Create an instance of the test class
        object testInstance = Activator.CreateInstance(testClassType);

        // Get all methods with the [Fact] attribute (unit tests)
        MethodInfo[] testMethods = testClassType
            .GetMethods()
            .Where(m => m.GetCustomAttributes(typeof(FactAttribute), false).Any())
            .ToArray();

        int passed = 0, failed = 0;

        Console.WriteLine("Running xUnit tests using reflection...\n");

        foreach (MethodInfo method in testMethods)
        {
            try
            {
                // Invoke the test method
                method.Invoke(testInstance, null);
                Console.WriteLine($"✅ {method.Name} PASSED");
                passed++;
            }
            catch (TargetInvocationException ex)
            {
                Console.WriteLine($"❌ {method.Name} FAILED: {ex.InnerException?.Message}");
                failed++;
            }
        }

        Console.WriteLine($"\nTest Results: {passed} Passed, {failed} Failed.");
    }
}


public class KMeansClusteringTests
{
    [Fact]
    public void ClusterWithCapacity_ValidInput_ReturnsCorrectAssignments()
    {
        double[][] data = new double[][]
        {
            new double[] { 25, 50000 },
            new double[] { 30, 60000 },
            new double[] { 28, 55000 },
            new double[] { 35, 70000 },
            new double[] { 22, 45000 },
            new double[] { 31, 62000 }
        };
        int k = 2;
        int capacity = 3;

        int[] assignments = KMeansClustering.ClusterWithCapacity(data, k, capacity);

        Assert.Equal(data.Length, assignments.Length);
        //Further checks (within capacity, correct clustering) could be added,
        // but are complex to validate *exactly* without replicating the logic.  We check counts below.

        // Basic count check (more robust than individual assignments):
        int countCluster0 = 0;
        int countCluster1 = 0;
        for (int i = 0; i < assignments.Length; i++)
        {
            if (assignments[i] == 0) countCluster0++;
            if (assignments[i] == 1) countCluster1++;
        }

        Assert.True(countCluster0 <= capacity);
        Assert.True(countCluster1 <= capacity);
    }
    
    [Fact]
    public void ClusterWithCapacity_ValidInput_ReturnsCorrectAssignments_DifferentKandCapacity()
    {
        //Arrange different k
        double[][] data = new double[][]
        {
            new double[] { 25, 50000 },
            new double[] { 30, 60000 },
            new double[] { 28, 55000 },
            new double[] { 35, 70000 },
            new double[] { 22, 45000 },
            new double[] { 31, 62000 },
            new double[] { 32, 63000 } //Additional data
        };
        int k = 3; //Change to 3 clusters.
        int capacity = 3;

        // Act
        int[] assignments = KMeansClustering.ClusterWithCapacity(data, k, capacity);

        // Assert
        Assert.Equal(data.Length, assignments.Length);

        int countCluster0 = 0;
        int countCluster1 = 0;
        int countCluster2 = 0;

        for (int i = 0; i < assignments.Length; i++)
        {
            if (assignments[i] == 0) countCluster0++;
            if (assignments[i] == 1) countCluster1++;
            if (assignments[i] == 2) countCluster2++;
        }
        //Assert clusters are within capacity
        Assert.True(countCluster0 <= capacity);
        Assert.True(countCluster1 <= capacity);
        Assert.True(countCluster2 <= capacity);

        //Arrange different capacity.
        k = 2; //reset k.
        capacity = 2;

        // Act
        assignments = KMeansClustering.ClusterWithCapacity(data, k, capacity);

        // Assert
        Assert.Equal(data.Length, assignments.Length);

        countCluster0 = 0;
        countCluster1 = 0;

        for (int i = 0; i < assignments.Length; i++)
        {
            if (assignments[i] == 0) countCluster0++;
            if (assignments[i] == 1) countCluster1++;
        }
        //Assert clusters are within capacity, they could exceed it in this scenario.
        Assert.True(countCluster0 > 0);
        Assert.True(countCluster1 > 0);
    }

    [Fact]
    public void ClusterWithCapacity_NullData_ThrowsArgumentException()
    {
        double[][] data = null;
        int k = 2;
        int capacity = 3;

        Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }

    [Fact]
    public void ClusterWithCapacity_EmptyData_ThrowsArgumentException()
    {
        double[][] data = new double[][] { };
        int k = 2;
        int capacity = 3;

        Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }

    [Fact]
    public void ClusterWithCapacity_InvalidK_ThrowsArgumentOutOfRangeException()
    {
        double[][] data = new double[][] { new double[] { 1, 2 } };
        int k = 0;  // Invalid K
        int capacity = 3;

        Assert.Throws<ArgumentOutOfRangeException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));

        k = -1; //Another invalid K.
        Assert.Throws<ArgumentOutOfRangeException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));

    }

    [Fact]
    public void ClusterWithCapacity_InvalidCapacity_ThrowsArgumentOutOfRangeException()
    {
        double[][] data = new double[][] { new double[] { 1, 2 } };
        int k = 2;
        int capacity = 0; //Invalid Capacity

        Assert.Throws<ArgumentOutOfRangeException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));

        capacity = -1; //Another Invalid Capacity
        Assert.Throws<ArgumentOutOfRangeException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }

    [Fact]
    public void ClusterWithCapacity_FewerDataPointsThanClusters_ThrowsArgumentException()
    {
        double[][] data = new double[][] { new double[] { 1, 2 } };
        int k = 3; // More clusters than data points
        int capacity = 3;

        Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
    [Fact]
    public void ClusterWithCapacity_NullDataRow_ThrowsArgumentException()
    {
         double[][] data = new double[][] { new double[] { 1, 2 }, null };
         int k = 2;
         int capacity = 3;
         Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
    [Fact]
    public void ClusterWithCapacity_EmptyDataRow_ThrowsArgumentException()
    {
         double[][] data = new double[][] { new double[] { 1, 2 }, new double[] {} };
         int k = 2;
         int capacity = 3;
         Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
     [Fact]
    public void ClusterWithCapacity_DifferentDataRowLength_ThrowsArgumentException()
    {
         double[][] data = new double[][] { new double[] { 1, 2 }, new double[] {1} };
         int k = 2;
         int capacity = 3;
         Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
    [Fact]
    public void ClusterWithCapacity_AllClustersFull_AssignsToNearest()
    {
        double[][] data = new double[][]
       {
            new double[] { 1, 1 },
            new double[] { 1.1, 1.1 },
            new double[] { 2, 2 },
            new double[] { 2.1, 2.1 },
            new double[] { 5, 5 } // This point will need to be assigned to the *nearest* cluster
       };

        int k = 2;
        int capacity = 2; // All clusters will be full before the last point

        int[] assignments = KMeansClustering.ClusterWithCapacity(data, k, capacity);

        Assert.Equal(data.Length, assignments.Length);

        // Check the assignment of the last point (index 4)
        // It should be assigned to either cluster 0 or 1, depending on which centroid is closer.

        //Manually calculate distances to centroids.  This is brittle if centroid calculation changes.
        Euclidean distance = new Euclidean();
        double distToCentroid0;
        double distToCentroid1;
        int count0 = 0;
        int count1 = 0;

        double[] centroid0 = new double[2];
        double[] centroid1 = new double[2];
        //Calculate centroids based on assignments (excluding the last point)
        for(int i = 0; i < data.Length -1; i++)
        {
            if (assignments[i] == 0)
            {
                centroid0[0] += data[i][0];
                centroid0[1] += data[i][1];
                count0++;
            }
            else
            {
                centroid1[0] += data[i][0];
                centroid1[1] += data[i][1];
                count1++;
            }
        }

        centroid0[0] /= count0;
        centroid0[1] /= count0;
        centroid1[0] /= count1;
        centroid1[1] /= count1;

        distToCentroid0 = distance.Distance(data[4], centroid0);
        distToCentroid1 = distance.Distance(data[4], centroid1);

        if(distToCentroid0 <= distToCentroid1)
        {
            Assert.Equal(0, assignments[4]);
        }
        else
        {
             Assert.Equal(1, assignments[4]);
        }
    }
}

​x
 
using Accord.MachineLearning;
using Accord.Math.Distances;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
​
​
​
using Xunit;
​
using Accord.MachineLearning;
using Accord.Math.Distances;
using System;
using System.Collections.Generic;
using System.Linq;
​
public class KMeansClustering
{
    public static int[] ClusterWithCapacity(double[][] data, int k, int capacity)
    {
        // --- Input Validation ---
        if (data == null || data.Length == 0)
        {
            throw new ArgumentException("Input data cannot be null or empty.", nameof(data));
        }
​
        if (k <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(k), "The number of clusters (k) must be greater than 0.");
        }
​
        if (capacity <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(capacity), "The capacity must be greater than 0.");
        }
​
        if (data.Length < k)
        {
            throw new ArgumentException("The number of data points must be greater than or equal to the number of clusters.", nameof(data));
        }
        if (data.Any(row => row == null || row.Length == 0))
        {
            throw new ArgumentException("Data rows cannot be null or empty.", nameof(data));
        }
        //All rows must have the same length.
        int firstRowLength = data[0].Length;
        if (data.Any(row => row.Length != firstRowLength))
        {
             throw new ArgumentException("All data rows must have the same length.", nameof(data));
        }
      
        // --- Initialization ---
        KMeans kmeans = new KMeans(k);
        //No need to specify a distance, since default is Euclidean, also default is KMeans++ initialization.
​
        // --- Initial Clustering (without capacity constraints) ---
        KMeansClusterCollection clusters = kmeans.Learn(data);
        int[] initialLabels = clusters.Decide(data);  // Get initial cluster assignments
​
        // --- Capacity Enforcement ---
        int[] clusterAssignments = new int[data.Length];
        int[] clusterCounts = new int[k];
​
        // Keep track of unassigned data points
        List<Tuple<int, double[]>> unassignedData = new List<Tuple<int, double[]>>();
​
        // Assign points based on initial clustering, respecting capacity
        for (int i = 0; i < data.Length; i++)
        {
            int clusterIndex = initialLabels[i];
​
            if (clusterCounts[clusterIndex] < capacity)
            {
                clusterAssignments[i] = clusterIndex;
                clusterCounts[clusterIndex]++;
            }
            else
            {
                unassignedData.Add(new Tuple<int, double[]>(i, data[i]));
            }
        }
​
        // --- Handle Unassigned Data ---
        // Assign remaining data points to the nearest cluster with available capacity
        foreach (var dataPoint in unassignedData)
        {
            int nearestCluster = -1;
            double minDistance = double.MaxValue;
​
            for (int j = 0; j < k; j++)
            {
                if (clusterCounts[j] < capacity)
                {
                    double distance = new Euclidean().Distance(dataPoint.Item2, kmeans.Centroids[j]);
                    if (distance < minDistance)
                    {
                        minDistance = distance;
                        nearestCluster = j;
                    }
                }
            }
​
            // If a cluster with capacity is found, assign the point
            if (nearestCluster != -1)
            {
                clusterAssignments[dataPoint.Item1] = nearestCluster;
                clusterCounts[nearestCluster]++;
            }
            else //All clusters reached their capacity limit
            {
                //Find the closest cluster to assign the point to.
                nearestCluster = -1;
                minDistance = double.MaxValue;
​
                for (int j = 0; j < k; j++)
                {
                     double distance = new Euclidean().Distance(dataPoint.Item2, kmeans.Centroids[j]);
                     if(distance < minDistance)
                     {
                         minDistance = distance;
                         nearestCluster = j;
                     }
                }
                clusterAssignments[dataPoint.Item1] = nearestCluster; //Assign to nearest cluster.
​
            }
        }
​
        return clusterAssignments;
    }
    
    static void Main(string[] args)
    {
        // Get the test class type
        Type testClassType = typeof(KMeansClusteringTests);
​
        // Create an instance of the test class
        object testInstance = Activator.CreateInstance(testClassType);
​
        // Get all methods with the [Fact] attribute (unit tests)
        MethodInfo[] testMethods = testClassType
            .GetMethods()
            .Where(m => m.GetCustomAttributes(typeof(FactAttribute), false).Any())
            .ToArray();
​
        int passed = 0, failed = 0;
​
        Console.WriteLine("Running xUnit tests using reflection...\n");
​
        foreach (MethodInfo method in testMethods)
        {
            try
            {
                // Invoke the test method
                method.Invoke(testInstance, null);
                Console.WriteLine($"✅ {method.Name} PASSED");
                passed++;
            }
            catch (TargetInvocationException ex)
            {
                Console.WriteLine($"❌ {method.Name} FAILED: {ex.InnerException?.Message}");
                failed++;
            }
        }
​
        Console.WriteLine($"\nTest Results: {passed} Passed, {failed} Failed.");
    }
}
​
​
public class KMeansClusteringTests
{
    [Fact]
    public void ClusterWithCapacity_ValidInput_ReturnsCorrectAssignments()
    {
        double[][] data = new double[][]
        {
            new double[] { 25, 50000 },
            new double[] { 30, 60000 },
            new double[] { 28, 55000 },
            new double[] { 35, 70000 },
            new double[] { 22, 45000 },
            new double[] { 31, 62000 }
        };
        int k = 2;
        int capacity = 3;
​
        int[] assignments = KMeansClustering.ClusterWithCapacity(data, k, capacity);
​
        Assert.Equal(data.Length, assignments.Length);
        //Further checks (within capacity, correct clustering) could be added,
        // but are complex to validate *exactly* without replicating the logic.  We check counts below.
​
        // Basic count check (more robust than individual assignments):
        int countCluster0 = 0;
        int countCluster1 = 0;
        for (int i = 0; i < assignments.Length; i++)
        {
            if (assignments[i] == 0) countCluster0++;
            if (assignments[i] == 1) countCluster1++;
        }
​
        Assert.True(countCluster0 <= capacity);
        Assert.True(countCluster1 <= capacity);
    }
    
    [Fact]
    public void ClusterWithCapacity_ValidInput_ReturnsCorrectAssignments_DifferentKandCapacity()
    {
        //Arrange different k
        double[][] data = new double[][]
        {
            new double[] { 25, 50000 },
            new double[] { 30, 60000 },
            new double[] { 28, 55000 },
            new double[] { 35, 70000 },
            new double[] { 22, 45000 },
            new double[] { 31, 62000 },
            new double[] { 32, 63000 } //Additional data
        };
        int k = 3; //Change to 3 clusters.
        int capacity = 3;
​
        // Act
        int[] assignments = KMeansClustering.ClusterWithCapacity(data, k, capacity);
​
        // Assert
        Assert.Equal(data.Length, assignments.Length);
​
        int countCluster0 = 0;
        int countCluster1 = 0;
        int countCluster2 = 0;
​
        for (int i = 0; i < assignments.Length; i++)
        {
            if (assignments[i] == 0) countCluster0++;
            if (assignments[i] == 1) countCluster1++;
            if (assignments[i] == 2) countCluster2++;
        }
        //Assert clusters are within capacity
        Assert.True(countCluster0 <= capacity);
        Assert.True(countCluster1 <= capacity);
        Assert.True(countCluster2 <= capacity);
​
        //Arrange different capacity.
        k = 2; //reset k.
        capacity = 2;
​
        // Act
        assignments = KMeansClustering.ClusterWithCapacity(data, k, capacity);
​
        // Assert
        Assert.Equal(data.Length, assignments.Length);
​
        countCluster0 = 0;
        countCluster1 = 0;
​
        for (int i = 0; i < assignments.Length; i++)
        {
            if (assignments[i] == 0) countCluster0++;
            if (assignments[i] == 1) countCluster1++;
        }
        //Assert clusters are within capacity, they could exceed it in this scenario.
        Assert.True(countCluster0 > 0);
        Assert.True(countCluster1 > 0);
    }
​
    [Fact]
    public void ClusterWithCapacity_NullData_ThrowsArgumentException()
    {
        double[][] data = null;
        int k = 2;
        int capacity = 3;
​
        Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
​
    [Fact]
    public void ClusterWithCapacity_EmptyData_ThrowsArgumentException()
    {
        double[][] data = new double[][] { };
        int k = 2;
        int capacity = 3;
​
        Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
​
    [Fact]
    public void ClusterWithCapacity_InvalidK_ThrowsArgumentOutOfRangeException()
    {
        double[][] data = new double[][] { new double[] { 1, 2 } };
        int k = 0;  // Invalid K
        int capacity = 3;
​
        Assert.Throws<ArgumentOutOfRangeException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
​
        k = -1; //Another invalid K.
        Assert.Throws<ArgumentOutOfRangeException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
​
    }
​
    [Fact]
    public void ClusterWithCapacity_InvalidCapacity_ThrowsArgumentOutOfRangeException()
    {
        double[][] data = new double[][] { new double[] { 1, 2 } };
        int k = 2;
        int capacity = 0; //Invalid Capacity
​
        Assert.Throws<ArgumentOutOfRangeException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
​
        capacity = -1; //Another Invalid Capacity
        Assert.Throws<ArgumentOutOfRangeException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
​
    [Fact]
    public void ClusterWithCapacity_FewerDataPointsThanClusters_ThrowsArgumentException()
    {
        double[][] data = new double[][] { new double[] { 1, 2 } };
        int k = 3; // More clusters than data points
        int capacity = 3;
​
        Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
    [Fact]
    public void ClusterWithCapacity_NullDataRow_ThrowsArgumentException()
    {
         double[][] data = new double[][] { new double[] { 1, 2 }, null };
         int k = 2;
         int capacity = 3;
         Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
    [Fact]
    public void ClusterWithCapacity_EmptyDataRow_ThrowsArgumentException()
    {
         double[][] data = new double[][] { new double[] { 1, 2 }, new double[] {} };
         int k = 2;
         int capacity = 3;
         Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
     [Fact]
    public void ClusterWithCapacity_DifferentDataRowLength_ThrowsArgumentException()
    {
         double[][] data = new double[][] { new double[] { 1, 2 }, new double[] {1} };
         int k = 2;
         int capacity = 3;
         Assert.Throws<ArgumentException>(() => KMeansClustering.ClusterWithCapacity(data, k, capacity));
    }
    [Fact]
    public void ClusterWithCapacity_AllClustersFull_AssignsToNearest()
    {
        double[][] data = new double[][]
       {
            new double[] { 1, 1 },
            new double[] { 1.1, 1.1 },
            new double[] { 2, 2 },
            new double[] { 2.1, 2.1 },
            new double[] { 5, 5 } // This point will need to be assigned to the *nearest* cluster
       };
​
        int k = 2;
        int capacity = 2; // All clusters will be full before the last point
​
        int[] assignments = KMeansClustering.ClusterWithCapacity(data, k, capacity);
​
        Assert.Equal(data.Length, assignments.Length);
​
        // Check the assignment of the last point (index 4)
        // It should be assigned to either cluster 0 or 1, depending on which centroid is closer.
​
        //Manually calculate distances to centroids.  This is brittle if centroid calculation changes.
        Euclidean distance = new Euclidean();
        double distToCentroid0;
        double distToCentroid1;
        int count0 = 0;
        int count1 = 0;
​
        double[] centroid0 = new double[2];
        double[] centroid1 = new double[2];
        //Calculate centroids based on assignments (excluding the last point)
        for(int i = 0; i < data.Length -1; i++)
        {
            if (assignments[i] == 0)
            {
                centroid0[0] += data[i][0];
                centroid0[1] += data[i][1];
                count0++;
            }
            else
            {
                centroid1[0] += data[i][0];
                centroid1[1] += data[i][1];
                count1++;
            }
        }
​
        centroid0[0] /= count0;
        centroid0[1] /= count0;
        centroid1[0] /= count1;
        centroid1[1] /= count1;
​
        distToCentroid0 = distance.Distance(data[4], centroid0);
        distToCentroid1 = distance.Distance(data[4], centroid1);
​
        if(distToCentroid0 <= distToCentroid1)
        {
            Assert.Equal(0, assignments[4]);
        }
        else
        {
             Assert.Equal(1, assignments[4]);
        }
    }
}

View IL Code