C#实现的一个实用的矩阵类

 前段时间做项目,将关于矩阵的一些操作封装了一个类,共享一下。

主要功能包括:计算矩阵的行列式、矩阵的最大特征值和它所对应的特征向量、矩阵的逆、矩阵的一致性指标。

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

 

namespace Car.systemClass
{
    public class MatrixLab
    {
        private static int N;
        private double eps;
        private double[,] A ;
        private double[] U ;
        private double[] V;
        private int[] Z;
        //计算1000次平的均随机一致性指标
        public static double[] RI ={ 0, 0, 0.52, 0.89, 1.12, 1.26, 1.36, 1.41, 1.46, 1.49 };

        ///


        /// 构造函数
        ///

        /// 矩阵的维长度
        /// 求解精度
        /// 矩阵对象
        public MatrixLab(int n, double e, double[,] a)
        {
            N = n;
            eps = e;
            A = new double[N, N];
            U = new double[N];
            V = new double[N];
            buildMatrix(a);
        }

        ///


        /// 返回和设置矩阵的维长度
        ///

        public int NValue
        {
            get
            {
                return N;
            }
            set
            {
                N = value;
            }
        }      
        ///
        /// 返回和设置求解精度
        ///

        public double Eps
        {
            get
            {
                return eps;
            }
            set
            {
                eps = value;
            }
        }

        ///


        /// 构造一个方阵
        ///

        /// 输入该方阵
        private void buildMatrix(double[,] a)
        {
            if (a.Rank == A.Rank)
            {
                for (int i = 0; i < N; i++)
                {
                    for (int j = 0; j < N; j++)
                    {
                        A[i, j] = a[i, j];
                    }
                }
            }
        }

        ///


        /// 求一个一维数组中的最大值
        ///

        /// 一个一维数组
        /// 最大值
        private double maxValue(params double[] W)
        {
            double tmp = 0;
            if (W.Length != 0)
                tmp = W[0];
            for (int i = 1; i < W.Length; i++)
            {
                if (W[i] > tmp)
                    tmp = W[0];
            }
            return tmp;
        }

        ///


        /// 使用幂法求一个方阵的最大特征值和它所对应的特征向量
        ///

        /// 最大特征值所对应的特征向量
        /// 最大特征值
        /// /// 结果小数点后的尾数长度(精度)
        public void returnResult(ref double[]W,ref double max)
        {
            int i = 0;
            for (i = 0; i < N; i++)
            {
                U[i] = 1;
            }
            int k = 1;
            double m0, mk = 0;
            m0 = maxValue(U);

            for (i = 0; i < N; i++)
            {
                U[i] = 1;
            }
            m0 = maxValue(U);

            while (true)
            {
                for (i = 0; i < N; i++)
                {
                    V[i] = U[i] / m0;
                }
                for (i = 0; i < N; i++)
                {
                    double sum = 0;
                    for (int j = 0; j < N; j++)
                    {
                        sum += A[i, j] * V[j];
                    }
                    U[i] = sum;
                }
                mk = maxValue(U);
                if (Math.Abs(mk - m0) >= eps)
                {
                    if ((Math.Abs(mk - m0) / (1 + mk)) >= eps)
                    {
                        m0 = mk;
                        k++;
                    }
                    else
                        break;
                }
                else
                    break;
            }
            if (Math.Abs(mk - m0) < eps || (Math.Abs(mk - m0) >= eps && (Math.Abs(mk - m0) / (1 + mk)) < eps))
            {
                W =V;
                max = mk;
            }
        }

        public void returnResult2(ref double[] W, ref double max)
        {
            int i = 0;
            for (i = 0; i < N; i++)
            {
                U[i] = 1;
            }
            int k = 1;
            double m0, mk = 0;
            m0 = maxValue(U);

            for (i = 0; i < N; i++)
            {
                U[i] = 1;
            }
            m0 = maxValue(U);

            while (true)
            {
                for (i = 0; i < N; i++)
                {
                    V[i] = U[i] / m0;
                }
                for (i = 0; i < N; i++)
                {
                    double sum = 0;
                    for (int j = 0; j < N; j++)
                    {
                        sum += A[i, j] * V[j];
                    }
                    U[i] = sum;
                }
                mk = maxValue(U);
                if (Math.Abs(mk - m0) >= eps)
                {
                    if ((Math.Abs(mk - m0) / (1 + mk)) >= eps)
                    {
                        m0 = mk;
                        k++;
                    }
                    else
                        break;
                }
                else
                    break;
            }
            if (Math.Abs(mk - m0) < eps || (Math.Abs(mk - m0) >= eps && (Math.Abs(mk - m0) / (1 + mk)) < eps))
            {
                W = V;
                max = mk;
            }

            double SUM = 0;
            for (i = 0; i < W.Length; i++)
            {
                SUM += W[i];
            }
            for (i = 0; i < W.Length; i++)
            {
                W[i] = W[i] / SUM;
            }
        }
        ///


