【C#】 4. NumericMatrix类型（包含矩阵运算）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace UserDefinedDataEXP
{
    class NumericMatrix<T>:Matrix<T>
    {
        // Constructors
        public NumericMatrix(): base()
        {
        }
        public NumericMatrix(int rows, int columns): base(rows, columns)
        {
        }
        public NumericMatrix(int rows, int columns, int rowstart, int columnstart) :base(rows, columns, rowstart, columnstart)
        {
        }
        public NumericMatrix(NumericMatrix<T> source): base(source)
        {
        }
        public NumericMatrix(Array<T> array, int rowstart, int columnstart) :base(array, rowstart, columnstart)
        {
        }

        // + 运算符
        #region ADD OPERATION
        //委托BinaryOperatorT<T, T, T> addTT
        private static BinaryOperatorT<T, T, T> addTT;

        //矩阵加法实现1：NumericMatrix<T> v1,NumericMatrix<T> v2
        public static NumericMatrix<T> operator +(NumericMatrix<T> v1, NumericMatrix<T> v2)
        {
            NumericMatrix<T> result = new NumericMatrix<T>(v1.Rows,v1.Columns,v1.MinRowIndex,v1.MinColumnIndex);
            int rdelta = v2.MinRowIndex - v1.MinRowIndex;
            int cdelta = v2.MinColumnIndex - v1.MinColumnIndex;
            
            if (addTT == null)
            {
                addTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, NumericMatrix<T>>.Add);
            }
            for (int i = v1.MinRowIndex; i <= v1.MaxRowIndex; i++)
            {
                for (int j =  v1.MinColumnIndex; j <= v1.MaxColumnIndex; j++)
                {
                    result[i,j] = addTT(v1[i,j], v2[i + rdelta,j+cdelta]);
                } 
            }
            return result;
        }
        #endregion

        // * 运算符
        #region MULPLICATION OPERATION
        //委托BinaryOperatorT<T, T, T> mulTT
        private static BinaryOperatorT<T, T, T> mulTT;

        //乘法实现1：NumericMatrix<T> v1, T v2
        public static NumericMatrix<T> operator *(NumericMatrix<T> v1, T v2)
        {
            int rows = v1.MaxRowIndex - v1.MinRowIndex + 1;
            int cols = v1.MaxColumnIndex - v1.MinColumnIndex + 1;
            NumericMatrix<T> result = new NumericMatrix<T>(rows, cols, v1.MinRowIndex, v1.MinColumnIndex);
            if (mulTT == null)
            {
                mulTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, NumericMatrix<T>>.Multiply);
                addTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, NumericMatrix<T>>.Add);
            }
            for (int i = v1.MinRowIndex; i <= v1.MaxRowIndex; i++)
            {
                for (int j = v1.MinColumnIndex; j <= v1.MaxColumnIndex; j++)
                {
                    result[i, j] = mulTT(v1[i, j], v2);
                }
            }
            return result;
        }

        //乘法实现2：T v2, NumericMatrix<T> v1
        public static NumericMatrix<T> operator *(T v2, NumericMatrix<T> v1)
        {
            NumericMatrix<T> result = new NumericMatrix<T>(v1.Rows, v1.Columns, v1.MinRowIndex, v1.MinColumnIndex);
            if (mulTT == null)
            {
                mulTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, NumericMatrix<T>>.Multiply);
            }
            for (int i = v1.MinRowIndex; i <= v1.MaxRowIndex; i++)
            {
                for (int j = v1.MinColumnIndex; j <= v1.MaxColumnIndex; j++)
                {
                    result[i, j] = mulTT(v1[i, j], v2);
                }
            }
            return result;
        }

        //乘法实现3：NumericMatrix<T> v1, Array<T> v2
        public static Vector<T> operator *(NumericMatrix<T> v1, Vector<T> v2)
        {
            Vector<T> result = new Vector<T>(v2.Length, v2.MinIndex);

            if (mulTT == null || addTT==null)
            {
                mulTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, NumericMatrix<T>>.Multiply);
                addTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, NumericMatrix<T>>.Add); //非常重要！定义了TT之间的加法！
            }

            int delta = v2.MinIndex - v1.MinRowIndex;
            for (int i = v1.MinRowIndex; i <= v1.MaxRowIndex; i++)
            {
                for (int j = v1.MinColumnIndex; j <= v1.MaxColumnIndex; j++)
                {
                   result[i + delta] = addTT(result[i+ delta], mulTT(v1[i, j], v2[j + delta]));
                }       
            }
            return result;
        }

        //乘法实现4：NumericMatrix<T> v1, NumericMatrix<T> v2
        public static NumericMatrix<T> operator *(NumericMatrix<T> v1, NumericMatrix<T> v2)
        {
            NumericMatrix<T> result = new NumericMatrix<T>(v1.Rows,v2.Columns,v1.MinRowIndex,v2.MinColumnIndex);
            if (mulTT == null || addTT==null )
            {
                mulTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, NumericMatrix<T>>.Multiply);
                addTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, NumericMatrix<T>>.Add); //非常重要！定义了TT之间的加法！
            }

            int delta = v2.MinRowIndex- v1.MinColumnIndex;
            for (int i = v1.MinRowIndex; i <= v1.MaxRowIndex; i++)
            {
                for (int j = v2.MinColumnIndex; j <= v2.MaxColumnIndex; j++)
                {
                    for (int k = v1.MinColumnIndex; k <= v1.MaxColumnIndex; k++)
                    {
                        result[i,j] = addTT(mulTT(v1[i, k], v2[k+delta, j]),  result[i,j]);
                    }          
                }
            }
            return result;
        }
        #endregion

    }
}

</pre><pre name="code" class="csharp">

</pre><pre name="code" class="csharp">

</pre><pre name="code" class="csharp">

class test
    {
            static void Main(string[] args)
            {
               // Matrices
                int R = 2;
                int C = 2;
                int startRow = 1; int startColumn = 1;
                NumericMatrix<double> A = new NumericMatrix<double>(R, C, startRow, startColumn);
                NumericMatrix<double> B = new NumericMatrix<double>(R, C, startRow, startColumn);
                A.initCells(1.0);
                A.print();
                for (int i = A.MinRowIndex; i <= A.MaxRowIndex; i++)
                {
                    for (int j = A.MinColumnIndex; j <= A.MaxColumnIndex; j++)
                    {
                        A[i, j] = i * j;
                        B[i, j] = -i * j;
                    }
                }


                A.print();
                B.print();
                Console.WriteLine();


                // Interactions with scalars and vectors
                double factor = 2.0;
                A = factor * A;
                Console.WriteLine("Original matrix A");
                A.print();
                Vector<double> x = new Vector<double>(A.Columns, A.MinColumnIndex);
                for (int j = x.MinIndex; j <= x.MaxIndex; j++)
                {
                    x[j] = j;
                }
                x.print();
                x = A * x; x.print();
                NumericMatrix<double> D = new NumericMatrix<double>(R, C, startRow, startColumn);
                D = 3.0 * A; D.print();
                D = A + A; D.print();
                D = A * A; D.print();
                Console.Read();
            }
        
    }