Implementing a vector class in C# is pretty easy.

The vector is stored as an array within the class. The constructor can either set this array directly, or initialises it to a particular size.

The Zero() function sets the entire vector to 0.

The Abs() function calculates the absolute value of the vector, which is the square root of the sum of the squares of the components of the vector.

The Dot() function returns the dot product of the vector, with another vector. The dot product is the sum of the products of each component in the vectors.

The Scale() function scales the vector by the scaling factor supplied.

The + and - operators are overloaded to make it easy to add and subtract vectors.

Each component of first vector is added (or subtracted) to the equivalent component of the second vector, and then the resulting vector is returned.

namespace MathLib
{
    public class Vector
    {
        public double[] vectorArray;
        public int Dimension;

        public Vector(double[] Values)
        {
            vectorArray = Values;
            Dimension = vectorArray.GetLength(0);
        }

        public Vector(int dim)
        {
            vectorArray = new double[dim];
            Dimension = dim;
            Zero();
        }

        public void Zero()
        {
            for(int i = 0; i < Dimension; i++)
            {
                vectorArray[i] = 0;
            }
        }

        public double Abs()
        {
            double abs = 0;

            for (int i = 0; i < Dimension; i++)
            {
                abs += vectorArray[i] * vectorArray[i];
            }
            return Math.Sqrt(abs);
        }

        public double Dot(Vector vector)
        {
            if (vector.Dimension != Dimension)
            {
                return 0;
            }
            double dotProd = 0;
            for (int i = 0; i < Dimension; i++)
            {
                dotProd += vectorArray[i] * vector.vectorArray[i];
            }
            return dotProd;
        }

        public Vector Scale(double factor)
        {
            double[] values = new double[Dimension];

            for (int i = 0; i < Dimension; i++)
            {
                values[i] = vectorArray[i] * factor;
            }
            return new Vector(values);
        }

        public override string ToString()
        {
            string str = "";
            for (int i = 0; i < Dimension; i++)
            {
                if (i != 0)
                {
                    str += ", ";
                }
                str += vectorArray[i];
            }
            return "(" + str + ")";
        }

        public static Vector operator +(Vector left, Vector right)
        {
            if (left.Dimension != right.Dimension)
            {
                return left;
            }
            double[] values = new double[left.Dimension];

            for (int i = 0; i < left.Dimension; i++)
            {
                values[i] = left.vectorArray[i] + right.vectorArray[i];
            }
            return (new Vector(values));
        }

        public static Vector operator -(Vector left, Vector right)
        {
            if (left.Dimension != right.Dimension)
            {
                return left;
            }
            double[] values = new double[left.Dimension];

            for (int i = 0; i < left.Dimension; i++)
            {
                values[i] = left.vectorArray[i] - right.vectorArray[i];
            }
            return (new Vector(values));
        }

    }
}

Related posts:

1. Matrices in C# Matrices are a very useful thing in computer programming –...
2. Complex numbers in C# Complex numbers are a vital part of many mathematical calculations,...
3. Finding the bearing between two GPS coordinates Don’t you think it would be really great to be...

Related posts brought to you by Yet Another Related Posts Plugin.

I am not going to go into major detail over what a matrix is – wikipedia can tell you that much better than I can – so will focus mainly on how to implement one in C#.

Essentially, a matrix is a 2-dimensional array of numbers, often representing a set of equations. The number of columns and rows is flexible.

Using the Matrix class below, the constructor can either take an x and y value or an array to determine how big to make the internal array for the matrix.

The Zero() function sets all entries in the matrix to zero by looping through the entire array.

The SetIdentity() function makes the matrix an identity matrix, which means that all the values are 0, except for the values along the diagonal from top left to bottom right being set to 1.

The Transpose function transforms the columns of the matrix into the rows, and vice versa.

The Scale function multiplies each value in the matrix by a scaling factor.

The determinant of an array is found by adding all the products of the entries of each diagonal sloping in a right direction, and subtracting the products of the entries of each diagonal sloping in a opposite direction. This is done with the Determinant function

