C#矩阵运算类

最新推荐文章于 2024-04-13 21:45:41 发布
最新推荐文章于 2024-04-13 21:45:41 发布
阅读量2.9k 收藏 20
点赞数 4
分类专栏： C++与Qt开发专栏 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dododododoooo/article/details/103706710
版权

命名空间：matrix
定义类：Matrix
方法：
public Matrix(int mm, int nn)
定义矩阵A:
Matrix A=new Matrix(int mm, int nn);

public double read(int i, int j)
获取Aij:
A.read(i,j);

public int write(int i, int j, double val)
将数据b写入Aij:
A.read(i,j,b);

释放矩阵：
public void freeMatrix()
A.freeMatrix();

方法：
//C = A + B
//成功返回1,失败返回-1
public int add(ref Matrix A, ref Matrix B, ref Matrix C)

//C = A - B
//成功返回1,失败返回-1
public int subtract(ref Matrix A, ref Matrix B, ref Matrix C)

//C = A * B
//成功返回1,失败返回-1
public int multiply(ref Matrix A, ref Matrix B, ref Matrix C)

//行列式的值,只能计算2 * 2,3 * 3
//失败返回-31415,成功返回值
public double det(ref Matrix A)

//求转置矩阵,B = AT
//成功返回1,失败返回-1
public int transpos(ref Matrix A, ref Matrix B)

//求逆矩阵,B = A^(-1)
//成功返回1,失败返回-1
public int inverse(ref Matrix A, ref Matrix B)

//矩阵输出//
public string Out(ref Matrix A)

//矩阵格式化输出//
public string Outt(ref Matrix A, string format)

//矩阵一维数组赋值//
public void Fuzhi( ref Matrix A , double[] arr)

//方阵行列式值//
public double Det(ref Matrix A)

//矩阵的伴随矩阵//
public void Accompany(ref Matrix A, ref Matrix B)

//伴随矩阵法求矩阵的逆//
public void Inverse(ref Matrix A, ref Matrix B)

//矩阵相等//
public void Equal(ref Matrix A, ref Matrix B)

//C = A + B
//成功返回1,失败返回-1
A.add(ref Matrix A, ref Matrix B, ref Matrix C);
//C = A - B
//成功返回1,失败返回-1
A.subtract(ref Matrix A, ref Matrix B, ref Matrix C)

//C = A * B
//成功返回1,失败返回-1
A.multiply(ref Matrix A, ref Matrix B, ref Matrix C)

//行列式的值,只能计算2 * 2,3 * 3
//失败返回-31415,成功返回值
A.det(ref Matrix A)

//求转置矩阵,B = AT
//成功返回1,失败返回-1
A.transpos(ref Matrix A, ref Matrix B)

//求逆矩阵,B = A^(-1)
//成功返回1,失败返回-1
A.inverse(ref Matrix A, ref Matrix B)

//矩阵输出//
A.Out(ref Matrix A)
//矩阵6位小数输出//
A.Outt(ref Matrix A)

//矩阵一维数组赋值//
A.Fuzhi( ref Matrix A , double[] arr)

//方阵行列式值//
A.Det(ref Matrix A)

//矩阵格式化输出//
public string Outt(ref Matrix A, string format)
A.Outt(ref Matrix A, string format);

//矩阵的伴随矩阵//
public void Accompany(ref Matrix A, ref Matrix B)
A.Accompany(ref Matrix A, ref Matrix B);

//伴随矩阵法求矩阵的逆//
public void Inverse(ref Matrix A, ref Matrix B)
A.Inverse(ref Matrix A, ref Matrix B);

//矩阵相等//
public void Equal(ref Matrix A, ref Matrix B)
A.Equal(ref Matrix A, ref Matrix B);

格式说明符说明 示例 输出

C 货币 2.5.ToString(“C”) ￥2.50

D 十进制数 25.ToString(“D5”) 00025

E 科学型 25000.ToString(“E”) 2.500000E+005

