using System;

using MathNet.Numerics.LinearAlgebra;

​

public class Program

{

        static void Main(string[] args)

        {

            MainApplication();

        }

​

        static void MainApplication()

        {

            Console.WriteLine("-------------------------------------------------------");

            Console.WriteLine("-      Welcome to PCA - EigneValue Calculator         -");

            Console.WriteLine("-        Created by Omar Abahsain - 20110708          -");

            Console.WriteLine("-   ITCIS792 - Statistics Techniques - 8th Nov 2024   -");

            Console.WriteLine("-------------------------------------------------------");

​

            Console.WriteLine();

            Console.WriteLine("What would you like to do?");

            Console.WriteLine("1. Enter Own Data Points, calculate covaroience and eigenvalues");

            Console.WriteLine("2. Load Sample Data Points, calculate covarience and eigenvalues.");

            Console.WriteLine("3. Exit");

​

            Console.WriteLine();

            Console.Write("I want Choice: ");

​

            var input = Console.ReadLine();

            input = input.Trim();

​

            if (input == null)

            {

                Console.WriteLine("Please select a choice, 1 or 2 or 3...");

                Console.ReadLine();

                MainApplication();

                return;

            }

            int x = 0;

            Boolean isNumeric = int.TryParse(input, out x);

​

            if (!isNumeric)

            {

                Console.WriteLine("Invalid input, expected numeric value, 1 or 2 or 3...");

                Console.ReadLine();

                MainApplication();

                return;

            }

​

            if (x != 1 && x != 2 && x != 3)

            {

                Console.WriteLine("Invalid choice, 1 or 2 or 3...");

                Console.ReadLine();

                MainApplication();

                return;

            }

​

            switch (x)

            {

                case 1:

                    CustomMatrix();

                    break;

                case 2:

                    SampleMatrix();

                    break;

                case 3:

                    Console.WriteLine("Have a Good Day :)");

                    Environment.Exit(1);

                    break;

            }

        }

​

        static void SampleMatrix() {

            Console.WriteLine("-------------------------------");

            // Define your data points (rows are points, columns are dimensions)

            double[,] data = new double[,]

            {

            { 3, 5, 6 },

            { 8, 10, 30 },

            { 7, 20, 1 },

            { 36, 15, 6 },

            { 17, 2, 3 },

            { 18, 50, 32 }

            };

​

            Console.WriteLine("Data points (rows are points, columns are dimensions):");

            PrintMatrix(data);

​

            // Step 1: Calculate the Covariance Matrix

            Console.WriteLine("\nCalculating Covariance Matrix...");

            double[,] covarianceMatrix = MatrixOperations.CalculateCovarianceMatrix(data);

​

            // Print Covariance Matrix

            Console.WriteLine("\nCovariance Matrix:");

            PrintMatrix(covarianceMatrix);

​

            // Step 2: Calculate Eigenvalues and Eigenvectors

            Console.WriteLine("\nCalculating Eigenvalues and Eigenvectors...");

            var (eigenvalues, eigenvectors) = PCAHelper.CalculateEigen(covarianceMatrix);

​

            // Print Eigenvalues

            Console.WriteLine("\nEigenvalues:");

            foreach (var eigenvalue in eigenvalues)

            {

                Console.WriteLine(eigenvalue);

            }

​

            // Print Eigenvectors

            Console.WriteLine("\nEigenvectors:");

            PrintMatrix(eigenvectors);

​

            Console.WriteLine("\n-----------------------------------------");

            Console.WriteLine("Press Any Key to return back to Menu...");

            Console.ReadLine();

            MainApplication();

        }

​

        static void CustomMatrix()