The Trace function returns the sum of the main diagonal of the matrix.

The matrix class has also got a few overloaded operators, to make handling matrices easier.

The + operator is overloaded so that when passed two matrices, each value in the one matrix is added to the equivalent value in the second matrix. Both matrices need to be the same size for this to work.

A second overload for the + operator takes a scalar value and adds it to the matrix, which just adds that value to each value in the matrix.

The - operator performs identically to the + operator, except that it subtracts instead of adds the matrices.

The * operator multiplies the two matrices together, which is a little more involved than addition.

namespace MathLib
{
    public class Matrix
    {
        public double[,] val;
        public int Cols;
        public int Rows;

        public Matrix(int X, int Y)
        {
            Cols = X;
            Rows = Y;
            val = new double[Rows, Cols];
            Zero();
        }

        public Matrix(double[,] array)
        {
            val = array;
            Cols = val.GetLength(1);
            Rows = val.GetLength(0);
        }

        public void Zero()
        {
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Cols; j++)
                {
                    val[i, j] = 0;
                }
            }
        }
        public void SetIdentity()
        {
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Cols; j++)
                {
                    if (i == j)
                    {
                        val[i, j] = 1;
                    }
                    else
                    {
                        val[i, j] = 0;
                    }
                }
            }
        }
        public Matrix Transpose()
        {
            double[,] values = new double[Cols, Rows];
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Cols; j++)
                {
                    values[j, i] = val[i, j];
                }
            }
            return new Matrix(values);
        }

        public Matrix Scale(double factor)
        {
            double[,] values = new double[Rows, Cols];
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Cols; j++)
                {
                    values[i, j] = factor * val[i, j];
                }
            }
            return new Matrix(values);
        }

        public double Determinant()
        {
            double det = 0;
            int colIndex = 0;
            double dval = 1;
            int k;
            for (int i = 0; i < Cols; i++)
            {
                k = 0;
                dval = 1;
                for (int j = 0; j < Cols; j++)
                {
                    colIndex = (i + j) % 3;
                    dval *= val[colIndex, k];
                    k++;
                }
                det += dval;
            }
            for (int i = 0; i < Cols; i++)
            {
                k = 0;
                dval = 1;
                for (int j = Cols-1; j >= 0; j--)
                {
                    colIndex = (i + j) % 3;
                    val *= dval[colIndex, k];
                    k++;
                }
                det -= dval;
            }

            return det;
        }
        public double Trace()
        {
            if (Rows != Cols)
            {
                return 0;
            }
            double trace = 0;
            for (int i = 0; i < Rows; i++)
            {

               trace += val[i, i];
            }
            return trace;
        }

        public override string ToString()
        {
            string str = "";
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Cols; j++)
                {
                    str += val[i, j].ToString() + ",";
                }
                str += Environment.NewLine;
            }
            return str;
        }

        public static Matrix operator +(Matrix left, Matrix right)
        {
            if ((left.Cols != right.Cols) || (left.Rows != right.Rows))
            {
                return left;
            }
            double[,] values = new double[left.Rows, left.Cols];

            for (int i = 0; i < left.Rows; i++)
            {
                for (int j = 0; j < left.Cols; j++)
                {
                    values[i,j] = left.val[i,j] + right.val[i,j];
                }
            }
            return (new Matrix(values));
        }

        public static Matrix operator +(double left, Matrix right)
        {
            double[,] values = new double[right.Rows, right.Cols];

            for (int i = 0; i < right.Rows; i++)
            {
                for (int j = 0; j < right.Cols; j++)
                {
                    values[i, j] = left + right.val[i, j];
                }
            }
            return (new Matrix(values));
        }

        public static Matrix operator -(Matrix left, Matrix right)
        {
            if ((left.Cols != right.Cols) || (left.Rows != right.Rows))
            {
                return left;
            }
            double[,] values = new double[left.Cols, left.Rows];

            for (int i = 0; i < left.Rows; i++)
            {
                for (int j = 0; j < left.Cols; j++)
                {
                    values[i, j] = left.val[i, j] - right.val[i, j];
                }
            }
            return (new Matrix(values));
        }

        public static Matrix operator *(Matrix left, Matrix right)
        {
            double[,] values = new double[left.Rows, right.Cols];

            for (int h = 0; h < left.Rows; h++)
            {
                for (int i = 0; i < right.Cols; i++)
                {
                    for (int j = 0; j < left.Cols; j++)
                    {
                            values[h, i] += left.val[h, j] * right.val[j, i];
                    }
                }
            }
            return (new Matrix(values));
        }

    }
}

