C#矩阵类实现（基于Python及matlab矩阵规范）

最新推荐文章于 2024-04-13 21:45:41 发布
最新推荐文章于 2024-04-13 21:45:41 发布
阅读量4.7k 收藏 71
点赞数 25
分类专栏： 矩阵 C# 文章标签： C#矩阵 C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41815357/article/details/83301516
版权
C# 同时被 2 个专栏收录
5 篇文章 1 订阅
订阅专栏
矩阵
1 篇文章 0 订阅
订阅专栏

目录

 

一.矩阵定义

1.指定简单矩阵的创建

2.特殊矩阵的创建

 【Matrix.Ones】

【Matrix.Eye】

【Matrix.Zeros】

 【Matrix.Random】

【Matrix.Diag】

二.矩阵的运算

【Matrix.I】

【Matrix.T】

三.矩阵类代码

四.小结

一.矩阵定义

1.指定简单矩阵的创建

//单行代码创建矩阵（推荐），以2*2的矩阵为例
Matrix a = new   Matrix(new double[,] {{2,2},{1,1}});
//多行代码创建矩阵，以2*2的矩阵为例
double[,] a = new double[2,2]{{2,2},{1,1}};
Matrix  b  = new Matrix(a);

2.特殊矩阵的创建

  •  【Matrix.Ones】

  创建元素全为1的矩阵

//生成一个指定阶数的元素全为1的方阵
Matrix a = Matrix.Ones(3);

//输出结果
1 1 1
1 1 1
1 1 1
//生成一个指定行列的矩阵并且其元素全为1
Matrix a = Matrix.Ones(2,3);

//生成结果
1 1 1 
1 1 1

  • 【Matrix.Eye】

创建单位矩阵

//生成一个指定阶数的单位矩阵
Matrix a = Matrix.Eye(3);

//生成结果
1 0 0
0 1 0
0 0 1

  • 【Matrix.Zeros】

创建零矩阵

//生成一个指定阶数的零矩阵
Matrix a  = Matrix.Zeros(3);


//输出结果
0 0 0
0 0 0
0 0 0
//生成一个指定行列的零矩阵
Matrix a = Matrix.Zeros(2,3);

//生成结果
0 0 0
0 0 0

  •  【Matrix.Random】

生成随机数矩阵

//创建指定维数的伪随机数矩阵（0-1）
Matrix a = Matrix.Random(2);


//输出结果
0.516404123751635 0.983861273147101
0.899167415173337 0.00153744081106849


//创建指定行和列的伪随机数矩阵
Matrix a  = Matrix.Random(2,3);


//输出结果
7.96839595212061E-05 0.147591004682514 0.695700505606691
0.0767334909535635 0.380114347850957 0.248828622628389

//创建指定维数，并且指定随机数范围的伪随机数矩阵(min-max)
Matrix a = Matrix.Random(2,10,20)


//输出结果
15.3690170521704 11.5182845441244
13.8757416298034 19.5315619183386

//创建指定行数，列数，并且指定随机数范围的伪随机数矩阵
Matrix a = Matrix.Random(2,3,10,20)


//输出结果
17.6909273945219 12.7356204915492 15.4563716824429
16.8744842786689 15.6722028579899 15.3704242572982

  • 【Matrix.Diag】

创建对角矩阵

//创建指定数据的对角矩阵(单行)

Matrix a = Matrix.Diag(new double[]{2,1,3})


//输出结果
2 0 0
0 1 0
0 0 3

 

二.矩阵的运算

矩阵相加减，矩阵乘法与基本矩阵运算相同

  • 【Matrix.I】

矩阵求逆

//矩阵求逆 
Matrix a = new Matrix ();
Matrix b = a.I;

  • 【Matrix.T】

矩阵求转置

//矩阵求转置
Matrix a = new Matrix ;
Matrix b = a.T;

三.矩阵类代码

using System;
using System.Collections.Generic;

