矩阵实现，C#

最新推荐文章于 2024-04-13 21:45:41 发布
最新推荐文章于 2024-04-13 21:45:41 发布
阅读量2.3k 收藏 8
点赞数 2
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nova565/article/details/104677257
版权

0、引言

C#提供了矩阵函数库MathNet，可以方便进行矩阵的相关运算，包括：矩阵加、减、乘、除等，以及矩阵的转置。使用时，只需通过NuGet加载该函数库到项目中即可。

一、具体实现

1、获取T矩阵

    private static List<double[]> GetT(Form1 form1)
    {
        List<double[]> list = new List<double[]>();

        int l1 = 0, l2 = 0, l3 = 0, m1 = 1, m2 = 1, m3 = 1, n1 = 0, n2 = 0, n3 = 0;
        l1 = int.Parse(form1.textBox_l1.Text);
        l2 = int.Parse(form1.textBox_l2.Text);
        l3 = int.Parse(form1.textBox_l3.Text);
        m1 = int.Parse(form1.textBox_m1.Text);
        m2 = int.Parse(form1.textBox_m2.Text);
        m3 = int.Parse(form1.textBox_m3.Text);
        n1 = int.Parse(form1.textBox_n1.Text);
        n2 = int.Parse(form1.textBox_n2.Text);
        n3 = int.Parse(form1.textBox_n3.Text);

        double[] t1 = {
                        l1 * l1, m1 * m1, n1 * n1, m1 * n1, l1 * n1, l1 * m1,
                        l2 * l2, m2 * m2, n1 * n2, m2 * n2, l2 * n2, l2 * m2,
                        l3 * l3, m3 * m3, n3 * n3, m3 * n3, l3 * n3, l3 * m3,
                        2 * l2 * l3, 2 * m2 * m3, 2 * n2 * n3,m2 * n3 + m3 * n2, l2 * n3 + l3 * n2, l2 * m3 + l3 * m2,
                        2 * l1 * l3, 2 * m1 * m3, 2 * n2 * n3,m1 * n3 + m3 * n1, l1 * n3 + l3 * n1, l1 * m3 + l3 * m1,
                        2 * l1 * l2, 2 * m1 * m2, 2 * n1 * n2,m1 * n2 + m2 * n1, l1 * n2 + l2 * n1, l1 * m2 + l2 * m1,
                       };


        l1 = int.Parse(form1.textBox_l4.Text);
        l2 = int.Parse(form1.textBox_l5.Text);
        l3 = int.Parse(form1.textBox_l6.Text);
        m1 = int.Parse(form1.textBox_m4.Text);
        m2 = int.Parse(form1.textBox_m5.Text);
        m3 = int.Parse(form1.textBox_m6.Text);
        n1 = int.Parse(form1.textBox_n4.Text);
        n2 = int.Parse(form1.textBox_n5.Text);
        n3 = int.Parse(form1.textBox_n6.Text);

        double[] t2 = {
                        l1 * l1, m1 * m1, n1 * n1, m1 * n1, l1 * n1, l1 * m1,
                        l2 * l2, m2 * m2, n1 * n2, m2 * n2, l2 * n2, l2 * m2,
                        l3 * l3, m3 * m3, n3 * n3, m3 * n3, l3 * n3, l3 * m3,
                        2 * l2 * l3, 2 * m2 * m3, 2 * n2 * n3,m2 * n3 + m3 * n2, l2 * n3 + l3 * n2, l2 * m3 + l3 * m2,
                        2 * l1 * l3, 2 * m1 * m3, 2 * n2 * n3,m1 * n3 + m3 * n1, l1 * n3 + l3 * n1, l1 * m3 + l3 * m1,
                        2 * l1 * l2, 2 * m1 * m2, 2 * n1 * n2,m1 * n2 + m2 * n1, l1 * n2 + l2 * n1, l1 * m2 + l2 * m1,
                       };


        l1 = 1;
        l2 = 0;
        l3 = 0;
        m1 = 0;
        m2 = 1;
        m3 = 0;
        n1 = 0;
        n2 = 0;
        n3 = 1;

        double[] t3 = {
                        l1 * l1, m1 * m1, n1 * n1, m1 * n1, l1 * n1, l1 * m1,
                        l2 * l2, m2 * m2, n1 * n2, m2 * n2, l2 * n2, l2 * m2,
                        l3 * l3, m3 * m3, n3 * n3, m3 * n3, l3 * n3, l3 * m3,
                        2 * l2 * l3, 2 * m2 * m3, 2 * n2 * n3,m2 * n3 + m3 * n2, l2 * n3 + l3 * n2, l2 * m3 + l3 * m2,
                        2 * l1 * l3, 2 * m1 * m3, 2 * n2 * n3,m1 * n3 + m3 * n1, l1 * n3 + l3 * n1, l1 * m3 + l3 * m1,
                        2 * l1 * l2, 2 * m1 * m2, 2 * n1 * n2,m1 * n2 + m2 * n1, l1 * n2 + l2 * n1, l1 * m2 + l2 * m1,
                       };

        for (int i = 1; i < 18; i++)
        {
            if (i % 2 != 0)
            {
                list.Add(t1);
            }
            else
            {
                list.Add(t2);
            }
        }

        list.Add(t3);

        return list;
    }

