C#的矩陣類

因爲課程設計的需要，寫的C#矩陣類，可以實現基本的矩陣操作。

_Matrix類：

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

namespace Matrix_Mul
{
    public class _Matrix
    {
        public int m;
        public int n;
        public double[] arr;

        //初始化    
        public _Matrix()
        {
            m = 0;
            n = 0;
        }

        public _Matrix(_Matrix s)
        {
            this.m = s.m;
            this.n = s.n;
            arr = new double[m * n];
            for (int i = 0; i < m * n; i++)
            {
                this.arr[i] = s.arr[i];
            }
        }

        public _Matrix(int mm, int nn)
        {
            m = mm;
            n = nn;
        }

        //設置m    
        public void set_mn(int mm, int nn)
        {
            m = mm;
            n = nn;
        }


        //設置m    
        public void set_m(int mm)
        {
            m = mm;
        }

        //設置n    
        public void set_n(int nn)
        {
            n = nn;
        }

        //初始化    
        public void init_matrix()
        {
            arr = new double[m * n];
        }

        //釋放    
        public void free_matrix()
        {
            //delete [] arr;  
        }

        //讀取i,j座標的數據    
        //失敗返回-31415,成功返回值    
        public double read(int i, int j)
        {
            if (i >= m || j >= n)
            {
                return -31415;
            }

            //return *(arr + i * n + j);  
            return arr[i * n + j];
        }

        //寫入i,j座標的數據    
        //失敗返回-1,成功返回1    
        public int write(int i, int j, double val)
        {
            if (i >= m || j >= n)
            {
                return -1;
            }

            arr[i * n + j] = val;
            return 1;
        }
        public double sums()
        {
            double a = 0;
            for (int i = 0; i < this.m; i++)
            {
                for (int j = 0; j < this.n; j++)
                {
                    a += this.read(i, j);
                }
            }
            return a;
        }


    };
}

_Matrix_Calc類

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

namespace Matrix_Mul
{
    public class _Matrix_Calc
    {
        //初始化  
        public _Matrix_Calc()
        {

        }

       

        /// <summary>
        /// C=A+B
        /// </summary>
        /// <param name="A"></param>
        /// <param name="B"></param>
        /// <returns></returns>
        public _Matrix adds(_Matrix A, _Matrix B)
        {
            int i = 0;
            int j = 0;
            _Matrix C = new _Matrix(A.m, A.n);
            C.init_matrix();
            //判斷是否可以運算    
            if (A.m != B.m || A.n != B.n ||
                A.m != C.m || A.n != C.n)
            {
                Console.ReadKey();
            }
            //運算    
            for (i = 0; i < C.m; i++)
            {
                for (j = 0; j < C.n; j++)
                {
                    C.write(i, j, A.read(i, j) + B.read(i, j));
                }
            }

            return C;
        }

        /// <summary>
        /// C=A-B
        /// </summary>
        /// <param name="A"></param>
        /// <param name="B"></param>
        /// <returns></returns>
        public _Matrix subtracts(_Matrix A, _Matrix B)
        {
            int i = 0;
            int j = 0;
            _Matrix C = new _Matrix(A.m, B.n);
            C.init_matrix();
            //判斷是否可以運算    
            if (A.m != B.m || A.n != B.n ||
                A.m != C.m || A.n != C.n)
            {
                Console.ReadKey();
            }
            //運算    
            for (i = 0; i < C.m; i++)
            {
                for (j = 0; j < C.n; j++)
                {
                    C.write(i, j, A.read(i, j) - B.read(i, j));
                }
            }

            return C;
        }
        /// <summary>
        /// 獲取矩陣的某一行 
        /// </summary>
        /// <param name="data"></param>
        /// <param name="kk">行數</param>
        /// <returns></returns>
        public _Matrix GetRow(_Matrix data, int kk)
        {
            _Matrix p = new _Matrix(1, data.n);
            p.init_matrix();
            for (int i = 0; i < data.n; i++)
            {
                p.write(0, i, data.read(kk, i));
            }
            return p;
        }

        /// <summary>
        /// 獲取矩陣的某一列
        /// </summary>
        /// <param name="data"></param>
        /// <param name="kk"></param>
        /// <returns></returns>
        public _Matrix GetColumn(_Matrix data, int kk)
        {
            _Matrix p = new _Matrix(data.m, 1);
            p.init_matrix();
            for (int i = 0; i < data.m; i++)
            {
                p.write(i, 0, data.read(i, kk));
            }
            return p;
        }
       

        

        /// <summary>
        /// C=A*B
        /// </summary>
        /// <param name="A"></param>
        /// <param name="B"></param>
        /// <returns></returns>
        public _Matrix multiplys(_Matrix A, _Matrix B)
        {
            int i = 0;
            int j = 0;
            int k = 0;
            double temp = 0;
            _Matrix C = new _Matrix(A.m, B.n);
            C.init_matrix();
            //判斷是否可以運算    
            if (A.m != C.m || B.n != C.n ||
                A.n != B.m)
            {
                Console.ReadKey();
            }
            //運算    
            for (i = 0; i < C.m; i++)
            {
                for (j = 0; j < C.n; j++)
                {
                    temp = 0;
                    for (k = 0; k < A.n; k++)
                    {
                        temp += A.read(i, k) * B.read(k, j);
                    }
                    C.write(i, j, temp);
                }
            }

            return C;
        }