namespace Cmath
{
    [Serializable]           //反射
    public class Matrix
    {
        public double[] element;
        private int rows = 0;
        private int cols = 0;
        private double[,] value;
        /// <summary>
        /// 获取矩阵行数
        /// </summary>
        public int Rows
        {
            get
            {
                return rows;
            }
            set
            {
                rows = value;
            }
        }
        /// <summary>
        /// 获取矩阵列数
        /// </summary>
        public int Cols
        {
            get
            {
                return cols;
            }
            set
            {
                cols = value;
            }
        }
        /// <summary>
        /// 获取与设置矩阵元素值的二维数组
        /// </summary>
        public double[,] Value
        {
            get
            {
                return this.value;
            }
            set
            {
                this.value = value;
            }
        }
        /// <summary>
        /// 获取或设置第i行第j列的元素值
        /// </summary>
        /// <param name="i">第i行</param>
        /// <param name="j">第j列</param>
        /// <returns>返回第i行第j列的元素值</returns>
        public double this[int i, int j]
        {
            get
            {
                if (i < Rows && j < Cols)
                {
                    return element[i * cols + j];
                }
                else
                {
                    throw new Exception("索引越界");
                }
            }
            set
            {
                element[i * cols + j] = value;
            }
        }
        /// <summary>
        /// 用二维数组初始化Matrix
        /// </summary>
        /// <param name="m">二维数组</param>
        private Matrix()
        {

        }
        private Matrix(int rows, int cols)
        {
            this.rows = rows;
            this.cols = cols;
            this.value = new double[rows, cols];
        }
        public Matrix(double[][] m)            //构造函数
        {
            this.rows = m.GetLength(0);
            this.cols = m.GetLength(1);
            int count = 0;
            this.element = new double[Rows * Cols];
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    element[count++] = m[i][j];
                }
            }
        }
        public Matrix(double[,] m)
        {
            this.rows = m.GetLength(0);
            this.cols = m.GetLength(1);
            this.element = new double[this.rows * this.cols];
            int count = 0;
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    element[count++] = m[i, j];
                }
            }
        }
        public Matrix(List<List<double>> m)
        {
            this.rows = m.Count;
            this.cols = m[0].Count;
            this.element = new double[Rows * Cols];
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    this[i, j] = m[i][j];
                }
            }
        }
        #region 特殊矩阵的生成
        /// <summary>
        ///         生成一个指定阶的元素全为1的方阵
        /// </summary>
        /// <param name="dimension"></param>
        /// <returns></returns>
        public static Matrix Ones(int dimension)
        {
            Matrix result = new Matrix();
            result.rows = dimension;
            result.cols = dimension;
            result.value = new double[dimension, dimension];
            result.element = new double[dimension * dimension];
            int count = 0;
            for (int i = 0; i < dimension; i++)
                for (int j = 0; j < dimension; j++)
                {
                    result.value[i, j] = 1;
                    result.element[count++] = 1 ;
                }
            return result;
        }
        /// <summary>
        ///         生成一个指定行列的元素全为1的矩阵
        /// </summary>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <returns></returns>
        public static Matrix Ones(int row, int column)
        {
            Matrix result = new Matrix();
            result.rows = row;
            result.cols = column;
            result.value = new double[row, column];
            result.element = new double[row * column];
            int count = 0;
            for (int i = 0; i < row; i++)
                for (int j = 0; j < column; j++)
                {
                    result.value[i, j] = 1;
                    result.element[count++] = 1;
                }
            return result;
        }
        /// <summary>
        ///         生成一个指定阶数的单位矩阵
        /// </summary>
        /// <param name="dimension"></param>
        /// <returns></returns>
        public static Matrix Eye(int dimension)
        {
            Matrix result = new Matrix();
            result.rows = dimension;
            result.cols = dimension;
            result.value = new double[dimension, dimension];
            result.element = new double[dimension * dimension];
            int count = 0;
            for (int i = 0; i < dimension; i++)
                for (int j = 0; j < dimension; j++)
                {
                    if (i == j)
                    {
                        result.value[i, j] = 1;
                        result.element[count] = 1;
                    }

                    else
                    {
                        result.value[i, j] = 0;
                        result.element[count] = 0;
                    }
                    count++;
                }
            return result;
        }
        /// <summary>
        ///         生成一个指定阶数的零矩阵
        /// </summary>
        /// <param name="dimension"></param>
        /// <returns></returns>
        public static Matrix Zeros(int dimension)
        {
            Matrix result = new Matrix();
            result.rows = dimension;
            result.cols = dimension;
            result.value = new double[dimension, dimension];
            result.element = new double[dimension * dimension];
            int count = 0;
            for (int i = 0; i < dimension; i++)
                for (int j = 0; j < dimension; j++)
                {
                    result.value[i, j] = 0;
                    result.element[count++] = 0;
                }

            return result;
        }
        /// <summary>
        ///         生成一个指定行列数的零矩阵
        /// </summary>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <returns></returns>
        public static Matrix Zeros(int row, int column)
        {
            Matrix result = new Matrix();
            result.rows = row;
            result.cols = column;
            result.value = new double[row, column];
            result.element = new double[row * column];
            int count = 0;
            for (int i = 0; i < row; i++)
                for (int j = 0; j < column; j++)
                {
                    result.value[i, j] = 0;
                    result.element[count++] = 0;
                }
            return result;
        }
        /// <summary>
        ///         生成一个指定阶数的伪随机数矩阵
        /// </summary>
        /// <param name="dimension"></param>
        /// <returns></returns>
        public static Matrix Random(int dimension)
        {
            Matrix result = new Matrix();
            result.rows = dimension;
            result.cols = dimension;
            result.value = new double[dimension, dimension];
            result.element = new double[dimension * dimension];
            int count = 0;
            for (int i = 0; i < dimension; i++)
                for (int j = 0; j < dimension; j++)
                {
                    result.value[i, j] = Matrix.GetRandomNum();
                    result.element[count++] = result.value[i, j];
                }
            return result;
        }
        /// <summary>
        ///         生成一个指定行列数的伪随机数矩阵
        /// </summary>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <returns></returns>
        public static Matrix Random(int row, int column)
        {
            Matrix result = new Matrix();
            result.rows = row;
            result.cols = column;
            result.value = new double[row, column];
            result.element = new double[row * column];
            int count = 0;
            for (int i = 0; i < row; i++)
                for (int j = 0; j < column; j++)
                {
                    result.value[i, j] = Matrix.GetRandomNum();
                    result.element[count++] = result.value[i, j];
                }
            return result;
        }
        /// <summary>
        ///         生成一个指定阶数和随机范围的伪随机数矩阵
        /// </summary>
        /// <param name="dimension"></param>
        /// <param name="min">伪随机数下限</param>
        /// <param name="max">伪随机数上限</param>
        /// <returns></returns>
        public static Matrix Random(int dimension, double min, double max)
        {
            if (min > max)
            {
                min = max + min;
                max = min - max;
                min = min - max;
            }
            Matrix result = new Matrix();
            result.rows = dimension;
            result.cols = dimension;
            result.value = new double[dimension, dimension];
            result.element = new double[dimension * dimension];
            int count = 0;
            for (int i = 0; i < dimension; i++)
                for (int j = 0; j < dimension; j++)
                {
                    result.value[i, j] = Matrix.GetRandomNum() * (max - min) + min;
                    result.element[count++] = result.value[i, j];
                }
            return result;
        }
        /// <summary>
        ///         生成一个指定行列数和伪随机数范围的矩阵
        /// </summary>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <param name="min">伪随机数下限</param>
        /// <param name="max">伪随机数上限</param>
        /// <returns></returns>
        public static Matrix Random(int row, int column, double min, double max)
        {
            if (min > max)
            {
                min = max + min;
                max = min - max;
                min = min - max;
            }
            Matrix result = new Matrix();
            result.rows = row;
            result.cols = column;
            result.value = new double[row, column];
            result.element = new double[row * column];
            int count = 0;
            for (int i = 0; i < row; i++)
                for (int j = 0; j < column; j++)
                {
                    result.value[i, j] = Matrix.GetRandomNum() * (max - min) + min;
                    result.element[count++] = result.value[i, j];
                }
            return result;
        }
        /// <summary>
        ///         生成一个由指定数组元素填充对角线的对角矩阵
        /// </summary>
        /// <param name="diag"></param>
        /// <returns></returns>
        public static Matrix Diag(double[] diag)
        {
            Matrix result = Matrix.Zeros(diag.GetLength(0));
            for (int i = 0; i < result.rows; i++)
            {
                result.value[i, i] = diag[i];
                result.element[i * result.rows + i] = result.value[i, i];
            }
            return result;
        }
        #endregion
        #region 矩阵数学运算
        public static Matrix MAbs(Matrix a)
        {
            Matrix _thisCopy = a.DeepCopy();
            for (int i = 0; i < a.Rows; i++)
            {
                for (int j = 0; j < a.Cols; j++)
                {
                    _thisCopy[i, j] = Math.Abs(a[i, j]);
                }
            }
            return _thisCopy;
        }
        /// <summary>
        /// 矩阵相加
        /// </summary>
        /// <param name="a">第一个矩阵,和b矩阵必须同等大小</param>
        /// <param name="b">第二个矩阵</param>
        /// <returns>返回矩阵相加后的结果</returns>
        public static Matrix operator +(Matrix a, Matrix b)
        {
            if (a.cols == b.cols && a.rows == b.rows)
            {
                double[,] res = new double[a.rows, a.cols];
                for (int i = 0; i < a.Rows; i++)
                {
                    for (int j = 0; j < a.Cols; j++)
                    {
                        res[i, j] = a[i, j] + b[i, j];
                    }
                }
                return new Matrix(res);
            }
            else
            {
                throw new Exception("两个矩阵行列不相等");
            }
        }
        /// <summary>
        /// 矩阵相减
        /// </summary>
        /// <param name="a">第一个矩阵,和b矩阵必须同等大小</param>
        /// <param name="b">第二个矩阵</param>
        /// <returns>返回矩阵相减后的结果</returns>
        public static Matrix operator -(Matrix a, Matrix b)
        {
            if (a.cols == b.cols && a.rows == b.rows)
            {
                double[,] res = new double[a.rows, a.cols];
                for (int i = 0; i < a.Rows; i++)
                {
                    for (int j = 0; j < a.Cols; j++)
                    {
                        res[i, j] = a[i, j] - b[i, j];
                    }
                }
                return new Matrix(res);
            }
            else
            {
                throw new Exception("两个矩阵行列不相等");
            }
        }
        /// <summary>
        /// 对矩阵每个元素取相反数
        /// </summary>
        /// <param name="a">二维矩阵</param>
        /// <returns>得到矩阵的相反数</returns>
        public static Matrix operator -(Matrix a)
        {
            Matrix res = a;
            for (int i = 0; i < a.rows; i++)
            {
                for (int j = 0; j < a.cols; j++)
                {
                    res.element[i * a.cols + j] = -res.element[i * a.cols + j];
                }
            }
            return res;
        }
        /// <summary>
        /// 矩阵相乘
        /// </summary>
        /// <param name="a">第一个矩阵</param>
        /// <param name="b">第二个矩阵,这个矩阵的行要与第一个矩阵的列相等</param>
        /// <returns>返回相乘后的一个新的矩阵</returns>
        public static Matrix operator *(Matrix a, Matrix b)
        {
            if (a.cols == b.rows)
            {
                double[,] res = new double[a.rows, b.cols];
                for (int i = 0; i < a.rows; i++)
                {
                    for (int j = 0; j < b.cols; j++)
                    {
                        for (int k = 0; k < a.cols; k++)
                        {
                            res[i, j] += a[i, k] * b[k, j];
                        }
                    }
                }
                return new Matrix(res);
            }
            else
            {
                throw new Exception("两个矩阵行和列不等");
            }
        }
        /// <summary>
        /// 矩阵与数相乘
        /// </summary>
        /// <param name="a">第一个矩阵</param>
        /// <param name="num">一个实数</param>
        /// <returns>返回相乘后的新的矩阵</returns>
        public static Matrix operator *(Matrix a, double num)
        {
            Matrix res = a;
            for (int i = 0; i < a.rows; i++)
            {
                for (int j = 0; j < a.cols; j++)
                {
                    res.element[i * a.cols + j] *= num;
                }
            }
            return res;
        }
        /// <summary>
        /// 矩阵转置
        /// </summary>
        /// <returns>返回当前矩阵转置后的新矩阵</returns>
        public Matrix T()
        {
            double[,] res = new double[cols, rows];
            {
                for (int i = 0; i < cols; i++)
                {
                    for (int j = 0; j < rows; j++)
                    {
                        res[i, j] = this[j, i];
                    }
                }
            }
            return new Matrix(res);
        }
        /// <summary>
        /// 矩阵求逆
        /// </summary>
        /// <returns>返回求逆后的新的矩阵</returns>
        public Matrix I()
        {
            //最后原始矩阵并不变，所以需要深拷贝一份
            Matrix _thisCopy = this.DeepCopy();
            if (cols == rows && this.Determinant() != 0)
            {
                //初始化一个同等大小的单位阵
                Matrix res = _thisCopy.EMatrix();
                for (int i = 0; i < rows; i++)
                {
                    //首先找到第i列的绝对值最大的数，并将该行和第i行互换
                    int rowMax = i;
                    double max = Math.Abs(_thisCopy[i, i]);
                    for (int j = i; j < rows; j++)
                    {
                        if (Math.Abs(_thisCopy[j, i]) > max)
                        {
                            rowMax = j;
                            max = Math.Abs(_thisCopy[j, i]);
                        }
                    }
                    //将第i行和找到最大数那一行rowMax交换
                    if (rowMax != i)
                    {
                        _thisCopy.Exchange(i, rowMax);
                        res.Exchange(i, rowMax);

                    }
                    //将第i行做初等行变换，将第一个非0元素化为1
                    double r = 1.0 / _thisCopy[i, i];
                    _thisCopy.Exchange(i, -1, r);
                    res.Exchange(i, -1, r);
                    //消元
                    for (int j = 0; j < rows; j++)
                    {
                        //到本行后跳过
                        if (j == i)
                            continue;
                        else
                        {
                            r = -_thisCopy[j, i];
                            _thisCopy.Exchange(i, j, r);
                            res.Exchange(i, j, r);
                        }
                    }
                }
                return res;
            }
            else
            {
                throw new Exception("矩阵不是方阵无法求逆");
            }
        }
        #region 重载比较运算符
        public static bool operator <(Matrix a, Matrix b)
        {
            bool issmall = true;
            for (int i = 0; i < a.Rows; i++)
            {
                for (int j = 0; j < a.Cols; j++)
                {
                    if (a[i, j] >= b[i, j]) issmall = false;
                }
            }
            return issmall;
        }
        public static bool operator >(Matrix a, Matrix b)
        {
            bool issmall = true;
            for (int i = 0; i < a.Rows; i++)
            {
                for (int j = 0; j < a.Cols; j++)
                {
                    if (a[i, j] <= b[i, j]) issmall = false;
                }
            }
            return issmall;
        }
        public static bool operator <=(Matrix a, Matrix b)
        {
            bool issmall = true;
            for (int i = 0; i < a.Rows; i++)
            {
                for (int j = 0; j < a.Cols; j++)
                {
                    if (a[i, j] > b[i, j]) issmall = false;
                }
            }
            return issmall;
        }
        public static bool operator >=(Matrix a, Matrix b)
        {
            bool issmall = true;
            for (int i = 0; i < a.Rows; i++)
            {
                for (int j = 0; j < a.Cols; j++)
                {
                    if (a[i, j] < b[i, j]) issmall = false;
                }
            }
            return issmall;
        }
        public static bool operator !=(Matrix a, Matrix b)
        {
            bool issmall = true;
            issmall = ReferenceEquals(a, b);
            if (issmall) return issmall;
            for (int i = 0; i < a.Rows; i++)
            {
                for (int j = 0; j < a.Cols; j++)
                {
                    if (a[i, j] == b[i, j]) issmall = false;
                }
            }
            return issmall;
        }
        public static bool operator ==(Matrix a, Matrix b)
        {
            bool issmall = true;
            issmall = ReferenceEquals(a, b);
            if (issmall) return issmall;
            for (int i = 0; i < a.Rows; i++)
            {
                for (int j = 0; j < a.Cols; j++)
                {
                    if (a[i, j] != b[i, j]) issmall = false;
                }
            }
            return issmall;
        }
        public override bool Equals(object obj)
        {
            Matrix b = obj as Matrix;
            return this == b;
        }
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
        #endregion
        public double Determinant()
        {
            if (cols == rows)
            {
                Matrix _thisCopy = this.DeepCopy();
                //行列式每次交换行，都需要乘以-1
                double res = 1;
                for (int i = 0; i < rows; i++)
                {
                    //首先找到第i列的绝对值最大的数
                    int rowMax = i;
                    double max = Math.Abs(_thisCopy[i, i]);
                    for (int j = i; j < rows; j++)
                    {
                        if (Math.Abs(_thisCopy[j, i]) > max)
                        {
                            rowMax = j;
                            max = Math.Abs(_thisCopy[j, i]);
                        }
                    }
                    //将第i行和找到最大数那一行rowMax交换,同时将单位阵做相同初等变换
                    if (rowMax != i)
                    {
                        _thisCopy.Exchange(i, rowMax);
                        res *= -1;
                    }
                    //消元
                    for (int j = i + 1; j < rows; j++)
                    {
                        double r = -_thisCopy[j, i] / _thisCopy[i, i];
                        _thisCopy.Exchange(i, j, r);
                    }
                }
                //计算对角线乘积
                for (int i = 0; i < rows; i++)
                {
                    res *= _thisCopy[i, i];
                }
                return res;
            }
            else
            {
                throw new Exception("不是行列式");
            }
        }
        #endregion
        #region 初等变换
        /// <summary>
        /// 初等变换：交换第r1和第r2行
        /// </summary>
        /// <param name="r1">第r1行</param>
        /// <param name="r2">第r2行</param>
        /// <returns>返回交换两行后的新的矩阵</returns>
        public Matrix Exchange(int r1, int r2)
        {
            if (Math.Min(r2, r1) >= 0 && Math.Max(r1, r2) < rows)
            {
                for (int j = 0; j < cols; j++)
                {
                    double temp = this[r1, j];
                    this[r1, j] = this[r2, j];
                    this[r2, j] = temp;
                }
                return this;
            }
            else
            {
                throw new Exception("超出索引");
            }
        }
        /// <summary>
        /// 初等变换：将r1行乘以某个数加到r2行
        /// </summary>
        /// <param name="r1">第r1行乘以num</param>
        /// <param name="r2">加到第r2行，若第r2行为负，则直接将r1乘以num并返回</param>
        /// <param name="num">某行放大的倍数</param>
        /// <returns></returns>
        public Matrix Exchange(int r1, int r2, double num)
        {
            if (Math.Min(r2, r1) >= 0 && Math.Max(r1, r2) < rows)
            {
                for (int j = 0; j < cols; j++)
                {
                    this[r2, j] += this[r1, j] * num;
                }
                return this;
            }
            else if (r2 < 0)
            {
                for (int j = 0; j < cols; j++)
                {
                    this[r1, j] *= num;
                }
                return this;
            }
            else
            {
                throw new Exception("超出索引");
            }
        }
        /// <summary>
        /// 得到一个同等大小的单位矩阵
        /// </summary>
        /// <returns>返回一个同等大小的单位矩阵</returns>
        public Matrix EMatrix()
        {
            if (rows == cols)
            {
                double[,] res = new double[rows, cols];
                for (int i = 0; i < rows; i++)
                {
                    for (int j = 0; j < cols; j++)
                    {
                        if (i == j)
                            res[i, j] = 1;
                        else
                            res[i, j] = 0;
                    }
                }
                return new Matrix(res);
            }
            else
                throw new Exception("不是方阵，无法得到单位矩阵");
        }
        #endregion
        /// <summary>
        /// 深拷贝，仅仅将值拷贝给一个新的对象
        /// </summary>
        /// <returns>返回深拷贝后的新对象</returns>
        public Matrix DeepCopy()
        {
            double[,] ele = new double[rows, cols];
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    ele[i, j] = this[i, j];
                }
            }
            return new Matrix(ele);
        }
        /// <summary>
        ///         返回一个伪随机数
        /// </summary>
        /// <returns></returns>
        public static double GetRandomNum()
        {
            Random ran = new Random(Guid.NewGuid().GetHashCode());
            return ran.NextDouble();
        }

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