2、获取S矩阵

 private static List<double[]> GetS(Form1 form1)
    {

        double E11fbt, E22fbt, E33fbt, V23fbt, V12fbt, V13fbt, G12fbt, G13fbt, G23fbt;

        double E11f = double.Parse(form1.textBox_E11f.Text.Split(',')[0]);
        double Vf = double.Parse(form1.textBox_vf.Text.Split(',')[0]);
        double Em = double.Parse(form1.textBox_em.Text.Split(',')[0]);
        double Vm = double.Parse(form1.textBox_vm.Text.Split(',')[0]);
        double vm = double.Parse(form1.textBox_smalvm.Text.Split(',')[0]);
        double E22f = double.Parse(form1.textBox_e22f.Text.Split(',')[0]);
        double V12f = double.Parse(form1.textBox_v12f.Text.Split(',')[0]);
        double V13f = double.Parse(form1.textBox_v13f.Text.Split(',')[0]);
        double G12f = double.Parse(form1.textBox_g12f.Text.Split(',')[0]);
        double G23f = double.Parse(form1.textBox_g23f.Text.Split(',')[0]);
        double Gm = double.Parse(form1.textBox_gm.Text.Split(',')[0]);

        E11fbt = E11f * Vf + Em * Vm;
        E22fbt = E33fbt = (E22f * Em) / (E22f - Math.Sqrt(Vf) * E22f + Math.Sqrt(Vf) * Em);
        V23fbt = Vf * V13f + Vm * vm;
        V12fbt = V13fbt = Vf * V12f + Vm * vm;
        G12fbt = G13fbt = (Gm * G12f) / (G12f - Math.Sqrt(Vf) * G12f + Math.Sqrt(Vf) * Gm);
        G23fbt = (Gm * G23f) / (G23f - Math.Sqrt(Vf) * G12f + Math.Sqrt(Vf) * Gm);


        List<double[]> list = new List<double[]>();

        //玻璃纤维
        double[] s1 = {
                        1/E11fbt, -(V12fbt/E22fbt), -(V13fbt/E33fbt), 0, 0, 0,
                         -(V12fbt/E22fbt), 1/E22fbt, -(V23fbt/E33fbt), 0, 0, 0,
                        -(V13fbt/E33fbt), -(V23fbt/E33fbt), 1/E33fbt, 0, 0, 0,
                        0, 0, 0, 2*(1 + V12fbt)/E22fbt, 0 ,0,
                        0, 0, 0, 0, 1/G13fbt, 0,
                        0, 0, 0, 0, 0, 1/G12fbt
                       };


        E11f = double.Parse(form1.textBox_E11f.Text.Split(',')[1]);
        Vf = double.Parse(form1.textBox_vf.Text.Split(',')[1]);
        Em = double.Parse(form1.textBox_em.Text.Split(',')[1]);
        Vm = double.Parse(form1.textBox_vm.Text.Split(',')[1]);
        vm = double.Parse(form1.textBox_smalvm.Text.Split(',')[1]);
        E22f = double.Parse(form1.textBox_e22f.Text.Split(',')[1]);
        V12f = double.Parse(form1.textBox_v12f.Text.Split(',')[1]);
        V13f = double.Parse(form1.textBox_v13f.Text.Split(',')[1]);
        G12f = double.Parse(form1.textBox_g12f.Text.Split(',')[1]);
        G23f = double.Parse(form1.textBox_g23f.Text.Split(',')[1]);
        Gm = double.Parse(form1.textBox_gm.Text.Split(',')[1]);

        E11fbt = E11f * Vf + Em * Vm;
        E22fbt = E33fbt = (E22f * Em) / (E22f - Math.Sqrt(Vf) * E22f + Math.Sqrt(Vf) * Em);
        V23fbt = Vf * V13f + Vm * vm;
        V12fbt = V13fbt = Vf * V12f + Vm * vm;
        G12fbt = G13fbt = (Gm * G12f) / (G12f - Math.Sqrt(Vf) * G12f + Math.Sqrt(Vf) * Gm);
        G23fbt = (Gm * G23f) / (G23f - Math.Sqrt(Vf) * G12f + Math.Sqrt(Vf) * Gm);


        //碳纤维
        double[] s2 = {
                        1/E11fbt, -(V12fbt/E22fbt), -(V13fbt/E33fbt), 0, 0, 0,
                         -(V12fbt/E22fbt), 1/E22fbt, -(V23fbt/E33fbt), 0, 0, 0,
                        -(V13fbt/E33fbt), -(V23fbt/E33fbt), 1/E33fbt, 0, 0, 0,
                        0, 0, 0, 2*(1 + V12fbt)/E22fbt, 0 ,0,
                        0, 0, 0, 0, 1/G13fbt, 0,
                        0, 0, 0, 0, 0, 1/G12fbt
                       };


        for (int i = 1; i < 19; i++)
        {
            if (i >= 4 && i <= 14)
            {
                list.Add(s2);
            }
            else
            {
                list.Add(s1);
            }
        }

        return list;
    }

