C#-分数矩阵类(visual studio 2019)

最新推荐文章于 2022-03-22 17:48:29 发布
最新推荐文章于 2022-03-22 17:48:29 发布
阅读量201 收藏 1
点赞数 1
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kaksk_aja/article/details/112216645
版权

分数类

using System;

namespace MathLib
{
	public class Rational
	{
		private int nume = 0, deno = 1;
		public Rational(int numerator = 0, int denominator = 1)
		{
			int n = Math.Abs(numerator), d = Math.Abs(denominator), t;
			while ((d = n % (t = d)) != 0) n = t;
			nume = numerator / t;
			deno = denominator / t;
		}
		public static implicit operator Rational(int numerator)
		{
			return new Rational(numerator);
		}
		public static implicit operator double(Rational a)
		{
			return (double)a.nume / a.deno;
		}
		public override string ToString()
		{
			return string.Format(deno == 1 ? "{0}" : "{0}/{1}", nume, deno);
		}
		public static Rational operator +(Rational a, Rational b)
		{
			return new Rational(a.nume * b.deno + b.nume * a.deno, a.deno * b.deno);
		}
		public static Rational operator -(Rational a, Rational b)
		{
			return new Rational(a.nume * b.deno - b.nume * a.deno, a.deno * b.deno);
		}
		public static Rational operator *(Rational a, Rational b)
		{
			return new Rational(a.nume * b.nume, a.deno * b.deno);
		}
		public static Rational operator /(Rational a, Rational b)
		{
			return new Rational(a.nume * b.deno, a.deno * b.nume);
		}
		public static bool operator ==(Rational a, Rational b)
		{
			if (a.nume == b.nume && a.deno == b.deno)
				return true;
			else
				return false;
		}
		public static bool operator !=(Rational a, Rational b)
		{
			if (a.nume != b.nume || a.deno != b.deno)
				return true;
			else
				return false;
		}
		public override bool Equals(object obj) { return (this == (Rational)obj); }
		public override int GetHashCode() { return base.GetHashCode(); }
	}
}

矩阵类