        {

            int cols = 0; int rows = 0;

            dimensions:

            Console.WriteLine("-------------------------------");

            Console.WriteLine("How many dimensions are there in the data points?\n(ex: {3,4,5} means 3 dimensions) - Enter E to exit to Menu");

            var dimensions = Console.ReadLine();

            dimensions = dimensions.Trim();

​

            if (dimensions.ToLower() == "e") {

                MainApplication();

            }

​

            Boolean dimensionIsNumeric = int.TryParse(dimensions, out cols);

            if (dimensions == null || !dimensionIsNumeric)

            {

                Console.WriteLine("Invalid entry, numeric value expected");

                Console.ReadLine();

                goto dimensions;

            }

​

            points:

            Console.WriteLine("-------------------------------");

            Console.WriteLine("Dimension of "+dimensions+" has been set.");

            Console.WriteLine();

            Console.WriteLine("How many data points do you have? - Enter E to exit to Menu");

            var points = Console.ReadLine();

            points = points.Trim();

​

            if (points.ToLower() == "e")

            {

                MainApplication();

            }

​

            Boolean pointsIsNumeric = int.TryParse(points, out rows);

            if (points == null || !pointsIsNumeric)

            {

                Console.WriteLine("Invalid entry, numeric value expected");

                Console.ReadLine();

                goto points;

            }

​

            var Example = generateExample(cols);

​

            double[,] data = new double[rows, cols];

            for (int i = 0; i <= rows; i++)

            {

                entry:

                Console.WriteLine("-------------------------------");

                Console.WriteLine("Dimension of " + dimensions + " has been set.");

                Console.WriteLine("Expecting " + points + " to be entered.");

                Console.WriteLine("Single Data point Example: " + Example);

                Console.WriteLine("Note: Enter E to exit to Menu");

                Console.WriteLine("-------------------------------");

                if (i > 0)

                {

                    Console.WriteLine("Current Entries:");

                    PrintMatrixByRows(data, i);

                    Console.WriteLine("-------------------------------");

                }

                if (i == rows) {

                    Console.WriteLine();

                    Console.Write("Calculation will begin...");

                    goto calculation_start;

                }

                Console.WriteLine();

                Console.WriteLine("Enter data points number [" + (i+1) + " out of "+rows+"] saperated by a comma of dimension " + dimensions + ":");

                var DataPoint = Console.ReadLine();

                DataPoint = DataPoint.Trim();

​

                if (DataPoint.ToLower() == "e")

                {

                    MainApplication();

                }

​

                if (DataPoint == null)

                {

                    Console.WriteLine("Invalid data point, expected data point dimension to be " + dimensions + ", and as example ("+Example+"), received empty input");

                    Console.ReadLine();

                    goto entry;

                }

​

                var DataPointArray = DataPoint.Split(',');

                var DataPointLength = DataPointArray.Length;

                if (DataPointLength != cols) 

                {

                    Console.WriteLine("Invalid data point, expected data point dimension to be "+dimensions+", received "+ DataPoint);

                    Console.ReadLine();

                    goto entry;

                }

​

                if (!ValidateDataPoints(DataPointArray)) {

                    Console.WriteLine("Invalid data point, expected data point as example ("+Example+") and recieved "+DataPoint);

                    Console.ReadLine();

                    goto entry;

                }

​

                //Convert DataPoint and insert it into data

                // Convert DataPointArray to doubles and insert it into data matrix

                for (int j = 0; j < cols; j++)

                {

                    data[i, j] = double.Parse(DataPointArray[j]);

                }

​

            }

            calculation_start:

            Console.WriteLine("-------------------------------");

            Console.WriteLine("You have provided the following Data points (rows are points, columns are dimensions):");

            PrintMatrix(data);

​

            // Step 1: Calculate the Covariance Matrix

            Console.WriteLine("\nCalculating Covariance Matrix...");

            double[,] covarianceMatrix = MatrixOperations.CalculateCovarianceMatrix(data);

​

            // Print Covariance Matrix

            Console.WriteLine("\nCovariance Matrix:");

            PrintMatrix(covarianceMatrix);

​

            // Step 2: Calculate Eigenvalues and Eigenvectors

            Console.WriteLine("\nCalculating Eigenvalues and Eigenvectors...");

            var (eigenvalues, eigenvectors) = PCAHelper.CalculateEigen(covarianceMatrix);

​

            // Print Eigenvalues

            Console.WriteLine("\nEigenvalues:");

            foreach (var eigenvalue in eigenvalues)

            {

                Console.WriteLine(eigenvalue);

            }

​

            // Print Eigenvectors

            Console.WriteLine("\nEigenvectors:");

            PrintMatrix(eigenvectors);

​

            Console.WriteLine("\n-----------------------------------------");

            Console.WriteLine("Press Any Key to return back to Menu...");

            Console.ReadLine();

            MainApplication();

        }

​

        static String generateExample(int cols) {

            String example = "";

            Random random = new Random();

            for (int i = 0; i < cols; i++) {

                example += random.Next(1, 100);

                example += ",";

            }

            return example.Remove(example.Length - 1);

        }

​

        static Boolean ValidateDataPoints(String[] DataPoints) {

            Boolean valid = true;

            int x = 0;

            for (int i = 0; i < DataPoints.Length; i++) {

                valid = int.TryParse(DataPoints[i], out x);

                if (!valid) {

                    break;

                }

            }

            return valid;

        }

​

        static void PrintMatrix(double[,] matrix)

        {

            int rows = matrix.GetLength(0);

            int cols = matrix.GetLength(1);

​

            for (int i = 0; i < rows; i++)

            {

                for (int j = 0; j < cols; j++)

                {

                    Console.Write($"{matrix[i, j]:F2}\t");

                }

                Console.WriteLine();

            }

        }

​

        static void PrintMatrixByRows(double[,] matrix, int currentRow)

        {

            int rows = currentRow;

            int cols = matrix.GetLength(1);

​

            for (int i = 0; i < rows; i++)

            {

                for (int j = 0; j < cols; j++)

                {

                    Console.Write($"{matrix[i, j]:F2}\t");

                }

                Console.WriteLine();

            }

        }

​

        public static class MatrixOperations

        {

            public static double[,] CalculateCovarianceMatrix(double[,] data)

            {

                int numPoints = data.GetLength(0);

                int numDimensions = data.GetLength(1);

                double[,] covarianceMatrix = new double[numDimensions, numDimensions];

​

                // Calculate the mean of each dimension

                double[] mean = new double[numDimensions];

                for (int j = 0; j < numDimensions; j++)

                {

                    for (int i = 0; i < numPoints; i++)

                    {

                        mean[j] += data[i, j];

                    }

                    mean[j] /= numPoints;

                }

​

                // Calculate covariance

                for (int i = 0; i < numDimensions; i++)

                {

                    for (int j = 0; j < numDimensions; j++)

                    {

                        double sum = 0;

                        for (int k = 0; k < numPoints; k++)

                        {

                            sum += (data[k, i] - mean[i]) * (data[k, j] - mean[j]);

                        }

                        covarianceMatrix[i, j] = sum / (numPoints - 1);

                    }

                }

​

                return covarianceMatrix;

            }

        }   

        public static class PCAHelper

        {

            public static (double[] eigenvalues, double[,] eigenvectors) CalculateEigen(double[,] covarianceMatrix)

            {

                // Convert the covariance matrix to a MathNet matrix

                var matrix = Matrix<double>.Build.DenseOfArray(covarianceMatrix);

​

                // Calculate eigenvalues and eigenvectors

                var evd = matrix.Evd();

                var eigenvalues = evd.EigenValues.Real().ToArray();

                var eigenvectors = evd.EigenVectors.ToArray();

​

                return (eigenvalues, eigenvectors);

            }

        }

​

}