编写的一个矩阵类（C++描述）

最新推荐文章于 2024-03-23 09:44:33 发布
最新推荐文章于 2024-03-23 09:44:33 发布
阅读量7.8k 收藏 18
点赞数 3
分类专栏： 矩阵类 文章标签： matrix C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nevermorphling/article/details/52187141
版权 

头文件 Matrix.h
#ifndef _Matrix_
#define _Matrix_

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include <cmath>
#include <iomanip>

#include "AllocateArray.h"
using namespace std;


// --------------------------------------------------------------------------

class Matrix
{
public:

	Matrix();
	Matrix(int, int);
	Matrix(const string&);
	
	Matrix Transpose();
	Matrix AlgebraicComplement(int,int);
	Matrix Triangulate();
	Matrix Inverse();
	
	double OneNorm();
	double Det();

	

	void GaussSeidel(vector<double>& X, vector<double>& B, double eps = 1e-6);
	void GaussElimination(vector<double>& X, vector<double>& B);

	~Matrix();


private:

	vector<vector<double> > vvElem_;
	int nRow_;
	int nCol_;
	bool minu_;

public:

	//"<<"overload
	inline friend std::ostream& operator << (std::ostream& out, const Matrix& rhs)
	{
		out << "Rows = " << rhs.nRow_ << "	Columns = "
			<< rhs.nCol_ << endl;
		for( int i = 0; i < rhs.nRow_; i++)
		{
			for( int j = 0; j < rhs.nCol_; j++)
			{
				out << rhs.vvElem_[i][j] << "\t";

			}
			out << endl;

		}
		return out;
	}



	//"+" overload
	Matrix operator + (const Matrix& rhs);

	//"-" overload
	Matrix operator - (const Matrix& rhs);

	//"*" overload
	Matrix operator * (const Matrix& rhs);

	//"*" overload
	Matrix operator * (const vector<double>& Vb);

	//"()" overload
	double& operator () (int i, int j);

	//"+=" overload
	void operator += (const Matrix& rhs);

	//"-=" overload
	void operator -= (const Matrix& rhs);

	//"=" overload
	Matrix& operator = (const Matrix& rhs);

};






#endif
实现文件 

Matrix::Matrix():nRow_(0),nCol_(0)
{

}

Matrix::Matrix(int Row, int Col):nRow_(Row), nCol_(Col)
{
	AllocateDim(vvElem_, nRow_, nCol_);
}

Matrix::Matrix(const string& fileName)
{
	ifstream	infile(fileName.c_str(), ios::in);
	string		dataInput;
	while(getline( infile, dataInput ))
	{
		stringstream temp(dataInput);
		double d;
		vector<double> tempV;
		while ( temp >> d)
		{
			tempV.push_back(d);
		}
		vvElem_.push_back(tempV);
		this->nCol_ = tempV.size();
		tempV.clear();
	}
	this->nRow_ = vvElem_.size();
}

// --------------------------------------------------------------------------
/// Geting a transposion of a matrix
/// 
/// @return no
/// 
/// @author Wang li
/// @date 2016-08-09
/// @reviser 
Matrix Matrix::Transpose()
{
	Matrix m(this->nCol_,this->nRow_);
	for( int i = 0; i <  m.nRow_; i++)
	{
		for ( int j = 0; j < m.nCol_; j++)
		{
			m.vvElem_[i][j]=this->vvElem_[j][i];
		}
	}
	return m;
}