F 固定点 25.ToString(“F2”) 25.00

G 常规 2.5.ToString(“G”) 2.5

N 数字 2500000.ToString(“N”) 2,500,000.00

X 十六进制 255.ToString(“X”) FF

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

namespace matrix
{

    //矩阵数据结构  
    //二维矩阵  
    public class Matrix
    {
        public int m;
        public int n;
        public double[] arr;

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

        public Matrix(int mm, int nn)
        {
            m = mm;
            n = nn;
            arr = new double[m * n];
        }

        //设置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 initMatrix()
        {
            arr = new double[m * n];
        }

        //释放  
        public void freeMatrix()
        {
            //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;
        }


        //二维运算类  

        //初始化
     

        //C = A + B  
        //成功返回1,失败返回-1  
        public int add(ref Matrix A, ref Matrix B, ref Matrix C)
        {
            int i = 0;
            int j = 0;

            //判断是否可以运算  
            if (A.m != B.m || A.n != B.n ||
                A.m != C.m || A.n != C.n)
            {
                return -1;
            }
            //运算  
            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 1;
        }

        //C = A - B  
        //成功返回1,失败返回-1  
        public int subtract(ref Matrix A, ref Matrix B, ref Matrix C)
        {
            int i = 0;
            int j = 0;

            //判断是否可以运算  
            if (A.m != B.m || A.n != B.n ||
                A.m != C.m || A.n != C.n)
            {
                return -1;
            }
            //运算  
            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 1;
        }

        //C = A * B  
        //成功返回1,失败返回-1  
        public int multiply(ref Matrix A, ref Matrix B, ref Matrix C)
        {
            int i = 0;
            int j = 0;
            int k = 0;
            double temp = 0;

            //判断是否可以运算  
            if (A.m != C.m || B.n != C.n ||
                A.n != B.m)
            {
                return -1;
            }
            //运算  
            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 1;
        }

        //行列式的值,只能计算2 * 2,3 * 3  
        //失败返回-31415,成功返回值  
        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;
        }

        //求转置矩阵,B = AT  
        //成功返回1,失败返回-1  
        public int transpos(ref Matrix A, ref Matrix B)
        {
            int i = 0;
            int j = 0;

            //判断是否可以运算  
            if (A.m != B.n || A.n != B.m)
            {
                return -1;
            }
            //运算  
            for (i = 0; i < B.m; i++)
            {
                for (j = 0; j < B.n; j++)
                {
                    B.write(i, j, A.read(j, i));
                }
            }

            return 1;
        }

        //求逆矩阵,B = A^(-1)  
        //成功返回1,失败返回-1  
        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.initMatrix();
            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.freeMatrix();

