예제 #1
0
        /// <summary>Matrix subtraction.</summary>
        public static GenericMatrix <T> Subtract(GenericMatrix <T> left, GenericMatrix <T> right)
        {
            if (left == null)
            {
                throw new ArgumentNullException("left");
            }

            if (right == null)
            {
                throw new ArgumentNullException("right");
            }

            if (!DimensionEquals(left, right))
            {
                throw new ArgumentException("Matrix dimension do not match.");
            }

            Matrix r = new Matrix(left.m_rows, left.m_columns);

            for (int i = 0; i < left.m_rows; i++)
            {
                for (int j = 0; j < left.m_columns; j++)
                {
                    r[i][j] = left.m_data[i][j] - right.m_data[i][j];
                }
            }
            return(r);
        }
예제 #2
0
        /// <summary>Raise every member of the matrix to the given power.</summary>
        public static GenericMatrix <T> Pow(GenericMatrix <T> m, double power)
        {
            GenericMatrix <T> r = m.Clone();

            for (int i = 0; i < r.m_rows; i++)
            {
                for (int j = 0; j < r.m_columns; j++)
                {
                    r.m_data[i][j] = System.Math.Pow(r.m_data[i][j], power);
                }
            }
            return(r);
        }
예제 #3
0
        //---------------------------------------------


        #region Static Methods

        /// <summary>Returns a matrix filled with random values.</summary>
        public static GenericMatrix <T> Random(int rows, int columns)
        {
            Matrix X = new GenericMatrix <T>(rows, columns);

            double[][] x = X.baseArray;
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    x[i][j] = random.NextDouble();
                }
            }
            return(X);
        }
예제 #4
0
        /// <summary>Matrix-matrix multiplication.</summary>
        public static GenericMatrix <T> Multiply(GenericMatrix <T> left, GenericMatrix <T> right)
        {
            if (left == null)
            {
                throw new ArgumentNullException("left");
            }

            if (right == null)
            {
                throw new ArgumentNullException("right");
            }

            int rows = left.Rows;

            double[][] data = left.baseArray;

            if (right.Rows != left.m_columns)
            {
                throw new ArgumentException("Matrix dimensions are not valid.");
            }

            int columns         = right.Columns;
            GenericMatrix <T> X = new GenericMatrix <T>(rows, columns);

            double[][] x = X.baseArray;

            int size = left.m_columns;

            double[] column = new double[size];
            for (int j = 0; j < columns; j++)
            {
                for (int k = 0; k < size; k++)
                {
                    column[k] = right[k, j];
                }
                for (int i = 0; i < rows; i++)
                {
                    double[] row = data[i];
                    double   s   = 0;
                    for (int k = 0; k < size; k++)
                    {
                        s += row[k] * column[k];
                    }
                    x[i][j] = s;
                }
            }

            return(X);
        }
예제 #5
0
 /// <summary>Creates a new copy of a matrix object</summary>
 /// <param name="matrix">The matrix to be copied.</param>
 public GenericMatrix(GenericMatrix <T> matrix)
 {
     this.m_data = new T[matrix.Rows][];
     for (int i = 0; i < matrix.Rows; i++)
     {
         this.m_data[i] = new T[matrix.Columns];
         for (int j = 0; j < matrix.Columns; j++)
         {
             this.m_data[i][j] = matrix.m_data[i][j];
         }
     }
     //    this.m_data = (double[][])matrix.m_data.Clone();
     this.m_columns = matrix.m_columns;
     this.m_rows    = matrix.m_rows;
 }
예제 #6
0
        /// <summary>Matrix-scalar multiplication.</summary>
        public static GenericMatrix <T> Multiply(GenericMatrix <T> left, double right)
        {
            if (left == null)
            {
                throw new ArgumentNullException("left");
            }

            GenericMatrix <T> r = new GenericMatrix <T>(left.m_rows, left.m_columns);

            for (int i = 0; i < left.m_rows; i++)
            {
                for (int j = 0; j < left.m_columns; j++)
                {
                    r.m_data[i][j] = left.m_data[i][j] * right;
                }
            }
            return(r);
        }
예제 #7
0
 /// <summary>Returns a square diagonal matrix of the given dimension.</summary>
 public static GenericMatrix <T> Diagonal(int dimension, T value)
 {
     return(GenericMatrix <T> .Diagonal(dimension, dimension, value));
 }
예제 #8
0
 /// <summary> Returns the identity matrix of the given dimension. </summary>
 public static GenericMatrix <T> Identity(int dimension)
 {
     return(GenericMatrix <T> .Diagonal(dimension, 1.0));
 }
예제 #9
0
 /// <summary>Returns a square matrix filled with random values.</summary>
 public static GenericMatrix <T> Random(int dimension)
 {
     return(GenericMatrix <T> .Random(dimension, dimension));
 }