// --------------------------------------------------------------------------
/// Getting a algebraic complement
/// 
/// @param ii row to split
/// @param jj column to split
/// 
/// @return Matrix
/// 
/// @author Wang li
/// @date 2016-08-09
/// @reviser 
Matrix Matrix::AlgebraicComplement(int ii, int jj)
{
	Matrix m(this->nRow_-1,this->nCol_-1);
	for( int i = 0; i <  m.nRow_; i++)
	{
		for ( int j = 0; j < m.nCol_; j++)
		{
			if( i < (ii -1) && j < (jj -1))
			{
				m.vvElem_[i][j]=this->vvElem_[i][j];
			}
			else if( i >= (ii -1) && j < (jj -1))
			{
				m.vvElem_[i][j]=this->vvElem_[i+1][j];
			}
			else if( i < (ii -1) && j >= (jj -1))
			{
				m.vvElem_[i][j]=this->vvElem_[i][j+1];
			}
			else if( i >= (ii -1) && j >= (jj -1))
			{
				m.vvElem_[i][j]=this->vvElem_[i+1][j+1];
			}
		}
	}
	return m;
}

// --------------------------------------------------------------------------
/// Geting a transposion of a matrix
/// 
/// @return no
/// 
/// @author Wang li
/// @date 2016-08-09
/// @reviser 
Matrix Matrix::Triangulate()
{
	Matrix m(*this);
	m.minu_ = false;
	bool flag = true ;
	for ( int i = 1; i < nRow_ ; i++)
		if ( flag)
		{
			for ( int j = i; j < nCol_ ; j++)
				if (flag)
				{
					if ( m.vvElem_[i-1][i-1] == 0)
					{
						flag = false;
						for ( int ii = i; ii < nRow_; ii++)
						{
							if ( m.vvElem_[ii][i-1] != 0)
							{

								for(int k = 0 ; k < nCol_; k++)
								{
									double temp = m.vvElem_[ii][k];
									m.vvElem_[ii][k] = m.vvElem_[i-1][k];
									m.vvElem_[i-1][k] = temp;
								}
								m.minu_ = !(m.minu_);
								flag = true;
								break;
							}					
						}
						
						if (!flag) 
						{ 
							break;
						}
						
						double a1a2(0.0);
						a1a2 = m.vvElem_[j][i-1] / m.vvElem_[i-1][i-1];
						for(int k = 0 ; k < nCol_; k++)
						{						
							m.vvElem_[j][k] -= m.vvElem_[i-1][k] * a1a2;
						}

					}
					else
					{	
						double a1a2(0);
						a1a2 = m.vvElem_[j][i-1] / m.vvElem_[i-1][i-1];
						for(int k = 0 ; k < nCol_; k++)
						{						
							m.vvElem_[j][k] -= m.vvElem_[i-1][k] * a1a2;
						}
					}
				}

		}


		return m;
}

// --------------------------------------------------------------------------
/// Getting a inversion of a matrix
/// 
/// @return Matrix
/// 
/// @author Wang li
/// @date 2016-08-09
/// @reviser 
Matrix Matrix::Inverse()
{
	Matrix m(*this);
	double detT = m.Det();
	
	for (int i = 0; i < m.nRow_; i++)
	{
		for (int j = 0; j < m.nCol_; j++)
		{
			m.vvElem_[j][i] = this->AlgebraicComplement(i+1,j+1).Det() * pow(-1.0,i+j) / detT ;
		}
	}

	return m;
}

// --------------------------------------------------------------------------
/// Using gusss elimination to solve a linear matrix equation
/// 
/// @return no
/// 
/// @author Zhang shuai
/// @date 2016-08-09
/// @reviser 
void Matrix::GaussElimination( vector<double>& X, vector<double>& B)
{
	//The Finite Volume Method in Computational Fluid Dynamics An Advanced Introduction with OpenFOAM
	if (vvElem_.size() == X.size() && vvElem_.size() == B.size())
	{
		int N = vvElem_.size();

		for (int k = 0; k < N - 1; k++)
		{
			for (int i = k + 1; i < N; i++)
			{
				double Ratio = vvElem_[i][k] / vvElem_[k][k];

				for (int j = k + 1; j < N; j++)
				{
					vvElem_[i][j] = vvElem_[i][j] - Ratio * vvElem_[k][j];
				}

				B[i] = B[i] - Ratio * B[k];
			}
		}

		X[N - 1] = B[N - 1] / vvElem_[N - 1][N - 1];

		for (int i = N - 2; i >= 0; i--)
		{
			double Term(0);

			for (int j = i + 1; j < N; j++)
			{
				Term = Term + vvElem_[i][j] * X[j];
			}

			X[i] = (B[i] - Term) / vvElem_[i][i];

		}
	}
	else
	{
		cerr << "The input dimension of array is not the same.\nPlease Check the input array." << endl;
	}
}

