c++实现矩阵类以及矩阵的相关运算

最新推荐文章于 2024-04-14 09:41:40 发布
最新推荐文章于 2024-04-14 09:41:40 发布
阅读量1.7k 收藏 24
点赞数 3
分类专栏： c++ 类 文章标签： 线性代数 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lshandel/article/details/116208189
版权
c++ 同时被 2 个专栏收录
3 篇文章 0 订阅
订阅专栏
类
2 篇文章 0 订阅
订阅专栏

c++实现矩阵类以及矩阵的相关运算

每次写线代作业的时候，自己懒的进行矩阵相关运算，想借助计算机，但这需要重新启动vscode，因为vscode的配置是和文件夹走的，我的c++和python不是一个文件夹，由于这一学期还是写c++多点，重启vscode也懒得，而c++中支持矩阵运算的第三方库一般又是做计算机图形方面的比较大型的库，于是就想自己写一个。
我这像是期中考试的学生吗 555
虽然还有瑕疵，比如小数的处理还没考虑，但是足够帮助我们学习（偷懒 ）线性代数了。
目前可以实现相乘、转置、求行列式、求逆、转化为上三角矩阵
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

不废话了直接上代码：

#include<iostream>
#include<vector>
#include <iomanip>
using namespace std;
class matrix
{
    friend matrix matmul(matrix a, matrix b);
    friend ostream& operator<<(ostream& out,matrix a);
    friend matrix operator*(int,matrix);
private:
    int row;
    int column;
    vector<vector<double> >cmatrix;
public:
    matrix(int t1,int t2);
    matrix();
    matrix tran(matrix);
    matrix show();
    vector<double>& operator[](int i);
    double det(vector<vector<double> >);
    double det();
    matrix T();
    matrix I();
    int R();
    matrix uptri();
    matrix operator+(matrix);
    matrix operator-(matrix);
    matrix operator*(double);
};
int matrix::R()
{
    matrix index=this->uptri();
    int r=0;
    int index1=0;
    for(int i=0;i<row;i++)
    {
        index1=0;
        for(int j=0;j<column;j++)
            if(index[i][j]!=0)
                index1=1;
        if(index1)
            r++;
    }
    return r;
}
matrix operator*(int a,matrix b)
{
    matrix index=b;
    for(int i=0;i<b.row;i++)
        for(int j=0;j<b.column;j++)
            index[i][j]*=a;
    return index;
}
matrix matrix::operator*(double b)
{
    matrix index=*this;
    for(int i=0;i<row;i++)
        for(int j=column;j<column;j++)
            index[i][j]*=b;
    return index;
}
matrix matrix::operator-(matrix b)
{
    matrix index=*this;
    if(this->row!=b.row||this->column!=b.column)
    {
        cout<<"数学错误"<<endl;
        return *this;
    }
    for(int i=0;i<row;i++)
        for(int j=0;j<column;j++)
        {
            index[i][j]=this->cmatrix[i][j]-b[i][j];
        }
    return index;
}
matrix matrix::operator+(matrix b)
{
    matrix index=*this;
    if(this->row!=b.row||this->column!=b.column)
    {
        cout<<"数学错误"<<endl;
        return *this;
    }
    for(int i=0;i<row;i++)
        for(int j=0;j<column;j++)
        {
            index[i][j]=this->cmatrix[i][j]+b[i][j];
        }
    return index;
}
matrix::matrix(){column=0;row=0;cmatrix.resize(0);}
matrix::matrix(int t1,int t2):row(t1),column(t2)
{
    vector<double>index;
    for(int i=0;i<row;i++)
    {
        index.resize(0);
        for(int j=0;j<column;j++)
        {
            double index1;
            cin>>index1;
            index.push_back(index1);
        }
        cmatrix.push_back(index);
    }
}
matrix matrix::show()
{
    for(int i=0;i<row;i++)
        for(int j=0;j<column;j++)
        {
            if(this->cmatrix[i][j]>0&&this->cmatrix[i][j]<10e-6)
                this->cmatrix[i][j]=0;
            else if(this->cmatrix[i][j]<0&&this->cmatrix[i][j]>-10e-6)
                this->cmatrix[i][j]=0;
        }
    cout<<'['<<setw(9);
    for(int i=0;i<row;i++)
    {
        // if (i != 0)
        //     cout <<' ';
        for(int j=0;j<column;j++)
        {
            cout<<cmatrix[i][j]<<setw(10);
            // if (j != column - 1)
            //     cout << "\t";
        }
        if(i!=row-1)
            cout<<endl;
    }
    cout<<']'<<endl;
    return *this;
}
vector<double>& matrix::operator[](int i)
{
    return cmatrix[i];
}
matrix matrix::tran(matrix tran)
{
    if (this->row != tran.column)
    {
        cout << "数学错误!" << endl;
        return *this;
    }
    else
    {
        matrix index;
        vector<double>index1;
        index1.resize(column);
        for (int i = 0; i < tran.row; i++)
            index.cmatrix.push_back(index1);
        for (int i = 0; i < tran.row; i++)
        {
            for (int j = 0; j < column; j++)
            {
                for (int k = 0; k < tran.column;k++)
                {
                    index[i][j] += tran[i][k] * cmatrix[k][j];
                }
            }
            index.row = tran.row;
            index.column = column;
        }
        return index;
    }
}
matrix  matmul(matrix a, matrix b)
{
    matrix index;
    vector<double>index1;
    index1.resize(b.column);
    for (int i = 0; i < a.row; i++)
        index.cmatrix.push_back(index1);
    for (int i = 0; i < a.row; i++)
    {
        for (int j = 0; j < b.column; j++)
        {
            for (int k = 0; k < a.column; k++)
            {
                index[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    index.column = b.column;
    index.row = a.row;
    return index;
}
ostream& operator<<(ostream& out, matrix a)
{
    a.show();
    return out;
}
double matrix::det(vector<vector<double> >M)
{
    if (M.size()==2)
    {
        return (M[0][0] * M[1][1] - M[0][1] * M[1][0]);
    }
    double result=0;
    for(int i=0;i<M.size();i++)
    {
        vector<vector<double> >index;
        int sign=i+2;
        for(int j=0;j<M.size();j++)
        {
            if(j==i)
                continue;
            vector<double>index2;
            for(int k=1;k<M.size();k++)
            {
                index2.push_back(M[j][k]);
            }
            index.push_back(index2);
        }
        if(sign%2==0)
            sign=1;
        else 
            sign=-1;
        result+=sign*M[i][0]*(this->det(index));
    }
    return result;
}
double matrix::det()
{
    if(column!=row)
    {
        cout<<"数学错误！"<<endl;
        return 0;
    }
    return det(this->cmatrix);
}
matrix matrix::T()
{
    matrix index;
    index.row=column;
    index.column=row;
    index.cmatrix.resize(0);
    vector<double>index2;
    index2.resize(index.column);
    for(int i=0;i<index.row;i++)
        index.cmatrix.push_back(index2);
    for(int i=0;i<index.row;i++)
        for(int j=0;j<index.column;j++)
            index.cmatrix[i][j]=this->cmatrix[j][i];
    return index;
}
matrix matrix::I()
{
    matrix index=*this;
    matrix index1=*this;
    for(int i=0;i<row;i++)
    {  
        index1.cmatrix[i].resize(0);
        index1.cmatrix[i].resize(column,0);
        index1.cmatrix[i][i]=1;
    }
    if(this->det()==0)
    {
        cout<<"不可逆"<<endl;
        return *this;
    }
    for(int i=1;i<row;i++)
    {
        bool over=false;
        for(int j=0;j<i;j++)
        {
            double t1=(double)index[i][j];
            double t2=(double)index[j][j];
            if(index[i][j]!=0)
            {
                if(t2==0)
                {
                    for(int j1=0;j1<column;j1++)
                    {
                        double index3=index[j][j1];
                        index[j][j1]=index[i][j1];
                        index[i][j1]=index3;
                        double index4=index1[j][j1];
                        index1[j][j1]=index1[i][j1];
                        index1[i][j1]=index4;
                    }
                    over=true;
                }
                if(over)
                    continue;
                for(int k=0;k<column;k++)
                {
                    index[i][k]-=(double)t1/t2*index[j][k];
                    index1[i][k]-=(double)t1/t2*index1[j][k];
                }
            }
        }
        if(over)
        {
            continue;
            over=false;
        }
    }
    for(int i=0;i<row;i++)
    {
        double t1=(double)index[i][i];
        for(int j=0;j<column;j++)
        {
            index[i][j]/=t1;
            index1[i][j]/=t1;
        }
    }
    for(int i=0;i<row;i++)
    {
        for(int j=i+1;j<column;j++)
        {
            double t2=(double)index[i][j];
            if(index[i][j]!=0)
            {
                for(int k=0;k<column;k++)
                {
                    index[i][k]-=t2*index[j][k];
                    index1[i][k]-=t2*index1[j][k];
                }
            }
        }
    }
    // for(int i=0;i<row;i++)
    //     for(int j=0;j<column;j++)
    //     {
    //         if((int)(index1[i][j]*100)%100==33)
    //             for(int k=0;k<column;k++)
    //                 index1[i][k]*=3;
    //         else if((int)(index1[i][j]*100)%100==50)
    //             for(int k=0;k<column;k++)
    //                 index1[i][k]*=2;
    //         else if((int)(index1[i][j]*100)%100==20)
    //             for(int k=0;k<column;k++)
    //                 index1[i][k]*=5;
    //         else if((int)(index1[i][j]*100)%100!=0)
    //             for(int k=0;k<column;k++)
    //                 index1[i][k]*=10;
    //         int t3=0;
    //         for(int k=2;k<10;k++)
    //         {
    //             t3=k;
    //             for(int i1=0;i1<column;i1++)
    //             {
    //                 if((int)index1[i][i1]%k!=0)
    //                     t3=0;
    //             }
    //             if(t3)
    //             {
    //                 for(int i1=0;i1<column;i1++)
    //                     index1[i][i1]/=t3;
    //             }
    //         }
    //     }
    return index1;
}
matrix matrix::uptri()
{
    if(row!=column)
    {
        cout<<"数学错误！"<<endl;
        return *this;
    }
    matrix index=*this;
    for(int i=1;i<row;i++)
    {
        bool over=false;
        for(int j=0;j<i;j++)
        {
            double t1=(double)index[i][j];
            double t2=(double)index[j][j];
            if(t1!=0)
            {
                if(t2==0)
                {
                    for(int j1=0;j1<column;j1++)
                    {
                        double index3=index[j][j1];
                        index[j][j1]=index[i][j1];
                        index[i][j1]=index3;
                    }
                    over=true;
                }
                if(over)
                    continue;
                for(int k=0;k<column;k++)
                {
                    index[i][k]-=(double)t1/t2*index[j][k];
                }
            }
        }
        if(over)
        {
            continue;
            over=false;
        }
    }
    return index;
}
int main()
{
    matrix a(3,3);
    cout<<"矩阵A：\n"<<a;
    cout<<"矩阵A的转置：\n"<<a.T();
    cout<<"矩阵A的行列式："<<a.det()<<endl;
    cout<<"矩阵A化为上三角矩阵：\n"<<a.uptri();
    cout<<"矩阵A的逆矩阵函数测试：\n"<<a.tran(a.I());
    cout<<"矩阵A的逆矩阵：\n"<<a.I();
    cout<<"矩阵A的秩为：  "<<a.R()<<endl;
    // matrix A(3,3);
    // matrix b(3,1);
    // cout<<matmul(A.I(),b);
    return 0;
}
青 霞
关注
  • 3
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++动态建立矩阵及矩阵相乘
chengyunpeng0198的博客
09-19 600
#include <iostream.h> #include <iomanip.h> int ** create(int m,int n) { int i,j; int **p = new int*[m]; cout <<"输入矩阵...
在C++中实现矩阵运算
qq_44949768的博客
04-22 1988
在C++中实现矩阵运算
矩阵基本运算（C++）
qq_41696018的博客
08-11 2万+
闲着没事，将以前利用C++实现的矩阵各种运算整理了一下，分享一下，矩阵运算包括： 1、二维矩阵创建6、两矩阵上下叠加 2、两矩阵相加 7、矩阵左右叠加 3、两矩阵相减 8、矩阵转置 4、两矩阵相乘 ...
C++ 实现 Matrix （矩阵）类
m0_58880769的博客
07-28 8932
​c)实现高斯消元法求解线性方程组Matrixx=GaussianElimination(A,b);​b)实现高斯滤波MatrixB=GaussianFilter(A,H)​a)增广矩阵MatrixAb=AugmentMatrix(A,B);​a)零矩阵Matrixzeros(rows,cols);​b)逆矩阵MatrixIA=Inverse(A);​a)默认构造函数，生成一个1,1列的矩阵。......
探索C++的矩阵运算库：cxxmatrix
gitblog_00015的博客
04-14 309
探索C++的矩阵运算库：cxxmatrix 项目地址:https://gitcode.com/akinomyoga/cxxmatrix 在处理科学计算、图像处理和机器学习等领域时，矩阵运算扮演着至关重要的角色。今天，我们向大家推荐一个简洁而高效的C++矩阵运算库——cxxmatrix，它提供了丰富的线性代数功能，并且易于集成到你的C++项目中。 项目简介 cxxmatrix是由Akinomiyo设...
C++实战笔记（一）：矩阵类
qq_41599413的博客
01-16 1万+
前言   上大学之前就对C++有过一些了解，知道C++是一种功能十分强大的语言。大一时学习了C语言，了解了面向过程的编程方法。现在大三开始学习C++，初步接触了面向对象的编程思想，对C++功能更为着迷，其既有C语言面向过程的特点，又能兼顾对问题对象的操作，自由度很高，是底层架构和高层架构对接的完美工具。   在学习C++的过程中，我将在这里整理学习的笔记，希望能对自己和他人有所帮助。 正文   第...
C++实现矩阵类(附代码和功能）
热门推荐
m0_37772174的博客
10-11 6万+
本文由两部分组成，第一部分介绍一个在win10系统上运行的exe程序，第二部分介绍通过C++实现矩阵运算的方法(功能会更强大，但不如exe文件操作方便)。 用户界面如下，能够实现矩阵的加、减、乘、除运算，以及矩阵的转置，求逆，求行列式的值等。 读者可以在下载该程序，直接在自己的电脑上运行。下载地址：https://download.csdn.net/do...
c++矩阵——超实用的数据结构
yzc_qiuse的博客
12-09 4436
矩阵是一个二维的数学结构，由行和列组成。在C++中，我们可以使用数组或者向量来表示矩阵。矩阵广泛应用于线性代数、图像处理、机器学习等领域。C++中的矩阵是一个重要的数学概念，在各种领域都有广泛的应用。我们可以使用数组或者向量来表示矩阵，并进行各种运算，如加法、减法、乘法和转置等。熟练掌握矩阵的表示和运算，对于理解和解决实际问题非常有帮助。今天的文章就到这里啦，三连必回qwq！
Debug_C++实现矩阵相乘_矩阵运算_
10-01
在C++编程中，矩阵运算...综上所述，C++实现矩阵相乘及其相关运算，涉及类的设计、内存管理、矩阵乘法算法以及错误处理等多个方面。通过合理组织代码，我们可以构建一个高效且灵活的矩阵运算库，方便在各种项目中复用。
C++矩阵类 C++矩阵运算
03-17
封装好的矩阵类，提供运算化间求秩等功能，全部在Main函数上方
矩阵运算_c++源代码；矩阵基本运算_矩阵运算_
10-03
本项目提供了一个用C++实现的矩阵运算库，涵盖了矩阵的基本运算，如加法、减法、乘法以及求逆矩阵。下面将详细介绍这些知识点。 1. **矩阵的概念**： 矩阵是由若干行和列组成的数表，每个数称为元素。在C++中，...
C++ QT 矩阵运算器
04-24
《C++ QT 矩阵运算器：深入解析与应用》 C++ QT 矩阵运算器是一款基于C++编程语言和QT图形用户界面库开发的矩阵计算工具，它为用户提供了一个直观且高效的环境来执行矩阵的加、减、乘及转置等基本操作。在这款软件...
矩阵运算-基于C++实现的矩阵运算之求逆矩阵.zip
最新发布
05-16
在C++中实现矩阵运算，我们需要定义一个矩阵类或结构体，包含矩阵元素的存储和相关的操作函数。例如，我们可以创建一个二维数组来存储矩阵元素，并提供初始化、赋值、打印、加法、乘法等方法。对于求逆矩阵，我们...
【基础算法】矩阵的几种基本运算 & C++实现
EWEADN
12-04 6024
矩阵是高等代数学中的常见工具，也常见于统计分析等应用数学学科中。物理学中，矩阵于电路学、力学、光学和量子物理中都有应用；计算机科学中，三维动画制作也需要用到矩阵。 矩阵的运算是数值分析领域的重要问题。将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。对一些应用广泛而形式特殊的矩阵，例如稀疏矩阵和准对角矩阵，有特定的快速运算算法。
矩阵的c++实现
liudabai__的博客
09-23 3396
在大学数学课程《线性代数》中，就有矩阵和行列式的出现，这篇文章主要讲矩阵在c++中的实现和一些用途。此篇文章只写c++的内容，不具体写到数学中矩阵的一些公式、性质。
C++(数据结构与算法):14---矩阵介绍
董哥的黑板报
11-26 1930
一、矩阵介绍 一个矩m*b的矩阵是一个m行、n列的表，如下图所示： m和n是矩阵的维数 矩阵与二维数组不同，矩阵的索引从1开始 二、矩阵的运算 矩阵最常见的操作是：矩阵转置、矩阵相加、矩阵相乘 矩阵转置 一个m*n的矩阵M转置之后是一个n*m的矩阵，它们的关系是： 矩阵相加 两个矩阵仅当维数相同（行数、列数分别相同）时才可以相加 两个m*n的矩阵A和B相加之后是一个m*n...
构造函数、拷贝构造函数的运用
徒步者
11-29 1132
需求： 创建一个矩阵类，要求实现矩阵的乘法 矩阵元素的数据类型为float，矩阵用双重指针表示； 另外，程序要包含：构造函数、拷贝构造函数、析构函数。 代码： //矩阵类头文件Matrix.h #ifndef _MATRIX_H_ #define _MATRIX_H_ typedef float DataType; #define ROW 3//矩阵的行 #define
C++项目练手：矩阵类的功能实现
weixin_51958878的博客
06-13 3424
C++项目练手：矩阵类的功能实现 C++课程设计：矩阵类的相关功能实现 矩阵简述： 实数矩阵是由一个按照长方阵列排列的实数集合。除数据外，两个实数矩阵可以进行加法和乘法运算，一个矩阵也可以和一个实数相乘，得到一个新的矩阵，请基于抽象出的矩阵的属性和方法，定义和实现一个矩阵类，并编写主函数，测试矩阵对象的构造和测试。 功能实现要求： 在缺省情况下，构造一个4*4的数据全为0的矩阵 可以按给定的行数和列数，构造一个值为全0的矩阵 可以使用给定的矩阵构造一个新的矩阵（定义并使用拷贝构造函数） 可以获取矩阵中的给
C++11标准|用C++写一个矩阵(包含了如何用cmake构建一个工程)
Rolandxxx的博客
08-02 4334
1.改进版2的矩阵乘法是很慢的，相比matlab差了至少1w倍，我们可以采取以下方式提速，cpu的并行指令，gpu的并行计算，但这些技术都太深入了。因为改进版2的矩阵乘法有三层for循环，版本1的k在最内层，版本2的i在最内层，版本3的j在最内层，用版本3时就可以实现缓存优化，对程序效率有所提高。3.在Matrix的成员函数里重载了()符号，函数名就是operator()，如A是Matrix类的对象，重载后就可以这样用，A.operator()(2,1) = 77等效于A(2, 1) = 77。
c++实现矩阵运算的库函数
06-08
C++中实现矩阵运算的库函数有很多，以下是一些常用的库函数： 1. Eigen：是一个用于线性代数的C++模板库，提供了矩阵、向量、数组等数据类型及其运算，支持SVD、QR分解、特征值分解等常用运算。 2. Armadillo：是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值