       /// <summary>
       /// 求行列式的值,只支持2*2,3*3
       /// </summary>
       /// <param name="A"></param>
       /// <returns></returns>
        public double det(ref _Matrix A)
        {
            double value = 0;

            //判斷是否可以運算    
            if (A.m != A.n || (A.m != 2 && A.m != 3))
            {
                return -31415;
            }
            //運算    
            if (A.m == 2)
            {
                value = A.read(0, 0) * A.read(1, 1) - A.read(0, 1) * A.read(1, 0);
            }
            else
            {
                value = A.read(0, 0) * A.read(1, 1) * A.read(2, 2) +
                        A.read(0, 1) * A.read(1, 2) * A.read(2, 0) +
                        A.read(0, 2) * A.read(1, 0) * A.read(2, 1) -
                        A.read(0, 0) * A.read(1, 2) * A.read(2, 1) -
                        A.read(0, 1) * A.read(1, 0) * A.read(2, 2) -
                        A.read(0, 2) * A.read(1, 1) * A.read(2, 0);
            }

            return value;
        }

      

        /// <summary>
        /// 求矩陣的轉置B=AT
        /// </summary>
        /// <param name="A"></param>
        /// <returns></returns>
        public _Matrix transposs(_Matrix A)
        {
            int i = 0;
            int j = 0;
            _Matrix B = new _Matrix(A.n,A.m);
            B.init_matrix();
            //運算    
            for (i = 0; i < B.m; i++)
            {
                
                for (j = 0; j < B.n; j++)
                {
                    B.write(i, j, A.read(j, i));
                }
            }

            return B;
        }

        /// <summary>
        /// 求矩陣的逆
        /// </summary>
        /// <param name="A"></param>
        /// <param name="B"></param>
        /// <returns></returns>
        public int inverse(ref _Matrix A, ref _Matrix B)
        {
            int i = 0;
            int j = 0;
            int k = 0;
            _Matrix m = new _Matrix(A.m, 2 * A.m);
            double temp = 0;
            double b = 0;

            //判斷是否可以運算    
            if (A.m != A.n || B.m != B.n || A.m != B.m)
            {
                return -1;
            }

            /*  
            //如果是2維或者3維求行列式判斷是否可逆  
            if (A.m == 2 || A.m == 3)  
            {  
                if (det(A) == 0)  
                {  
                    return -1;  
                }  
            }  
            */

            //增廣矩陣m = A | B初始化    
            m.init_matrix();
            for (i = 0; i < m.m; i++)
            {
                for (j = 0; j < m.n; j++)
                {
                    if (j <= A.n - 1)
                    {
                        m.write(i, j, A.read(i, j));
                    }
                    else
                    {
                        if (i == j - A.n)
                        {
                            m.write(i, j, 1);
                        }
                        else
                        {
                            m.write(i, j, 0);
                        }
                    }
                }
            }

            //高斯消元    
            //變換下三角    
            for (k = 0; k < m.m - 1; k++)
            {
                //如果座標爲k,k的數爲0,則行變換    
                if (m.read(k, k) == 0)
                {
                    for (i = k + 1; i < m.m; i++)
                    {
                        if (m.read(i, k) != 0)
                        {
                            break;
                        }
                    }
                    if (i >= m.m)
                    {
                        return -1;
                    }
                    else
                    {
                        //交換行    
                        for (j = 0; j < m.n; j++)
                        {
                            temp = m.read(k, j);
                            m.write(k, j, m.read(k + 1, j));
                            m.write(k + 1, j, temp);
                        }
                    }
                }

                //消元    
                for (i = k + 1; i < m.m; i++)
                {
                    //獲得倍數    
                    b = m.read(i, k) / m.read(k, k);
                    //行變換    
                    for (j = 0; j < m.n; j++)
                    {
                        temp = m.read(i, j) - b * m.read(k, j);
                        m.write(i, j, temp);
                    }
                }
            }
            //變換上三角    
            for (k = m.m - 1; k > 0; k--)
            {
                //如果座標爲k,k的數爲0,則行變換    
                if (m.read(k, k) == 0)
                {
                    for (i = k + 1; i < m.m; i++)
                    {
                        if (m.read(i, k) != 0)
                        {
                            break;
                        }
                    }
                    if (i >= m.m)
                    {
                        return -1;
                    }
                    else
                    {
                        //交換行    
                        for (j = 0; j < m.n; j++)
                        {
                            temp = m.read(k, j);
                            m.write(k, j, m.read(k + 1, j));
                            m.write(k + 1, j, temp);
                        }
                    }
                }

                //消元    
                for (i = k - 1; i >= 0; i--)
                {
                    //獲得倍數    
                    b = m.read(i, k) / m.read(k, k);
                    //行變換    
                    for (j = 0; j < m.n; j++)
                    {
                        temp = m.read(i, j) - b * m.read(k, j);
                        m.write(i, j, temp);
                    }
                }
            }
            //將左邊方陣化爲單位矩陣    
            for (i = 0; i < m.m; i++)
            {
                if (m.read(i, i) != 1)
                {
                    //獲得倍數    
                    b = 1 / m.read(i, i);
                    //行變換    
                    for (j = 0; j < m.n; j++)
                    {
                        temp = m.read(i, j) * b;
                        m.write(i, j, temp);
                    }
                }
            }
            //求得逆矩陣    
            for (i = 0; i < B.m; i++)
            {
                for (j = 0; j < B.m; j++)
                {
                    B.write(i, j, m.read(i, j + m.m));
                }
            }
            //釋放增廣矩陣    
            m.free_matrix();

            return 1;
        }
    };
}