// --------------------------------------------------------------------------
/// Using gusss seidel iteration method to solve a linear matrix equation
/// 
/// @return no
/// 
/// @author Huang chao
/// @date 2016-08-09
/// @reviser 
void Matrix::GaussSeidel(vector<double>& X, vector<double>& B,double eps)
{
	double error,sum,w(1.3),test(0);
	bool flag(true);

	if (vvElem_.size() == X.size() && vvElem_.size() == B.size())
	{
		int N = vvElem_.size();
		vector<double> Xold(N);
		do
		{
			for(int i = 0; i < N; i++)
			{
				Xold[i] = X[i];
				sum =0.0;
				for(int j = 0; j < N; j++)
				{
					if(j != i) {sum += vvElem_[i][j] * X[j];}
				}

				X[i] = (B[i]-sum)/vvElem_[i][i];

			}

			for(int i = 0; i < N; i++)
			{
				X[i]=w*X[i]+(1-w)*Xold[i];
			}

			for(int i = 0; i < N; i++)
			{
				error=fabs(Xold[i]-X[i])/X[i];
				if(error < eps) {flag = false;}
			}
			test++;

		} while (flag);

	}
	else
	{
		cerr << "The input dimension of array is not the same.\nPlease Check the input array." << endl;
	}


}

// --------------------------------------------------------------------------
/// Getting a determinate of a matrix
/// 
/// @return double
/// 
/// @author Wang li
/// @date 2016-08-09
/// @reviser 
double Matrix::Det()
{
	Matrix m(*this);	

	m = m.Triangulate();

	double mut(1);
	for ( int i = 0 ; i < this->nRow_; i++)
	{
		mut *= m.vvElem_[i][i];
	}
	if(m.minu_) {mut = -mut;}

	return mut;
}

// --------------------------------------------------------------------------
/// Getting the one norm of a matrix
/// 
/// @return double
/// 
/// @author Huang chao
/// @date 2016-08-09
/// @reviser 
double Matrix::OneNorm()
{	
	double mut1(0.0);
	for ( int i = 0 ; i < this->nRow_; i++)
	{
		for ( int j = 0 ; j < this->nCol_; j++)
		{
			mut1 += fabs(vvElem_[i][j]);
		}	
	}
	return mut1;
}

// --------------------------------------------------------------------------
/// overload operator + of matrix
/// 
/// @return Matrix
/// 
/// @author Wang jian
/// @date 2016-08-09
/// @reviser 
Matrix Matrix::operator + (const Matrix& rhs)
{
	Matrix mTemp(rhs);

	cout << " mTemp.vvElem_.size():\t" <<mTemp.vvElem_.size() << endl;

	for(int i = 0; i < rhs.vvElem_.size(); i++)
	{
		for(int j = 0; j < rhs.vvElem_[0].size(); j++)
		{
			mTemp.vvElem_[i][j] = vvElem_[i][j] + rhs.vvElem_[i][j];
		}
	}

	return mTemp;
}

// --------------------------------------------------------------------------
/// overload operator - of matrix
/// 
/// @return Matrix
/// 
/// @author Wang jian
/// @date 2016-08-09
/// @reviser 
Matrix Matrix::operator - (const Matrix& rhs)
{
	Matrix mTemp(rhs);

	for(int i = 0; i < rhs.vvElem_.size(); i++)
	{
		for(int j = 0; j < rhs.vvElem_[0].size(); j++)
		{
			mTemp.vvElem_[i][j] = this->vvElem_[i][j] - rhs.vvElem_[i][j];
		}
	}

	return mTemp;

}

