matrix.cpp

自己编的一个矩阵类

#include "matrix.h"
#include <iostream>

using namespace std;


Matrix::Matrix(int m,int n, float* a):nrow(m),ncol(n),array(a)
{
}

/*
* 构造维数为n的单位矩阵
*/
Matrix::Matrix(size_t n):nrow(n),ncol(n)
{
	array = new float[n * n];
	int j = 0;
	for (int i=0,count = n * n;i < count;i++)
	{
		if ( i == j * n + j)
		{
			array[i] = 1;
			j++;
		}
		else
			array[i] = 0;
	}
}

/*复制构造函数*/
Matrix::Matrix(const Matrix& m) : nrow(m.nrow),ncol(m.ncol)
{
	const int n = nrow * ncol;
	array = new float[ n ];
	for (int i=0;i < n;i++)
	{
		array[i] = m.array[i];
	}
}

Matrix::~Matrix()
{
	delete[] array;
}

void Matrix::CreateMatrix()
{
	cout << "Please input the dimension of this matrix(separate with space):";
	cin >> nrow >> ncol;

	cout << "Please input the elements of this matrix:" << endl;

	array = new float[nrow * ncol];
	for (int i=0,n = nrow * ncol;i < n;i++)
		cin >> array[i];
}

/*重载赋值运算符：
*注意与复制构造函数的区别，因为后者是给没有初始化的对象成员赋值，
*前者是给已经初始化的成员赋值，注意释放掉原数组变量的内存空间。
————————-------------------------------------
在赋值之前应该判断this != &m的情况，但是由于没有重载比较
运算符!=，所以这里就省略了。
*/
Matrix& Matrix::operator =( const Matrix& m )
{
	delete[] array;
	nrow = m.nrow;
	ncol = m.ncol;
	const int n = nrow * ncol;
	array = new float[ n ];
	for (int i=0;i < n;i++)
	{
		array[i] = m.array[i];
	}
	return *this;
}

float* Matrix::operator [](size_t i)
{
	if ( i >= nrow )
	{
		cerr << "Index out of bound!" << endl;
		exit( EXIT_FAILURE );
	}
	return array +i*nrow;
}

Matrix& Matrix::operator +=(const Matrix &m )
{
	if( nrow != m.nrow || ncol != m.ncol )
	{
		cerr << "Addition ERROR!" << endl;
		exit( EXIT_FAILURE );
	}
	for (int i=0,n=nrow * ncol;i < n;i++)
		array[i] += m.array[i];

	return *this;
}

Matrix& Matrix::operator -=(const Matrix &m )
{
	if( nrow != m.nrow || ncol != m.ncol )
	{
		cerr << "Minus ERROR!" << endl;
		exit( EXIT_FAILURE );
	}
	for (int i=0,n=nrow * ncol;i < n;i++)
		array[i] -= m.array[i];

	return *this;
}

/*先使用一个数组来存放矩阵相乘所得乘积的新元素，然后把原矩阵元素指针指向新数组指针，
*最后释放掉原矩阵元素占有的空间。
**/
Matrix& Matrix::operator *=(const Matrix &m )
{
	if( ncol != m.nrow )
	{
		cerr << "Multiply ERROR!" << endl;
		exit( EXIT_FAILURE );
	}

	//产生一个新数组存放计算结果
	float* result = new float[nrow * m.ncol];
	int count = 0;

	//计算矩阵乘积，并存入新数组
	for (int i=0;i < nrow;i++)
		for (int j=0;j < m.ncol;j++)
		{
			int indexRow = i * ncol;
			int indexCol = j;
			int sum = 0;

			for (int k=0;k < ncol;k++)
			{
				sum += array[indexRow] * m.array[indexCol];
				indexRow++;
				indexCol += m.ncol;
			}
			result[count] = sum;
			count++;
		}

	//改变矩阵的列数
	ncol = m.ncol;
	
	//释放原数组空间
	delete[] array;

	array = result;
	return *this;
}

Matrix& Matrix::operator *=(const float multiple )
{
	for (int i=0,n = nrow*ncol;i < n;i++)
		array[i] *= multiple;

	return *this;
}

float Matrix::trace() const
{
	if ( nrow != ncol )
	{
		cerr << "Trace ERROR:this matrix is not a square matrix!" << endl;
		exit( EXIT_FAILURE );
	}

	int sum = 0;
	for (int i=0;i < nrow;i++)
		sum += array[i*nrow + i];
	
	return sum;
}

Matrix operator+ (const Matrix& m1,const Matrix& m2)
{
	Matrix ret(m1);
	ret += m2;
	return ret;
}

Matrix operator- (const Matrix& m1,const Matrix& m2)
{
	Matrix ret(m1);
	ret -= m2;
	return ret;
}

Matrix operator* (const Matrix& m1,const Matrix& m2)
{
	Matrix ret(m1);
	ret *= m2;
	return ret;
}

Matrix operator* (const Matrix& m,const float multitle)
{
	Matrix ret(m);
	ret *= multitle;
	return ret;
}

Matrix pow(const Matrix& m, const size_t n)
{
	if ( m.getNRow() != m.getNCol() )
	{
		cerr << "Pow ERROR:this matrix is not a square matrix!" << endl;
		exit( EXIT_FAILURE );
	}
	if ( n == 0 )
		return Matrix( m.getNRow() );

	Matrix ret( m );
	for (int i=1;i < n;i++)
		ret *= m;

	return ret;
}

size_t Matrix::getNRow() const
{
	return nrow;
}

size_t Matrix::getNCol() const
{
	return ncol;
}

void Matrix::print() const
{
	for (int i=0,n = nrow * ncol;i < n;i++)
	{
		if( i % ncol == 0)
			cout << endl;
		cout << array[i] << " ";
	}
}