四.小结

这个矩阵类是根据我个人的习惯进行编写的，我平时比较喜欢用Python编写矩阵，所以在一些函数的命名上和Python基本相同，这个矩阵类目前还有许多地方可以进行改进，比如element这个成员变量如何进行优化，还有传数组是以地址形式，相对比较不安全，以及本矩阵类在一些功能上还不完整，比如求行列式还没有写，希望大家可以互相讨论，有需要的可以根据自己的情况在这个基础上进行改进。

 

 

 

武者小路
关注
  • 25
    点赞
  • 踩
  • 71
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通过C#实现矩阵求逆-简单版
Ratatoskr_01的博客
12-02 1371
原理简单的C#求逆方法
C#完成Matrix类的定义
m0_58251664的博客
10-11 1233
/构造函数，column是矩阵列数，row是矩阵行数，initial是所有矩阵元素的初始值，//默认为零。// RowMajore为True表示行优先存储，RowMajore为False表示列优先存储。//行优先存储或列优先。//构造函数，column是矩阵列数，row是矩阵行数，values是矩阵元素的初始值，protected double[] _elements;一、完成Matrix类的定义。//获取方阵的行列式值。
C# 中的一些矩阵运算方法
helldoger的博客
06-10 1704
【代码】C# 中的一些矩阵运算方法。
C#简单的矩阵类并实现基本的矩阵运算
最新发布
wddblog的博客
04-13 435
在C#中，你可以通过创建自定义类或使用现有的库（如MathNet.Numerics）来实现矩阵计算。下面是一个简单的例子，说明如何创建一个简单的矩阵类并实现基本的矩阵运算。类来表示矩阵，并提供基本的矩阵操作，如加法、乘法和转置。然后，你可以这样使用你的。
MathNet.Numerics中的矩阵及其运算的简单整理
热门推荐
steven_lenny的博客
03-06 1万+
1.不支持空矩阵和空向量，不支持int型矩阵。 2.推荐将多个向量用集合存放，而不是组成矩阵（除非有组成矩阵的必要） 3…NET3.0之后支持lambda表达式，可以用于Dense函数的入参中，dense及稠密矩阵创建。 // 3x4 dense matrix filled with zeros M.Dense(3, 4); // 3x4 dense matrix filled with 1.0...
数据结构-C#实现矩阵的旋转
rail1000的博客
11-18 203
旋转矩阵，第一行变为最后一列，第二行变为倒数第二列，以此类推，最后一行变为第一列。再分析其坐标变化规律，可以发现，[0,0]变为[0,2],[0,1]变为[1,2]，[0,2]变为[2,2]，由此可以看出，第一行变为最后一列时，列的索引保持为length-1-i，而行索引则从0递增，而再观察第二行，第三行均有此规律。由此便可以新增一个空白矩阵，在两次循环中将变化的数据按照变化规律给写入即可。2.不新增数据，直接在矩阵里面变换坐标。
稀疏矩阵的快速转制c语言代码_有限元方法：从代码入手(4)
weixin_29743937的博客
12-18 427
稀疏矩阵的封装由有限元方法获得的单元刚度矩阵通常与单个单元相关联。这样单元矩阵与有限个单元节点相互关联，由这些单元矩阵组装成的全局矩阵就含有大量的非零元，即稀疏矩阵。为了节省存储内存，通常仅仅存储非零元的信息。稀疏矩阵的具有多种存储格式，包括行主元存储，列主元存储，坐标存储格式。在这里封装时，仅仅对CSR格式的稀疏阵进行封装。以上图所示的稀疏矩阵为例，在存储的时候，需要一个名为Value的数组存储...
fast-python-src-1.0.zip_python_python C#_python matlab
09-14
描述提到，这个实现不仅限于Python，还包括C#和MATLAB的版本。标签进一步确认了这一点，提到了"python"、"python_c#"和"python_matlab"，暗示了这些编程语言的交叉应用。 在深入探讨之前，首先理解"fast特征"是什么...
New folder (4)_C#_matlab_python_
10-01
标题中的"New folder (4)_C#_matlab_python_"暗示了这个压缩包可能包含与C#、MATLAB和Python编程相关的代码或项目。描述提到"requesting to upload my code"，表明这是一个用户想要分享或者寻求帮助的代码集合，可能...
MATLAB中的矩阵运算.ppt
04-07
包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。【项目质量】：所有源码都经过严格测试，可以直接运行。功能在确认正常工作后才上传。【适用人群】：适用...
C#自编矩阵运算库，弥补C#缺少矩阵运算相关库的不足
09-17
为了弥补这一不足，开发者自编了一个C#矩阵运算库，名为Matrix.dll。这个库的目的是为了方便那些需要在C#项目中进行矩阵运算的程序员，让他们能够更加高效地进行科学计算和数据分析。 Matrix.dll库的核心是实现了...
呕心沥血之作。C#矩阵类（matrix）
05-27
c#封装的矩阵类，好东西不要嫌贵，本人创作它的时候四处都找不到全面的参考资料，我第一个创作出来自然贵点，包含了矩阵的+ - *运算符重载，方程求解gass完全主元法，JACIBO叠带法，GassSeid叠带法，矩阵的LU，QR，奇异分解，矩阵求逆（3种方法包括复矩阵），矩阵特征值，特征向量求法，化矩阵为Herbeg矩阵，怎么样全面吧
C#用矩阵运算（实现3x3矩阵求逆）
02-06
定义了一个矩阵的储存方法CMatrix 定义了一个矩阵的预算方法CMatrix_Operation 代码可以实现以下功能： 1.矩阵加法 2.矩阵减法 3.矩阵乘法 4.矩阵行列式 5.矩阵转置 6.矩阵的伴随矩阵 7.矩阵的逆（只限于3x3） 8.向量的单位化 此代码为本人做3D建模(空间旋转)时用的基础代码
C#的矩阵类，包含矩阵的各种运算
05-25
C#的矩阵类，包含矩阵的加减乘除，求逆，转置，赋值等
C# Matrix 矩阵 运算 类
07-16
别再下载这个了，我都觉得丢人，请使用math.net #这是自己编的矩阵类，所有的输入矩阵都是二维矩阵。#
C# 矩阵运算（实数+复数）
11-28
c#实现实数和复数的常用矩阵运算（矩阵乘、数乘、求逆、卷积、产生服从正态分布的随机数）
基于PCA的掌纹识别系统,PCA算法用Matlab实现，然后将算法用DLL封装，c#做桌面实现GUI.zip
03-12
6. **集成能力**：MATLAB可以与其他编程语言（如C、C++、Java、Python等）及外部应用程序进行数据交换和联合开发，也可以调用硬件接口进行实时实验和控制。 7. **交互式工作空间**：用户可以在命令窗口中直接输入...
C#的矩阵类
LanQiuChaoRen的专栏
07-13 6612
由于课程设计选的题目是基于神经网络的综合评价，利用暑假时间用C#实现的bp神经网络。此bp神经网络包含1个隐藏层，其中输入层，隐藏层，输出层个数都可以根据需要更改。
矩阵类的C#代码
数学算子的天地
10-01 1万+
    今天是国庆节，祝贺我们的祖国越来越昌盛！我把以前编写的矩阵类的C#代码贴出来与大家共享，有不对的地方多提宝贵意见哟。本贴如果转帖一定要注明出处呀！namespace Maths{ using System; using System.Text; using Maths.Statistic; ///  /// 这是一个实矩阵类，矩阵大小可更改 ///  /// 功能如下： /// （1）矩阵