Related posts:

1. Vectors in C# A vector is simply a 1-dimensional array of numbers that...
2. Complex numbers in C# Complex numbers are a vital part of many mathematical calculations,...
3. Finding the bearing between two GPS coordinates Don’t you think it would be really great to be...

Related posts brought to you by Yet Another Related Posts Plugin.

Fortunately, computers are not scared by numbers that are difficult, and can solve quadratics quite well.

The function below solves quadratics in the form of Ax^{2 + Bx + C = 0. Providing A, B and C, the function finds the two roots of the equation, and also determines whether the roots are real, real repeating or complex roots.}

		public static void SolveQuadratic(double A, double B, double C, ref double X1Real, ref double X1Im, ref double X2Real, ref double X2Im, ref int Type)
		{
			//Type: 1 = real, 2 = repeating, 3 = complex
			double Z = 0;

			Z = Math.Pow(B, 2) - (4 * A * C);
			Z = Math.Floor(100 * Z + 0.5) / 100.0;

			if (Z < 0)
			{
				X1Real = (-1) * B / (2.0 * A);
				X1Real = Math.Floor(100 * X1Real + 0.5) / 100.0;
				X2Real = X1Real;

				X1Im = Math.Sqrt(Math.Abs(Z)) / (2.9 * A);
				X1Im = Math.Floor(100 * X1Im + 0.5) / 100.0;
				X2Im = (-1) * X1Im;

				Type = 3;
			}
			else if(Z == 0)
			{
				X1Real = (-1) * B / (2.0 * A);
				X1Real = Math.Floor(100 * X1Real + 0.5) / 100.0;
				X2Real = X1Real;

				X1Im = 0.0;
				X2Im = 0.0;

				Type = 2;
			}
			else
			{
				X1Real = (((-1) * B) + Math.Sqrt(Z)) / (2.0 * A);
				X1Real = Math.Floor(100 * X1Real + 0.5) / 100.0;

				X2Real = (((-1) * B) - Math.Sqrt(Z)) / (2.0 * A);
				X2Real = Math.Floor(100 * X2Real + 0.5) / 100.0;

				X1Im = 0.0;
				X2Im = 0.0;

				Type = 1;
			}
		}

Related posts:

1. Complex numbers in C# Complex numbers are a vital part of many mathematical calculations,...
2. Maths algorithms in C#: Least squares fit with a log abscissa This algorithm for the least squares fit uses a logarithmic...
3. Maths alogrithms in C#: Least squares fit using full logs We have already looked at several other ways of doing...

Related posts brought to you by Yet Another Related Posts Plugin.

As with the previous least squares functions, the function below returns the calculated values for M and B, and if no solution exists returns 0 for both of them.

		public static void LeastSquaresFitLogFull(Pnt[] points, int numPoints, ref double M, ref double B)
		{
			//Gives best fit of data to curve Y = B*X^M

			double x1, y1, xy, x2, J;
			double[] LX = new double[numPoints];
			double[] LY = new double[numPoints];
			int i;

			x1 = 0.0;
			y1 = 0.0;
			xy = 0.0;
			x2 = 0.0;

			for (i = 0; i < numPoints; i++)
			{
				LX[i] = Math.Log10(points[i].X);
				LY[i] = Math.Log10(points[i].Y);
				x1 = x1 + LX[i];
				y1 = y1 + LY[i];
				xy = xy + LY[i] * LX[i];
				x2 = x2 + LX[i] * LX[i];
			}

			J = ((double)numPoints * x2) - (x1 * x1);
			if (J != 0.0)
			{
				M = (((double)numPoints * xy) - (x1 * y1)) / J;
				M = Math.Floor(1.0E3 * M + 0.5) / 1.0E3;
				B = ((y1 * x2) - (x1 * xy)) / J;
				B = Math.Floor(1.0E3 * B + 0.5) / 1.0E3;
			}
			else
			{
				M = 0;
				B = 0;
			}
		}