3、矩阵求逆

 public static double[,] Athwart(double[,] iMatrix)
    {
        int i = 0;
        int row = iMatrix.GetLength(0);
        double[,] MatrixZwei = new double[row, row * 2];
        double[,] iMatrixInv = new double[row, row];
        for (i = 0; i < row; i++)
        {
            for (int j = 0; j < row; j++)
            {
                MatrixZwei[i, j] = iMatrix[i, j];
            }
        }
        for (i = 0; i < row; i++)
        {
            for (int j = row; j < row * 2; j++)
            {
                MatrixZwei[i, j] = 0;
                if (i + row == j)
                    MatrixZwei[i, j] = 1;
            }
        }

        for (i = 0; i < row; i++)
        {
            if (MatrixZwei[i, i] != 0)
            {
                double intTemp = MatrixZwei[i, i];
                for (int j = 0; j < row * 2; j++)
                {
                    MatrixZwei[i, j] = MatrixZwei[i, j] / intTemp;
                }
            }
            for (int j = 0; j < row; j++)
            {
                if (j == i)
                    continue;
                double intTemp = MatrixZwei[j, i];
                for (int k = 0; k < row * 2; k++)
                {
                    MatrixZwei[j, k] = MatrixZwei[j, k] - MatrixZwei[i, k] * intTemp;
                }
            }
        }

        for (i = 0; i < row; i++)
        {
            for (int j = 0; j < row; j++)
            {
                iMatrixInv[i, j] = MatrixZwei[i, j + row];
            }
        }
        return iMatrixInv;
    }

4、计算