using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MathLib
{
    public class Matrix<T>
    {
        static readonly Func<T, T> abs = (T a) => (dynamic)a > 0 ? a : (dynamic)a * -1;
        public T[,] Data;
        public Matrix(T[,] data)
        {
            Debug.Assert(data != null);
            Data = data;
        }
        public static Matrix<T> I(int n)
        {
            var res = new T[n, n];
            for (int row = 0; row < n; row++)
                for (int col = 0; col < n; col++)
                    res[row, col] = (T)(dynamic)(row == col ? 1 : 0);
            return new Matrix<T>(res);
        }
        public override string ToString()
        {
            return ToString("{0,6}");
        }
        public string ToString(string format)
        {
            string list = "";
            int row = Data.GetLength(0);
            int col = Data.GetLength(1);
            for (int i = 0; i < row; i++)
            {
                list += "[";
                for (int K = 0; K < col; K++)
                {
                    list += string.Format(format, Data[i, K]);
                    if (K != col - 1)
                        list += string.Format(format, " ,", Data[i, K]);

                }
                list += "]\n";
            }
            return list;
        }
        public static Matrix<T> operator +(Matrix<T> M1, Matrix<T> M2)
        {
            if (M1.Data.GetLength(0) != M2.Data.GetLength(0) && M2.Data.GetLength(1) != M1.Data.GetLength(1))
            {
                throw new Exception("矩阵不相同，无法进行加法运算");
            }
            else
            {
                int row = M1.Data.GetLength(0);
                int col = M1.Data.GetLength(1);
                for (int i = 0; i < row; i++)
                    for (int j = 0; j < col; j++)
                        M1.Data[i, j] = (dynamic)M1.Data[i, j] + (dynamic)M2.Data[i, j];
            }
            return M1;
        }
        public static Matrix<T> operator -(Matrix<T> M1)
        {
            int row = M1.Data.GetLength(0);
            int col = M1.Data.GetLength(1);
            for (int i = 0; i < row; i++)
                for (int j = 0; j < col; j++)
                    M1.Data[i, j] = (dynamic)M1.Data[i, j] - (dynamic)M1.Data[i, j];
            return M1;
        }
        public static Matrix<T> operator *(Matrix<T> M, T factor)
        {
            int row = M.Data.GetLength(0);
            int col = M.Data.GetLength(1);
            for (int i = 0; i < row; i++)
                for (int j = 0; j < col; j++)
                    M.Data[i, j] = (dynamic)M.Data[i, j] * factor;

            return M;
        }
        public static Matrix<T> operator *(T factor, Matrix<T> M)
        {
            return M * factor;
        }
        public static Matrix<T> operator *(Matrix<T> M1, Matrix<T> M2)
        {
            Debug.Assert(M1.Data.GetLength(1) == M2.Data.GetLength(0));
            int row = M1.Data.GetLength(0);
            int col = M2.Data.GetLength(1);
            T[,] list = new T[row, col];
            int n = M2.Data.GetLength(0);
            for (int i = 0; i < row; i++)
            {
                for (int j = 0; j < col; j++)
                {
                    list[i, j] = (dynamic)M1.Data[i, 0] * (dynamic)M2.Data[0, j];
                    for (int k = 1; k < n; k++)
                        list[i, j] += (dynamic)M1.Data[i, k] * (dynamic)M2.Data[k, j];
                }
            }
            return new Matrix<T>(list);
        }
        public static Matrix<T> operator ~(Matrix<T> M)
        {
            int row = M.Data.GetLength(1);
            int col = M.Data.GetLength(0);
            T[,] list = new T[row, col];
            for (int i = 0; i < row; i++)
                for (int j = 0; j < col; j++)
                {
                    list[i, j] = M.Data[j, i];
                }
            return new Matrix<T>(list);
        }
        public static Matrix<T> operator /(Matrix<T> M1, Matrix<T> M2)
        {
            return M1 * invert(M2);
        }
        public static bool operator ==(Matrix<T> M1, Matrix<T> M2)
        {
            int row = M1.Data.GetLength(0);
            int col = M1.Data.GetLength(1);
            if (M1.Data.GetLength(0) == M2.Data.GetLength(0) && M1.Data.GetLength(1) == M2.Data.GetLength(1))
            {
                for (int i = 0; i < row; i++)
                    for (int j = 0; j < col; j++)
                        if ((dynamic)M1.Data[i, j] == (dynamic)M2.Data[i, j])
                            return true;
            }
            else
                return false;
            return true;
        }
        public static bool operator !=(Matrix<T> M1, Matrix<T> M2)
        {
            if (M1 != M2)
                return true;
            else
                return false;
        }
        private static Matrix<T> invert(Matrix<T> M)
        {
            if (M.Data.GetLength(0) != M.Data.GetLength(1))
            {
                throw new Exception("erro!");
            }
            int row = M.Data.GetLength(0);
            int col = M.Data.GetLength(1);
            T[,] list1 = new T[2 * row + 1, 2 * col + 1];
            T[,] list = new T[2 * row + 1, 2 * col + 1];
            T[,] list2 = new T[row, col];
            I(row);
            for (int i = 0; i < 2 * row + 1; i++)
            {
                for (int j = 0; j < 2 * col + 1; j++)
                    list[i, j] = (dynamic)0;
            }
            for (int i = 0; i < row; i++)
                for (int j = 0; j < col; j++)
                    list[i, j] = M.Data[i, j];
            for (int k = 0; k < row; k++)
            {
                for (int t = col; t <= 2 * col; t++)
                {
                    if ((t - k) == row)
                    {
                        list[k, t] = (dynamic)1;
                    }
                    else
                    {
                        list[k, t] = (dynamic)0;
                    }
                }
            }

            for (int k = 0; k < row; k++)
            {
                if (list[k, k] != (dynamic)1)
                {
                    list1[k, k] = list[k, k];
                    list[k, k] = (dynamic)1;
                    for (int p = k + 1; p < 2 * col; p++)
                    {
                        list[k, p] = (dynamic)list[k, p] / (dynamic)list1[k, k];
                    }
                }
                for (int q = 0; q < row; q++)
                {
                    if (q != k)
                    {
                        list1[q, k] = list[q, k];
                        for (int p = 0; p < 2 * col; p++)
                        {
                            list[q, p] = list[q, p] - (dynamic)list1[q, k] * list[k, p];
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
            }
            for (int x = 0; x < row; x++)
            {
                for (int y = col; y < 2 * col; y++)
                {
                    list2[x, y - col] = list[x, y];
                }
            }
            return new Matrix<T>(list2); ;
        }
        public override bool Equals(object obj) { return (this == (Matrix<T>)obj); }
        public override int GetHashCode() { return base.GetHashCode(); }
    }
}

主类

using System;

namespace MathLib
{
    public class Test
    {
        static void Main(string[] args)
        {
            Console.WriteLine("========== Rational Test ==========");
            var fa = new Rational(3, 12);
            var fb = new Rational(4, 6);
            var fc = new Rational(6, 9);
            Console.WriteLine("{0} + {1} - {2} = {3}", fa, fb, fc, fa + fb - fc);
            Console.WriteLine("{0} {2} {1}", fa, .25, fa == 0.25 ? "==" : "!=");
            Console.WriteLine("{0} {2} {1}", fb, fc, (fb == fc ? "==" : "!="));
            Console.WriteLine("========== Matrix<double> Test ==========");
            var a = new Matrix<double>(new double[,] {
                { 1, 2, 3, 4, 5 },
                { 2, 3, 4, 5, 6 },
                { 3, 4, 5, 6, 7 }
            });
            var b = new Matrix<double>(new double[,] {
                { 17, 24, 01, 08, 15 },
                { 23, 05, 07, 14, 16 },
                { 04, 06, 13, 20, 22 },
                { 10, 12, 19, 21, 03 },
                { 11, 18, 25, 02, 09 }
            });


            var c = Matrix<double>.I(5) / b;
            Console.WriteLine("∵ a = \n{0}", a);
            Console.WriteLine("∴ ~a = \n{0}", ~a);
            Console.WriteLine("∵ b = \n{0}", b);
            Console.WriteLine("∴ a * b = \n{0}", a * b);
            Console.WriteLine("∵ c = 1/b =\n{0}", c.ToString("{0,9:f6}"));
            Console.WriteLine("∴ b * c =\n{0}", (b * c).ToString("{0,5:f2}"));
            Console.WriteLine("? b * c {0} I\n", b * c == Matrix<double>.I(5) ? "!=" : "==");

            Console.WriteLine("========== Matrix<Rational> Test ==========");
            var e = new Matrix<Rational>(new Rational[,] {
                        { new Rational(1), new Rational(1, 2), new Rational(1, 5) },
                       { new Rational(1, 4), new Rational(1, 3), new Rational(1, 6) },
                    { new Rational(1, 9), new Rational(1, 8), new Rational(1, 303) }	// 将最后数字7，替换为学号后三位数。
            });
            var f = Matrix<Rational>.I(3) / e;
            Console.WriteLine("∵ e =\n{0}", e);
            Console.WriteLine("∴ 60 * ~e =\n{0}", 60 * ~e);
            Console.WriteLine("∵ f = 1/e =\n{0}", f.ToString("{0,12}"));
            Console.WriteLine("∴ e * f {0} I", e * f == Matrix<Rational>.I(3) ? "==" : "!=");
            Console.ReadKey();
        }
    }
}
C++lover
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
codeup 问题 A: 分数矩阵
记录
07-31 132
#include <bits/stdc++.h> using namespace std; ostream &sp(ostream &output); int main() { int n; while (1) { scanf("%d", &n); if (n == 0) break; double ans = 0; double y = 1;
一个简单的数学运算库c#版
11-06
一个简单而又功能强大的数学计算库，包含矩阵计算，基本几何运算功能
Mathlib:非常简单的C＃数学库
03-14
Mathlib：一个非常简单的C＃数学库 这是一个非常简单的C＃数学库，我的软件渲染器和多代理模拟器项目仍在开发中。 创建它的目的是（在某种程度上）与Unity的数学库兼容（或多或少）。 执照 由开发的引擎代码; 它是根据。 所有文本和文档（即非代码文件）均可在[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License] [CC BY-NC-SA 4.0]下获得。
HDU2156 分数矩阵
wzxshhz123的博客
03-08 400
分数矩阵 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 5312    Accepted Submission(s): 3146 Problem Description 我们定义如下矩阵: 1/1 1/2 1/
leetcode之翻转矩阵后的得分（C++）
beilizhang的博客
05-02 130
参考链接 https://leetcode-cn.com/problems/score-after-flipping-matrix/ 题目描述 有一个二维矩阵 A 其中每个元素的值为 0 或 1 。 移动是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。 在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。 返回尽可能高的分数。 解题思路 贪心策略，要数字最大，最高位要为1，所以先通过移动哪些最高位不是1的行，使
c#课程设计--矩阵的按行按列读取功能及矩阵的基本计算.docx
07-04
C#矩阵计算课程设计报告 本课程设计报告主要基于C#语言，旨在设计一个可以进行矩阵的基本运算的程序，包括矩阵的按行按列读取、转置、高斯消元、求特征值等功能。该程序使用 VISUAL STUDIO 2010 进行开发，旨在帮助...
C#三角分解矩阵类
09-09
此代码是在Visual Studio2008平台上编写的，低于此版本的Visual Studio不兼容；此类是对矩阵进行LDU三角分解，并形成因子表；
曲线图绘制、分析上位机软件平台-用于热释电传感器矩阵数据采集
09-04
使用4个热释电传感器组成一个2X2的矩阵。通过曲线的相位差、 峰峰值等特征量来计算相关信息。本文使用STM32单片机设计、制作了热释电传感器矩阵；使用C#.NET设计了上位机软件。为以上研究做了试验平台，适合在此...
使用.NET GDI +进行图像的矩阵转换
04-08
使用GDI + Matrix类执行图像转换。
c#课程设计矩阵的按行按列读取功能及矩阵的基本计算-毕业论文.doc
06-29
该程序使用 VISUAL STUDIO 2010 开发环境，旨在帮助学生更好地理解矩阵计算的基本原理。 矩阵是线性代数中的一个基本概念，它是一个具有行和列的矩形数组，用来描述线性变换和向量空间。矩阵可以用于描述物理系统、...
C#分数运算
12-20
C#分数运算
序列比对打分矩阵C++(实验报告+源程序)
04-08
序列比对打分矩阵C++(实验报告+源程序) 序列比对打分矩阵C++(实验报告+源程序) 序列比对打分矩阵C++(实验报告+源程序)
分数矩阵行列式计算辅助工具
05-16
分数矩阵行列式计算辅助工具，如果觉得计算过于复杂，就用这个吧
安装及使用 C# 科学计算库 Math.NET Numerics
weixin_41241658的博客
02-25 2374
参考地址： https://blog.csdn.net/heray1990/article/details/72467304 在一个新建控制台项目下 打开工具-NuGet包管理器-程序包管理器控制台 稍等片刻 输入如下命令： Install-Package MathNet.Numerics 等待…大功告成！ （但是不是每个新建控制台项目都要重新安装一遍） ...
C#与MATLAB混合编程
不积跬步，无以至千里
11-03 8439
原地址：C#与MATLAB混合编程 - SteveWang - 博客园 http://www.cnblogs.com/eniac12/p/4390845.html C#和MatLab的混合编程，充分利用了winform的直观显示和matlab的强大计算能力。在此以一个小例子的形式给大家讲述一下二者混合编程的实现。 　　 　　一、软件的配置说明 　　C#版本：VS201
C#数学计算包 Math.NET
无人境域
09-11 6186
关于Math.NET的简介 源码地址
MyMathLib系列(一元多项式-准备)
三人行必有我师,手写三行必有所悟
01-07 2133
这里定义的类TExp是基本的计算项，这里的表达式与C#自带的表达式有很大的区别，这里定义这个类主要是为了进行矩阵运算，当然本身也支持普通的运算，但目前不支持除法。这个类目前的用途主要是为了计算矩阵的特征值，特征向量，有时间，再扩展成支持常见的复数域类的数值和符号运算。代码有点长，需要有点耐心：using System; using System.Collections.Generic; using
c# 分数处理
安梓晨的博客
03-22 1448
分数处理类 作用： 用于做 比例运算、分数运算 分数处理类 public class Fraction { private int member; // 分子 private int denominator; // 分母 //分子属性 public int Member { get { return member; } set { member = value; } } //分母属性 pu
visual studio 2019 c#打包
最新发布
09-07
Visual Studio 2019是微软推出的一款面向开发者的集成开发环境（IDE），专门用于开发和调试各种软件应用程序，包括C语言程序。 首先，它提供了丰富的功能和工具，使开发人员可以轻松编写、调试和部署C语言程序。它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值