Related posts:

1. Maths algorithms in C#: Least squares fit with a log abscissa This algorithm for the least squares fit uses a logarithmic...
2. Maths algorithms in C#: Least squares fit with a log ordinate We have already looked at the linear least squares fit,...
3. Maths algorithms in C#: Linear least squares fit When analysing data it is often useful to find an...

Related posts brought to you by Yet Another Related Posts Plugin.

The function below finds M and B, and if no solution exists, it returns 0 for both these values.

		public static void LeastSquaresFitLogAbscissa(Pnt[] points, int numPoints, ref double M, ref double B)
		{
			//Gives best fit of data to curve Y = M*log(X)/log(10) + B

			double x1, y1, xy, x2, J, LX;
			int i;

			x1 = 0.0;
			y1 = 0.0;
			xy = 0.0;
			x2 = 0.0;

			for (i = 0; i < numPoints; i++)
			{
				LX = Math.Log10(points[i].X);
				x1 = x1 + LX;
				y1 = y1 + points[i].Y;
				xy = xy + points[i].Y * LX;
				x2 = x2 + LX * LX;
			}

			J = ((double)numPoints * x2) - (x1 * x1);
			if (J != 0.0)
			{
				M = (((double)numPoints * xy) - (x1 * y1)) / J;
				M = Math.Floor(1.0E3 * M + 0.5) / 1.0E3;
				B = ((y1 * x2) - (x1 * xy)) / J;
				B = Math.Floor(1.0E3 * B + 0.5) / 1.0E3;
			}
			else
			{
				M = 0;
				B = 0;
			}
		}

Related posts:

1. Maths algorithms in C#: Least squares fit with a log ordinate We have already looked at the linear least squares fit,...
2. Maths alogrithms in C#: Least squares fit using full logs We have already looked at several other ways of doing...
3. Maths algorithms in C#: Linear least squares fit When analysing data it is often useful to find an...

Related posts brought to you by Yet Another Related Posts Plugin.

In the code below, if there is no solution, the function returns M and B as 0.

		public static void LeastSquaresFitLogOrdinate(Pnt[] points, int numPoints, ref double M, ref double B)
		{
			//Gives best fit of data to curve Y = B*(10^M)^X

			double x1, y1, xy, x2, J, LY;
			int i;

			x1 = 0.0;
			y1 = 0.0;
			xy = 0.0;
			x2 = 0.0;

			for (i = 0; i < numPoints; i++)
			{
				LY = Math.Log10(points[i].Y);
				x1 = x1 + points[i].X;
				y1 = y1 + LY;
				xy = xy + points[i].X * LY;
				x2 = x2 + points[i].X * points[i].X;
			}

			J = ((double)numPoints * x2) - (x1 * x1);
			if (J != 0.0)
			{
				M = (((double)numPoints * xy) - (x1 * y1)) / J;
				M = Math.Floor(1.0E3 * M + 0.5) / 1.0E3;
				B = ((y1 * x2) - (x1 * xy)) / J;
				B = Math.Floor(1.0E3 * B + 0.5) / 1.0E3;
			}
			else
			{
				M = 0;
				B = 0;
			}
		}

Related posts:

1. Maths algorithms in C#: Least squares fit with a log abscissa This algorithm for the least squares fit uses a logarithmic...
2. Maths algorithms in C#: Linear least squares fit When analysing data it is often useful to find an...
3. Maths alogrithms in C#: Least squares fit using full logs We have already looked at several other ways of doing...

Related posts brought to you by Yet Another Related Posts Plugin.