public void calc(Form1 form1)
    {
        List<double[]> Tlist = GetT(form1);
        List<double[]> Slist = GetS(form1);

        List<double> Vlist = new List<double>();
        Vlist.Add(double.Parse(form1.textBox_v1.Text));
        Vlist.Add(double.Parse(form1.textBox_v2.Text));
        Vlist.Add(double.Parse(form1.textBox_v3.Text));
        Vlist.Add(double.Parse(form1.textBox_v4.Text));
        Vlist.Add(double.Parse(form1.textBox_v5.Text));
        Vlist.Add(double.Parse(form1.textBox_v6.Text));
        Vlist.Add(double.Parse(form1.textBox_v7.Text));
        Vlist.Add(double.Parse(form1.textBox_v8.Text));
        Vlist.Add(double.Parse(form1.textBox_v9.Text));
        Vlist.Add(double.Parse(form1.textBox_v10.Text));
        Vlist.Add(double.Parse(form1.textBox_v11.Text));
        Vlist.Add(double.Parse(form1.textBox_v12.Text));
        Vlist.Add(double.Parse(form1.textBox_v13.Text));
        Vlist.Add(double.Parse(form1.textBox_v14.Text));
        Vlist.Add(double.Parse(form1.textBox_v15.Text));
        Vlist.Add(double.Parse(form1.textBox_v16.Text));
        Vlist.Add(double.Parse(form1.textBox_v17.Text));
        Vlist.Add(double.Parse(form1.textBox_v18.Text));

        double Vm = double.Parse(form1.textBox_svm.Text);

        double Em15 = double.Parse(form1.textBox_em15.Text);
        double Vm15 = double.Parse(form1.textBox_vm15.Text);
        double Gm15 = double.Parse(form1.textBox_gm15.Text);

        //公式15矩阵
        double[] s15 = {
                        1/Em15, -Vm15/Em15, -Vm15/Em15, 0, 0, 0,
                        -Vm15/Em15, 1/Em15, -Vm15/Em15, 0, 0, 0,
                        -Vm15/Em15, -Vm15/Em15, 1/Em15, 0, 0, 0,
                        0, 0, 0, 1/Gm15, 0, 0,
                        0, 0, 0, 0, 1/Gm15, 0,
                        0, 0, 0, 0, 0, 1/Gm15
                       };

        DenseMatrix matrixResult = new DenseMatrix(6, 6);

        for (int i = 0; i < 18; i++)
        {
            DenseMatrix matrixT = new DenseMatrix(6, 6, Tlist[i]);
            DenseMatrix matrixS = new DenseMatrix(6, 6, Slist[i]);
            DenseMatrix matrixTR = (DenseMatrix)matrixT.Transpose();
            
            matrixResult += matrixT * matrixS * matrixTR * Vlist[i];
        }

        matrixResult += new DenseMatrix(6, 6, s15) * Vm;

        double[] tt = matrixResult.Values;

        double[,] matrixReverse = Athwart(matrixResult.ToArray());


        Console.WriteLine("结果：");
        string reslut = "";

        for (int i = 0; i < 36; i++)
        {
            if ((i + 1) == 7 || (i + 1) == 13 || (i + 1) == 19 ||
                (i + 1) == 25 || (i + 1) == 31)
            {
                Console.WriteLine();
                reslut += "\r\n";
            }

            Console.Write(tt[i] + ",");

            reslut += tt[i].ToString() + ",";
        }

        Console.WriteLine();
        Console.WriteLine("逆矩阵：");

        string reslutReverse = "";
        for (int i = 0; i < 6; i++)
        {
            for (int j = 0; j < 6; j++)
            {
                //Console.Write(matrixReverse[i, j] + ",");
                reslutReverse += matrixReverse[i, j].ToString("0.00") + ",";
            }

            reslutReverse += "\r\n";
        }


        form1.textBox_result.Text = reslutReverse;
    }

二、测试

在这里插入图片描述