// --------------------------------------------------------------------------
/// overload operator * of matrix
/// 
/// @return Matrix
/// 
/// @author Wang jian
/// @date 2016-08-09
/// @reviser 
Matrix Matrix::operator * (const Matrix& rhs)
{
	if(this->vvElem_[0].size() != rhs.vvElem_.size())
	{
		cerr << " The Matrix A cannot be multiplied by Matrix B" << endl;
	}
	Matrix mTemp(rhs);

	for(int i = 0; i < this->vvElem_.size(); i++)
	{
		for(int j = 0; j < rhs.vvElem_[0].size(); j++)
		{
			mTemp.vvElem_[i][j] = 0.0;
		}
	}

	for(int i = 0; i < this->vvElem_.size(); i++)
	{
		for(int j = 0; j < this->vvElem_[0].size(); j++)
		{
			for(int k = 0; k < rhs.vvElem_[0].size(); k++)
			{
				mTemp.vvElem_[i][k] += this->vvElem_[i][j] * rhs.vvElem_[j][k];
			}		
		}
	}

	return mTemp;

}

// --------------------------------------------------------------------------
/// overload operator () of matrix
/// 
/// @return Matrix
/// 
/// @author Wang li
/// @date 2016-08-09
/// @reviser 
double& Matrix::operator () (int i, int j)
{

	return this->vvElem_[i][j];

}

// --------------------------------------------------------------------------
/// overload operator += of matrix
/// 
/// @return Matrix
/// 
/// @author Wang jian
/// @date 2016-08-09
/// @reviser 
void Matrix::operator += (const Matrix& rhs)
{
	for(int i = 0; i < rhs.vvElem_.size(); i++)
	{
		for(int j = 0; j < rhs.vvElem_[0].size(); j++)
		{
			this->vvElem_[i][j] = this->vvElem_[i][j] + rhs.vvElem_[i][j];
		}
	}
}

// --------------------------------------------------------------------------
/// overload operator -= of matrix
/// 
/// @return Matrix
/// 
/// @author Wang jian
/// @date 2016-08-09
/// @reviser 
void Matrix::operator -= (const Matrix& rhs)
{
	for(int i = 0; i < rhs.vvElem_.size(); i++)
	{
		for(int j = 0; j < rhs.vvElem_[0].size(); j++)
		{
			this->vvElem_[i][j] = this->vvElem_[i][j] - rhs.vvElem_[i][j];
		}
	}
}

// --------------------------------------------------------------------------
/// overload operator = of matrix
/// 
/// @return Matrix
/// 
/// @author Wang jian
/// @date 2016-08-09
/// @reviser 
Matrix& Matrix::operator = (const Matrix& rhs)
{
	this->nRow_ = rhs.nRow_;
	this->nCol_ = rhs.nCol_;

	this->vvElem_.resize(nRow_);
	for(int i = 0; i < rhs.nRow_; i++)
	{
		this->vvElem_[i].resize(nCol_);
	}


	for(int i = 0; i < rhs.nRow_; i++)
	{

		for(int j = 0; j < rhs.nCol_; j++)
		{
			this->vvElem_[i][j] = rhs.vvElem_[i][j];
		}

	}

	this->minu_ = rhs.minu_;

	return *this;

}

Matrix::~Matrix()
{
}