        /// 求矩阵的逆
        ///

        /// 原矩阵的逆矩阵
        public double[,] invertMatrix()
        {
            int i = 0;
            Z = new int[N];
            for (i = 0; i < N; i++)
            {
                Z[i] = i;
            }

            int K = 0;
            int L = 0;
            double D = 0;
            double maxA = 0;
            int t = 0;
            double Ck = 0;
            while (K != N)
            {
                maxA = Math.Abs(A[K, K]);
                L = K;
                i = K + 1;
                while (i != N)
                {
                    if (Math.Abs(A[i, K]) > maxA)
                    {
                        maxA = Math.Abs(A[i, K]);
                        L = i;
                    }
                    i++;
                }
                i = 0;
                D = A[L, K];
                Z[K] = L;
                if (D == 0)
                    break;

                int j = 0;
                if (L != K)
                {
                    for (j = 0; j < N; j++)
                    {
                        double tmp = A[K, j];
                        A[K, j] = A[L, j];
                        A[L, j] = tmp;
                    }
                }
                Ck = 1 / A[K, K];
                A[K, K] = Ck;
                for (j = 0; j < N; j++)
                {
                    if (j != K)
                        A[K, j] = A[K, j] * Ck;
                }
                for (i = 0; i < N; i++)
                {
                    for (j = 0; j < N; j++)
                    {
                        if (i != K && j != K)
                            A[i, j] = A[i, j] - A[i, K] * A[K, j];
                    }
                }
                for (i = 0; i < N; i++)
                {
                    if (i != K)
                        A[i, K] = -A[i, K] * Ck;
                }
                K++;
            }
            K = N - 2;
            while (K >= 0)
            {
                t = Z[K];
                if (t != K)
                    for (i = 0; i < N; i++)
                    {
                        double tmp = A[i, K];
                        A[i, K] = A[i, t];
                        A[i, t] = tmp;
                    }
                K--;
            }
            return A;
        }

        /*函数介绍:输入一个行列式,用递归的方法,以行列式的行序为主序求行列式的值
         输入参数:const int a[][N] :一个以二维数组形式存储的行列式
         int n:行列式的阶数
         输出参数:无
         返回值:  int :行列式的值
        */
        ///


        /// 输入一个行列式,用递归的方法,以行列式的行序为主序求行列式的值
        ///

        /// 一个以二维数组形式存储的行列式
        /// 行列式的阶数
        /// 行列式的值
        public double HLS(double[,] a, int n)
        {
            if (n == 1) //如果行列式的阶数为1,直接返回其值
            {
                return a[0, 0];
            }
            else  //否则按照求代数余子式的方法,采用递归方式求行列式的值
            {
                double sum = 0; //用来存储当前行列式(可能是上一层行列式的余子式)的值

                for (int i = 0; i < n; i++)//以行列式的行序为主序求行列式的值
                {
                    double[,] Y = new double[N, N]; //存储行列式当前元素的余子式
                    YZS(Y, a, n, i);   //求行列式当前元素的余子式

                    int xs = (i % 2 == 0) ? 1 : -1; //计算行列式当前元素的代数余子式的系数

                    sum += xs * a[i, 0] * HLS(Y, n - 1);//累积当前行列式的值
                }
                return sum;
            }
        }
        /*函数介绍:输入一个行列式及其第0列第a-r行元素,求该元素的余子式
          输入参数:const int a[][N] :一个以二维数组形式存储的行列式
          int n:行列式的阶数
          int a_r:元素的行号(列号默认为0)
          输出参数:int Y[][N]:该元素的余子式
          返回值:  void
        */
        ///


        /// 输入一个行列式及其第0列第a-r行元素,求该元素的余子式
        ///

        /// 该元素的余子式
        /// 一个以二维数组形式存储的行列式
        /// 行列式的阶数
        /// 元素的行号(列号默认为0)
        private void YZS(double[,] Y, double[,] a, int len, int a_r)
        {
            int r = 0;//r,c用来填充余子式的元素值
            int c = 0;

            for (int i = 0; i < len; i++)
            {
                if (i != a_r)
                {
                    for (int j = 1; j < len; j++)
                    {
                        Y[r, c++] = a[i, j];
                    }
                    r++;
                    c = 0;
                }
            }
        }
        ///


        /// 计算一致性指标CI
        ///

        /// n阶矩阵的最大特征值
        /// 矩阵的阶数
        /// 一致性指标CI的值
        public static double CI(double lamda, int n)
        {
            if (n > 1 && lamda >= n)
                return (lamda - n) / (n - 1);
            else
                return -1;
        }
    }
}

你可能感兴趣的:(C#实现的一个实用的矩阵类)