            return 1;
        }
        //矩阵输出//
        public string Out(ref Matrix A)
        {
            string s = null;
            int i, j;
            for (i = 0; i < A.m; i++)
            {
                for (j = 0; j < A.n; j++)
                    s += A.read(i, j).ToString() + "    ";
                s += "\r\n";
            }
            return s;

        }
        public string Outt(ref Matrix A, string format)
        {
            string s = null, m = null;
            m = "{" + "0:" + format + "}";
            int i, j;
            for (i = 0; i < A.m; i++)
            {
                for (j = 0; j < A.n; j++)
                    s += A.read(i, j).ToString(format) + "    ";
                s += "\r\n";
            }
            return s;

        }
        public void Fuzhi(ref Matrix A, double[] arr)
        {
            int i, j, k = 0;
            for (i = 0; i < A.m; i++)
            {
                for (j = 0; j < A.n; j++)
                    A.write(i, j, arr[k++]);

            }

        }

        public void Accompany(ref Matrix A, ref Matrix B)
        {
            int m = 0; int n = 0;
            Matrix Q = new Matrix(A.m - 1, A.n - 1);//用于求伴随矩阵过程中过渡矩阵//
            //Matrix_Calc C = new Matrix_Calc();
            for (int i = 0; i < A.m; i++)
                for (int j = 0; j < A.n; j++)//遍历矩阵A中元素//
                {
                    for (int p = 0; p < A.m - 1; p++)
                    {
                        for (int q = 0; q < A.n - 1; q++)//写入过渡矩阵//                             
                        {
                            if (m == i)
                                m++;
                            if (n == j)
                                n++;
                            Q.write(p, q, A.read(m, n++));
                        }
                        n = 0;
                        m++;
                    }
                    //   Console.Write("\r\n   {0}    \r\n",C.Out(ref Q));//验证过渡矩阵结果是否正确//
                    m = 0; n = 0;
                    B.write(i, j, Math.Pow(-1.0, Convert.ToDouble(i + j)) * Q.Det(ref Q));
                }
            //  Console.Write("\r\n   {0}    \r\n", C.Out(ref B));//验证伴随矩阵结果是否正确//
        }
        public void Inverse(ref Matrix A, ref Matrix B)
        {
            //Matrix_Calc Q = new Matrix_Calc();
            Matrix C = new Matrix(A.m, A.n);
            C.Accompany(ref A, ref C);
            for (int i = 0; i < A.m; i++)
                for (int j = 0; j < A.n; j++)
                    B.write(i, j, C.read(i, j) / C.Det(ref A));
           // Console.Write("{0}", C.Out(ref B));//验证逆阵结果
        }
        public void Equal(ref Matrix A, ref Matrix B)
        {
            for (int i = 0; i < A.m; i++)
                for (int j = 0; j < A.n; j++)
                    B.write(i, j, A.read(i, j));
        }
        public double Det(ref Matrix A)
        {
            Matrix R = new Matrix(A.m, A.n);
            R.Equal(ref A, ref R);
            // string s = null;
            double f = 0.0;
            int j, n = 0;
            double B, D;
            double[] huanhangi = new double[A.n];//定义一个交换行的中间数组//
            double[] huanhangj = new double[A.n];//定义一个交换行的中间数组//
            n = A.m;
            for (j = 0; j < n - 1; j++)
            {
                if (A.read(j, j) == 0)
                {
                    for (int i = j; i < A.m;)
                    {
                        if (A.read(i, j) == 0)
                            i++;//往下找不为零的元素

                        if (A.read(i, j) != 0)
                        {
                            for (int l = 0; l < A.n; l++)
                            {
                                huanhangi[l] = A.read(i, l);
                                huanhangj[l] = A.read(j, l);
                                A.write(j, l, huanhangi[l]);
                                A.write(i, l, huanhangj[l]);
                                //交换第i行和第j行//
                                //  Console.Write("换行i：{0}     ", huanhangi[l]);
                                //  Console.Write("换行j：{0}     ", huanhangj[l]);    
                                f++;//记录交换多少次//
                            }
                            break;

                        }       //如果第i行不为零，则交换i，j两行//
                        if (i == A.m)
                            return 0;//如果以下都为零则行列式为零//
                    }
                }
                int k = j + 1; int m = j;//行变换元素之间对应关系
                for (; k < n; k++)
                {
                    D = A.read(k, j) / A.read(j, j);
                    for (; m < n; m++)
                    {
                        //Matrix_Calc C = new Matrix_Calc();
                        // String S = null;  //初始化对象

                        B = A.read(k, m) - A.read(j, m) * D;
                        A.write(k, m, B);
                        // Console.Write("\r\n {0} \r\n", A.Out(ref A));//观察矩阵运行变化

                        //   Console.Write("\r\n {0} {1} {2} \r\n", j, k, m); //观察变量是否符合要求

                    }
                    m = j;//注意如果不重新置m,k内循环将不会继续
                }
                k = j + 1;//同上原理                  
            }
            double result = 1;
            for (int Q = 0; Q < A.n; Q++)
                result *= Math.Pow(-1.0, f) * A.read(Q, Q);
            R.Equal(ref R, ref A);//将A变回原来形式//
            return result;


        }
        public void Shangsanjiao(ref Matrix A)
        {
            int j, n = 0;

            double C, D;
            double[] huanhangi = new double[A.n];//定义一个交换行的中间数组//
            double[] huanhangj = new double[A.n];//定义一个交换行的中间数组//
            n = A.m;
            for (j = 0; j < n - 1; j++)
            {
                if (A.read(j, j) == 0)
                {
                    for (int i = j; i < A.m;)
                    {
                        if (A.read(i, j) == 0)
                            i++;//往下找不为零的元素

                        if (A.read(i, j) != 0)
                        {
                            for (int l = 0; l < A.n; l++)
                            {
                                huanhangi[l] = A.read(i, l);
                                huanhangj[l] = A.read(j, l);
                                A.write(j, l, huanhangi[l]);
                                A.write(i, l, huanhangj[l]);
                                //交换第i行和第j行//
                                //  Console.Write("换行i：{0}     ", huanhangi[l]);
                                //  Console.Write("换行j：{0}     ", huanhangj[l]); 

                            }
                            break;

                        }       //如果第i行不为零，则交换i，j两行//
                        if (i == A.m)
                            j++;//如果以下都为零则行列式为零//
                    }
                }
                int k = j + 1; int m = j;//行变换元素之间对应关系
                for (; k < n; k++)
                {
                    D = A.read(k, j) / A.read(j, j);
                    for (; m < n; m++)
                    {
                        //Matrix_Calc C = new Matrix_Calc();
                        // String S = null;  //初始化对象

                        C = A.read(k, m) - A.read(j, m) * D;
                        A.write(k, m, C);
                        //  Console.Write("\r\n {0} \r\n", C.Out(ref A));//观察矩阵运行变化

                        //   Console.Write("\r\n {0} {1} {2} \r\n", j, k, m); //观察变量是否符合要求

                    }
                    m = j;//注意如果不重新置m,k内循环将不会继续
                }
                k = j + 1;//同上原理
            }
        }
    }
}
dododododoooo
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# Matrix 矩阵 运算 类
07-16
别再下载这个了，我都觉得丢人，请使用math.net #这是自己编的矩阵类，所有的输入矩阵都是二维矩阵。#
c#矩阵运算库
07-20
可用于定义矩阵，并进行常用的矩阵运算
C#使用MathNet库进行矩阵运算
热门推荐
万里归来少年心
05-15 1万+
Math.net计算库是专为.NET开发的开源科学计算库。包含了大部分矩阵运算、线性运算等功能。 1.安装 项目 - 右键 - 管理NuGet程序包 2.矩阵定义 //矩阵的定义和初始化 var matrix1 = new DenseMatrix(3); //3维方阵 var matrix2 = new DenseMatrix(2, 2); //2维方阵 va...
C#矩阵运算类库 -- 一些补充
Thomas会写字
10-13 1057
重点补充，发现原类中没有深度复制（也许是我没找到。。。） 于是修改如下 MatrixAlgebra -->Matrix.cs -->Initialize函数 private void Initialize(double[,] Elements) { elements = Elements.CopyMatrix(); SubMat = new MatrixSubset(elements); ...
C#简单的矩阵类并实现基本的矩阵运算
最新发布
wddblog的博客
04-13 439
在C#中，你可以通过创建自定义类或使用现有的库（如MathNet.Numerics）来实现矩阵计算。下面是一个简单的例子，说明如何创建一个简单的矩阵类并实现基本的矩阵运算。类来表示矩阵，并提供基本的矩阵操作，如加法、乘法和转置。然后，你可以这样使用你的。
C#矩阵运算类库
aiiok4600的博客
07-26 1181
这个类库是本人参考许多相关资料之后做出的C#矩阵运算类库，因为C#的数值计算库相对比较少，所以希望这个类库能够给大家带来一些帮助。 源码github网址：https://github.com/JoshuaHe2015/MatrixLibrary 功能介绍：（持续更新中） 1、矩阵的基本运算： 　　矩阵的加、减、乘、除、求逆、求幂、求秩、求行列式、转置。运算包括矩阵与矩阵的运算，矩...
C# 中的一些矩阵运算方法
helldoger的博客
06-10 1715
【代码】C# 中的一些矩阵运算方法。
C#中矩阵运算方法实例分析
09-03
在实际项目中，这样的矩阵运算类可以与其他代码配合使用，例如，处理图像处理中的像素操作，或者在物理模拟中计算力的传递。开发者可以根据需求扩展这个类，添加更多如矩阵的标量乘法、矩阵的幂、迹、行列式等高级...
C#实现矩阵运算大全MatrixCalculate.cs
06-12
该文件中包含了各种数组运算，都是用C#语言编写，有矩阵的转置；求逆矩阵；两个矩阵相乘，相加，相减；构造单位对角矩阵；矩阵否相等；托伯利兹矩阵求逆的埃兰特方法；求行列式值的全选主元高斯消去法；求矩阵秩的...
C#自编矩阵运算库，弥补C#缺少矩阵运算相关库的不足
09-17
为了弥补这一不足，开发者自编了一个C#矩阵运算库，名为Matrix.dll。这个库的目的是为了方便那些需要在C#项目中进行矩阵运算的程序员，让他们能够更加高效地进行科学计算和数据分析。 Matrix.dll库的核心是实现了...
C# 矩阵算法
06-03
C# 矩阵算法 .net 矩阵算法。C#矩阵运算类。实现转置,相乘,相加,求逆。
用c#编写的矩阵类，可进行矩阵的各项科学计算
03-08
这是一个用c#语言写成的矩阵类，可以完成矩阵的各种准确的数学计算，如：矩阵的加减乘除、转置、逆运算、 复矩阵的乘法、求行列式值、 求矩阵秩、一般实矩阵的奇异值分解、求广义逆、约化对称矩阵为对称三对角阵、实对称三对角阵的全部特征值与特征向量的计算、求赫申伯格矩阵全部特征值、求实对称矩阵特征值与特征向量等.可以将其做成dll用到其他的环境下。填补了.net中没有矩阵的空白，是你进行科学计算不可或缺的插件之一。
C#有关矩阵运算
10-29
矩阵运算包括转置、求逆、相乘，没有使用类，完全使用方法调用
dotnet矩阵类库matrix_src
07-16
dotnet矩阵类库matrix_src
Matrix-Calculator-using-csharp:csharp，ui的矩阵计算法是什么
05-18
矩阵计算器使用锐化 csharp的矩阵计算器，UI为中文。 如果您在使用时遇到问题，请随时与我联系。
Matlab提速方法-转
z18607005331的博客
05-05 5525
用过Matlab的人都知道，Matlab是一种解释性语言，存在计算速度慢的问题，为了提高程序的运行效率，matlab提供了多种实用工具及编码技巧。 循环矢量化 Matlab是为矢量和矩阵操作而设计的，因此，可以通过矢量化方法加速M文件的运行。矢量化是指将for循环和while循环转换为等价的矢量或矩阵操作。下面给出一个循环的例子： i=0; for n = 0:0.1:1000 i=i+1; ...
C#基础知识学习——数组与动态数组(初始化、方法)、字符串 （三）
weixin_45496521的博客
10-09 1031
数组与字符串
【笔记】bool类型 和 矩阵的常规操作：降成一维、并将True的元素输出
nyist_yangguang的博客
07-28 264
eg1: eg2:
C＃计算矩阵运算除法
05-27
在C#中，可以使用MathNet库来进行矩阵运算。要进行矩阵除法，可以使用Matrix类的Divide方法。 首先，需要将原始矩阵和除数矩阵作为两个Matrix对象进行创建。假设原始矩阵为matrixA，除数矩阵为matrixB，下面的代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值