nova565
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C#实现矩阵计算
m0_68160088的博客
07-05 2523
其中包含了矩阵的数据（使用二维数组存储）、行数和列数等属性。并在接下来的代码实现中利用类里面的各种方法实现矩阵的加减乘除、转置、求逆等运算功能。首先，我们需要定义一个Matrix类来表示矩阵，并实现一些基本的矩阵操作。上述代码中，我们定义了基本的。上述是矩阵运算的部分实现。
C#的矩阵类
LanQiuChaoRen的专栏
07-13 6612
由于课程设计选的题目是基于神经网络的综合评价，利用暑假时间用C#实现的bp神经网络。此bp神经网络包含1个隐藏层，其中输入层，隐藏层，输出层个数都可以根据需要更改。
c#矩阵运算库
07-20
可用于定义矩阵，并进行常用的矩阵运算
C#矩阵类实现（基于Python及matlab矩阵规范）
武者小路的博客
10-23 4741
C#本身不支持矩阵，所以不适合数值运算，但是C#的优点又在于界面编写简单，如果需要用到界面，且必须用到矩阵，那么就就需要引用一个矩阵类来帮助矩阵的实现。本次矩阵类主要是基于Python以及Matlab矩阵的格式规范，轻松上手C#矩阵编写
C#简单的矩阵类并实现基本的矩阵运算
最新发布
wddblog的博客
04-13 435
在C#中，你可以通过创建自定义类或使用现有的库（如MathNet.Numerics）来实现矩阵计算。下面是一个简单的例子，说明如何创建一个简单的矩阵类并实现基本的矩阵运算。类来表示矩阵，并提供基本的矩阵操作，如加法、乘法和转置。然后，你可以这样使用你的。
C# 中的一些矩阵运算方法
helldoger的博客
06-10 1704
【代码】C# 中的一些矩阵运算方法。
C#使用Math.Net库进行矩阵运算
u014090257的博客
10-02 2357
C#使用Math.Net库进行矩阵运算 herryone1232019-04-01 19:57:0010858收藏32 分类专栏：C# 版权 一、基础知识 1、Math.net是什么 Math.net计算库是专为.NET开发的开源科学计算库。包含了大部分矩阵运算、线性运算等功能。效率高，且可以在C#中直接使用。简单的矩阵运算，其效率可以达到C#代码的10倍以上。 开源地址：http://mathnetnumerics.codeplex.com Math.NETNum...
C#实现矩阵计算类库
04-19
本项目名为"C#实现矩阵计算类库"，其目标是为开发者提供一个类似MATLAB的矩阵运算环境，使得在C#中进行矩阵操作变得更加便捷。MATLAB是一款流行的数值计算软件，它的核心功能之一就是矩阵运算，因此这个类库的出现，...
C#计算矩阵的逆矩阵方法实例分析
09-03
在C#编程中，我们可以利用数学原理和编程技巧来实现矩阵逆的计算。以下是关于C#计算矩阵逆矩阵的方法的详细解释： 首先，我们需要理解逆矩阵的基本概念。一个n阶方阵A的逆矩阵记作A^-1，如果存在，它满足等式AA^-1 ...
C#实现矩阵乘法实例分析
09-03
主要介绍了C#实现矩阵乘法的方法,实例分析了通过C#数组构造矩阵及实现矩阵乘法的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
C#实现矩阵转置的方法
09-03
总的来说，C#实现矩阵转置的关键在于理解矩阵转置的规则，并通过合理的数据结构和循环来实现。通过这种方式，我们可以轻松地处理各种大小的矩阵，进行矩阵运算，这对于处理图像处理、线性代数等问题的C#程序来说是...
矩阵运算_C#_矩阵_
10-03
本文将深入探讨如何使用C#语言来实现矩阵的运算，并以C#窗体应用程序为背景进行讲解。 首先，我们需要了解矩阵的基本概念。矩阵是由m行n列的元素构成的矩形数组，通常表示为A=(a[i,j])，其中i是行索引，j是列索引。...
通过C#实现矩阵求逆-简单版
Ratatoskr_01的博客
12-02 1371
原理简单的C#求逆方法
C# 矩阵库 功能特别强大！！
热门推荐
一些笔记
08-04 1万+
对一个 C# 矩阵库的使用作的总结 和 使用方法介绍
【C#】MathNet矩阵计算
微小冷的学习笔记
12-06 2109
Matrix也封装了常见运算的方法，以加法为例，提供了两种方案，一是直接返回一个矩阵，二是实现一个void方法，通过传地址的方式，更改输入的另一个矩阵。MathNet.Numerics中提供了线性代数、微积分、特殊函数、概率论、随机函数、插值、最优化等一系列功能，是.net技术中首选的数值计算包。其中，线性代数包LinearAlgebra包提供了向量、矩阵等数据结构，这些是数值计算的前提，故而相比于其他包更加基础。Matrix类中封装了一些静态方法，除了绝对值Abs，开根号Sqrt之外，还有如下。
C#用MathNet生成矩阵，并打印矩阵元素
微小冷的学习笔记
12-03 1774
MathNet.Numerics中提供了线性代数、微积分、特殊函数、概率论、随机函数、插值、最优化等一系列功能，是.net技术中首选的数值计算包。其中，线性代数包LinearAlgebra包提供了向量、矩阵等数据结构，这些是数值计算的前提，故而相比于其他包更加基础。
C#中的矩阵乘法——对图像应用变换
寒冰屋的专栏
07-12 2022
目录 介绍 源代码 矩阵乘法 转换 旋转变换 拉伸/缩放转换 单位矩阵 翻转变换 颜色密度变换 将事物连接在一起 创建客户端 性能说明 结论 介绍 今天，我将向您展示我的矩阵乘法的C#实现以及如何使用它对图像应用基本变换，如旋转、拉伸、翻转和修改颜色密度。 请注意，这不是图像处理类。相反，本文在C#中演示了三个核心线性代数概念：矩阵乘法、点积和变换矩阵。 源代码 本文的源代码可在以下存储库的GitHub上获得：https://github.com/elsheimy/...
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#矩阵乘法
05-24
在C#中实现矩阵乘法，可以使用以下代码： ```csharp public static double[,] MatrixMultiplication(double[,] matrix1, double[,] matrix2) { int rowsA = matrix1.GetLength(0); int colsA = matrix1.GetLength...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值