C#矩阵乘法运算符重载
09-02
在C#中，可以通过重载运算符来实现矩阵的乘法运算符重载。通过重载乘法运算符，我们可以实现两个矩阵对象之间的乘法操作。重载乘法运算符的方法是在类中定义一个名为"operator*"的方法。该方法接受两个矩阵对象作为参数，并返回一个新的矩阵对象，表示两个矩阵的乘法结果。 下面是一个示例代码，展示了如何在C#中重载矩阵乘法运算符： ```csharp public class Matrix { // 矩阵的行数和列数 private int rows; private int columns; // 矩阵的数据 private int[,] data; // 构造函数 public Matrix(int rows, int columns) { this.rows = rows; this.columns = columns; this.data = new int * matrix2.data[k, j]; } result.data[i, j = sum; } } return result; } } // 示例用法 Matrix matrix1 = new Matrix(2, 3); Matrix matrix2 = new Matrix(3, 2); Matrix result = matrix1 * matrix2; ``` 在上面的示例中，我们定义了一个名为Matrix的类，其中包含了重载乘法运算符的方法。在使用时，我们可以创建两个矩阵对象matrix1和matrix2，并通过乘法运算符*将它们相乘得到结果矩阵result。 请注意，为了进行矩阵乘法运算，我们需要确保第一个矩阵的列数与第二个矩阵的行数相等。如果不满足这个条件，就无法进行矩阵乘法运算。 以上是关于C#矩阵乘法运算符重载的解释和示例代码。希望对你有帮助！<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [C#运算符重载](https://blog.csdn.net/q269399361/article/details/52924869)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [C#中运算符重载](https://blog.csdn.net/cloproad/article/details/79028076)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值