nevermorphling
关注
  • 3
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
C++实现矩阵原地转置算法
01-01
本文实例描述了C++实现矩阵原地转置算法，是一个非常经典的算法，相信对于学习C++算法的朋友有很大的帮助。具体如下： 一、问题描述 微软面试题：将一个MxN的矩阵存储在一个一维数组中，编程实现矩阵的转置。 要求：...
矩阵类的实现
Galina Lin的博客
05-12 7522
一、实现矩阵类及以下功能（1）编写一个4*4的矩阵类，定义构造函数、复制构造函数；（2）重载运算符“+”和“-”实现矩阵的相应运算；（3）重载运算符&lt;&lt;实现矩阵数据的输出。二、代码（1）头文件 matrix.h#include&lt;iostream&gt; using namespace std; class Matrix{ private: int row; int col;...
编写了一个简单的矩阵类，可以实现矩阵的加减乘运算和求行列式等等
weixin_30569153的博客
07-05 6453
摘要 因为很久没有写过什么代码，于是打算写一个矩阵类来练一下手，找找感觉。 这次写的是一个简单的矩阵类，这个类里面的包含一个二维数组形式的成员用来存放矩阵，并且可以实现一些矩阵的基本运算，如加法、减法、乘法和赋值等等。（写的比较简陋，凑合着看吧） Matrix类的构成 数据成员 int row 行 int column 列 long matrix** 动态二维数组 成员函数 Matr...
c++矩阵入门
最新发布
huweixi2011的博客
03-23 237
矩阵
C++程序设计三、四、五（矩阵类的编写、String类的简单编写、有理数Rational类的编写）
qq_45125356的博客
08-26 636
3、编写简单的矩阵类 1）编写一个表示矩阵的类Matrix。矩阵元素为double类型。 2）改写默认构造函数，生成一个空矩阵，（不分配内存，矩阵大小为0*0）。 3）添加一个带参数的构造函数，传入参数为矩阵的大小，该构造分配矩阵内存，并初始化矩阵元素为0。矩阵元素按行序存储。 4）在析构函数中释放内存。 5）编写拷贝构造函数和拷贝赋值函数（operator=）。（注意用深拷贝） 6）编写成员函数SetValue,实现对矩阵的第i行第j列赋值。 7）编写成员函数GetValue,返回矩阵的第i
实验5 编写矩阵类实验
A_lonly的博客
12-14 1378
编写矩阵类实验 5.Matrix。该类包括矩阵数据数组double data[ ][ ]，构造方法Matrix()、Matrix(int rows,int cols)、Matrix(double data[ ][ ])、获取某元素值的方法getData(int row,int col)、设置某元素值的方法setData(int row,int col,double value)、计算两个矩阵的乘积的方法multiply(Matrix m)以及equals ( )、toString( )等内容； 编写测试类实
C++大作业（实现矩阵类）
weixin_51671868的博客
05-26 3703
此实验不放出解答，有些许提示
C++矩阵连乘源代码和题目描述和算法复杂度的解析
05-10
c/c++阵连乘，编译不错，挺好的！大家可以过来试试。还有源代码和题目描述和算法复杂度的解析。
稀疏矩阵的C++实现
09-25
稀疏矩阵的C++实现，此为本人完成人民邮电出版社出版的《数据结构——使用C++语言描述一书》中课后实习四的代码
1121 计算矩阵边缘元素之和.cpp
05-13
输入一个整数矩阵，计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。 【输入】 第一行分别为矩阵的行数m和列数n（m，n），两者之间以一个空格分开。 接...
C语言求矩阵的各列元素之和的代码示例
01-20
统计一个矩阵的各列元素之和。矩阵各元素为整数且绝对值不超过100。 要求输入： 有多个测试用例，每个测试用例的第一行是空格分隔的两个正整数n和m（ 1 < n, m < 80 ），接下来的n行每行有m个空格分隔的整数，...
编写代表矩阵的Matrix类
12-06
设计和编写代表矩阵的Matrix类。该类包括矩阵行列数变量int rows和int cols，矩阵数据数组double data[][]，构造方法Matrix()、Matrix(int rows,int cols)、Matrix(int rows,int cols,double data[][])，获取某元素值的方法getData(int row,int col)，设置某元素值的方法setData(int row,int col,double value)，计算两个矩阵的乘积的方法multiply(Matrix m)以及toString()等内容。 编写测试类MatrixTest，并在该类中创建两个矩阵对象，计算其乘积.
C++ 实现 Matrix （矩阵）类
m0_58880769的博客
07-28 8400
​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++实战笔记（一）：矩阵类
qq_41599413的博客
01-16 1万+
前言   上大学之前就对C++有过一些了解，知道C++是一种功能十分强大的语言。大一时学习了C语言，了解了面向过程的编程方法。现在大三开始学习C++，初步接触了面向对象的编程思想，对C++功能更为着迷，其既有C语言面向过程的特点，又能兼顾对问题对象的操作，自由度很高，是底层架构和高层架构对接的完美工具。   在学习C++的过程中，我将在这里整理学习的笔记，希望能对自己和他人有所帮助。 正文   第...
c++矩阵——超实用的数据结构
yzc_qiuse的博客
12-09 3090
矩阵是一个二维的数学结构，由行和列组成。在C++中，我们可以使用数组或者向量来表示矩阵。矩阵广泛应用于线性代数、图像处理、机器学习等领域。C++中的矩阵是一个重要的数学概念，在各种领域都有广泛的应用。我们可以使用数组或者向量来表示矩阵，并进行各种运算，如加法、减法、乘法和转置等。熟练掌握矩阵的表示和运算，对于理解和解决实际问题非常有帮助。今天的文章就到这里啦，三连必回qwq！
C++实现矩阵类(附代码和功能）
热门推荐
m0_37772174的博客
10-11 6万+
本文由两部分组成，第一部分介绍一个在win10系统上运行的exe程序，第二部分介绍通过C++实现矩阵运算的方法(功能会更强大，但不如exe文件操作方便)。 用户界面如下，能够实现矩阵的加、减、乘、除运算，以及矩阵的转置，求逆，求行列式的值等。 读者可以在下载该程序，直接在自己的电脑上运行。下载地址：https://download.csdn.net/do...
C++(数据结构与算法):14---矩阵介绍
董哥的黑板报
11-26 1864
一、矩阵介绍 一个矩m*b的矩阵是一个m行、n列的表，如下图所示： m和n是矩阵的维数 矩阵与二维数组不同，矩阵的索引从1开始 二、矩阵的运算 矩阵最常见的操作是：矩阵转置、矩阵相加、矩阵相乘 矩阵转置 一个m*n的矩阵M转置之后是一个n*m的矩阵，它们的关系是： 矩阵相加 两个矩阵仅当维数相同（行数、列数分别相同）时才可以相加 两个m*n的矩阵A和B相加之后是一个m*n...
构造函数、拷贝构造函数的运用
徒步者
11-29 1115
需求： 创建一个矩阵类，要求实现矩阵的乘法 矩阵元素的数据类型为float，矩阵用双重指针表示； 另外，程序要包含：构造函数、拷贝构造函数、析构函数。 代码： //矩阵类头文件Matrix.h #ifndef _MATRIX_H_ #define _MATRIX_H_ typedef float DataType; #define ROW 3//矩阵的行 #define
矩阵相关操作——C++实现
weixin_44788162的博客
10-06 3123
注：操作较复杂，不建议写数值课设的同学借鉴 1. 定义矩阵结构体 矩阵是高等代数(线性代数)中的基本运算单位，在运算时具有一些特殊的性质。按定义来看，矩阵是由非质数(m × n)个基本元素单元组成，这些单元按一定的顺序排列，构成了一个m行n列的矩阵。 从定义中不难看出，定义矩阵的结构体需要包含三个数据成员： 行数(整型); 列数(整型); 各元素的值(根据计算精度需求进行调整). 于是定义矩阵...
c++编写单元刚度矩阵
09-12
单元刚度矩阵是有限元分析中的一个重要概念，用于描述单元内部的物理特性和材料性质。下面是一个简单的C语言函数，用于计算一维杆单元的刚度矩阵。 ```c void getElementStiffnessMatrix(double E, double A, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值