作者:
Phinecos(洞庭散人) 來源:
博客園 發布時間: 2008-08-16 22:51 閱讀: 1162 次 推薦: 0
原文鏈接 [收藏]
幫一個朋友做的作業題，現在真是什么專業都要學編程了呀。。
//向量類
/**//*
**author:phinecos
**date:7/17/2008
*/
class CVector
{
public:
CVector(unsigned int d=0);//由向量的維數創建向量，向量元素值初始化為
CVector(unsigned int d, double* pe);//由向量的維數和向量元素數組創建數組
CVector(double x, double y);//由兩個元素生成二維向量
CVector(double x, double y, double z);//由三個元素生成三維向量
CVector(CVector& v);//復制構造函數
~CVector();//析構函數
CVector& operator =(const CVector& v);//重載賦值運算符
CVector& operator +(void);//重載一元運算符+
CVector operator +(const CVector& v) const;//重載二元運算符+
CVector& operator -(void);//重載一元運算符-
CVector operator -(const CVector& v) const;//重載二元運算符-
CVector operator *(const CVector& v) const;//重載二元運算符*,表示向量的叉乘（向量積）
double operator %(const CVector& v) const;//重載二元運算符%,表示向量的點乘（數量積）
CVector operator *(const double& d) const;//重載二元運算符*，表示向量的數乘
double& operator [](const unsigned int i);//重載操作符[]，對指定向量元素進行操作
unsigned int GetDegree() const;//獲取向量維數
void printElements();
friend class CLinearEquation;
private:
double* pElement; //向量元素存儲地址
unsigned int nDegree;//向量的維數
void initByZero();//初始化為
void initByArray(double* pe);//用數組初始化
void alloc(unsigned int n=0);//分配空間
void reverse();//變號
void destory();
};
向量類實現
#include "stdafx.h"
#include "Vector.h"
#include <cassert>
#include <memory.h>
#include <iostream>
using namespace std;
/**//*
**author:phinecos
**date:7/17/2008
*/
CVector::CVector(unsigned int d):nDegree(d)
{//由向量的維數創建向量，向量元素值初始化為
if(d>0)
{
this->alloc(this->nDegree);
this->initByZero();//向量元素值初始化為
}
}
CVector::CVector(double x, double y):nDegree(2)
{
this->alloc(nDegree);
this->pElement[0] = x;
this->pElement[1] = y;
}
CVector::CVector(double x, double y, double z):nDegree(3)
{//由三個元素生成三維向量
this->alloc(nDegree);
this->pElement[0] = x;
this->pElement[1] = y;
this->pElement[2] = z;
}
CVector::CVector(unsigned int d, double* pe):nDegree(d)
{//由向量的維數和向量元素數組創建數組
if(d>0)
{
this->alloc(this->nDegree);
this->initByArray(pe);
}
}
CVector::CVector(CVector& v)
{//復制構造函數
this->nDegree = v.GetDegree();
if(this->nDegree>0)
{
this->alloc(this->nDegree);
this->initByArray(v.pElement);
}
}
CVector& CVector::operator =(const CVector& v)
{//重載賦值運算符
if(v.GetDegree()>0)
{
this->destory();//銷毀原數據
this->nDegree = v.GetDegree();//新向量大小
this->alloc(this->nDegree);//分配空間
this->initByArray(v.pElement);//復制數據
}
return *this;
}
CVector& CVector:: operator +(void)
{//重載一元運算符+
return *this;
}
CVector CVector::operator +(const CVector& v) const
{//重載二元運算符+
assert(this->nDegree==v.GetDegree());//兩個向量的維數應該相等
CVector result(this->nDegree,this->pElement);
for(unsigned int i=0;i<this->nDegree;++i)
{
result.pElement[i] += v.pElement[i];
}
return result;
}
CVector& CVector::operator -(void)
{//重載一元運算符-
this->reverse();
return *this;
}
CVector CVector::operator -(const CVector& v) const
{//重載二元運算符-
assert(this->nDegree==v.GetDegree());//兩個向量的維數應該相等
CVector result(this->nDegree,this->pElement);
for(unsigned int i=0;i<this->nDegree;++i)
{
result.pElement[i] -= v.pElement[i];
}
return result;
}
CVector CVector::operator *(const CVector& v) const
{//重載二元運算符*,表示向量的叉乘（向量積）
assert(this->nDegree==v.GetDegree());
assert(this->nDegree==3);
double a1 = this->pElement[0];
double b1 = this->pElement[1];
double c1 = this->pElement[2];
double a2 = v.pElement[0];
double b2 = v.pElement[1];
double c2 = v.pElement[2];
return CVector(b1*c2-b2*c1,c1*a2-a1*c2,a1*b2-a2*b1);
}
double CVector::operator %(const CVector& v) const
{//重載二元運算符%,表示向量的點乘（數量積）
assert(this->nDegree==v.GetDegree());
double result = 0.0f;
for(unsigned int i=0;i<this->nDegree;++i)
{
result += this->pElement[i]*v.pElement[i];
}
return result;
}
double& CVector::operator [](const unsigned int i)
{//重載操作符[]，對指定向量元素進行操作
assert(i>=0&&i<this->nDegree);
return this->pElement[i];
}
void CVector::reverse()
{
for(unsigned int i=0;i<this->nDegree;++i)
{
this->pElement[i] = -this->pElement[i];
}
}
void CVector::alloc(unsigned int n)
{//分配大小為n的存儲區
if(n>0)
{
this->pElement = new double[n];
}
}
void CVector::initByZero()
{
for(unsigned int i=0;i<nDegree;++i)
{
this->pElement[i] = 0;
}
}
void CVector::initByArray(double *pe)
{
for(unsigned int i=0;i<nDegree;++i)
{
this->pElement[i] = pe[i];
}
}
void CVector::destory()
{
if(this->pElement!=NULL)
{
delete [] pElement;
this->pElement = NULL;
this->nDegree = 0;
}
}
CVector::~CVector(void)
{
this->destory();
}
unsigned int CVector::GetDegree() const
{//獲取向量維數
return this->nDegree;
}
void CVector::printElements()
{
for(unsigned int i=0;i<this->nDegree;++i)
{
cout<<"x["<<i<<"]="<<this->pElement[i]<<endl;
}
}
class CVector;//前向聲明
//矩陣類
/**//*
**author:phinecos
**date:7/17/2008
*/
class CMatrix
{
public:
CMatrix(unsigned int r=0,unsigned int c=0); //由矩陣的行數和列數創建矩陣類對象，并為矩陣元素分配存儲空間，將矩陣初始化為單位矩陣；
CMatrix(const char* pFileName); //由矩陣存儲文件名創建矩陣類對象，文件格式可參考附錄，但不限于采用此格式；
CMatrix(const CMatrix& m); //復制構造函數，由已有矩陣類對象創建新的矩陣類對象；
unsigned int GetRowsNum() const;//獲取矩陣的行數
unsigned int GetColumnsNum() const;//獲取矩陣的列數
double& operator ()(unsigned int r, unsigned int c);//重載運算符()，用于提取指定行(r)列(c)的元素值
CMatrix& operator =(const CMatrix& m); //重載運算符=,用于矩陣之間相互賦值
CMatrix& operator +() const;//重載一元運算符+,即取矩陣本身
CMatrix operator -() const;//重載一元運算符-，即矩陣元素取相反數
CMatrix operator +(const CMatrix& m) const;//重載二元運算符+,即兩個矩陣求和
CMatrix operator -(const CMatrix& m) const;//重載二元運算符-,即兩個矩陣求差
CMatrix operator *(const CMatrix& m) const;//重載二元運算符*,即兩個矩陣求積
CMatrix operator *(const double& x) const;//重載二元運算符*,即矩陣與數相乘
CMatrix operator *(CVector& v) const;//重載二元運算符*，即矩陣與向量相乘
CMatrix operator /(const double& x ) const;//重載二元運算符/,即矩陣與數相除
CMatrix operator ^(const int& t) const;//重載二元運算符^,即矩陣求t次冪
void operator -=(const CMatrix& m); //重載二元運算符-=，即自減運算
void operator +=(const CMatrix& m);//重載二元運算符-=，即自加運算
void operator *=(const double x);//重載二元運算符*=，即自乘運算（矩陣）
CMatrix Tranpose() const;//求矩陣的轉置的函數
CMatrix Invert() const;//求矩陣的逆的函數
void Zeros();//矩陣歸零化，將當前矩陣的所有元素歸零
void Unit();//矩陣單元化，將當前矩陣轉換為單位矩陣
int AddRow(double* pe, unsigned int nr);//在矩陣的nr行位置插入一行，數據存放地址為pe，返回行標
int AddColumn(double* pe, unsigned int nc);//在矩陣的nc列位置插入一列，數據存放地址為pe，返回列標
double* DeleteRow(unsigned int nr);//刪除矩陣nr行，返回該行元素值（臨時存儲地址）
double* DeleteColumn(unsigned int nc);//刪除矩陣nc列，返回該列元素值（臨時存儲地址）
friend class CLinearEquation;//聲明友元類CLinearEquation
friend class CVector;//聲明友元類CVector
//析構函數，釋放存儲矩陣元素的空間
virtual ~CMatrix(void);
//void printMatrix()const;
private:
double* pElement;//元素存儲區
unsigned int nRow;//行數
unsigned int nColumn;//列數
void destroy();
void alloc(unsigned int n=0);//分配空間
protected:
virtual void InitFromFile(const char* pFileName);//從文件中初始化
public:
virtual int MatOut(const char* pFileName); //將矩陣以pFileName為文件名進行文件輸出
};
矩陣類實現
#include "stdafx.h"
#include "Matrix.h"
#include "Vector.h"
#include <iostream>
#include <cassert>
#include <fstream>
using namespace std;
CMatrix::CMatrix(const CMatrix& m)
{//復制構造函數，由已有矩陣類對象創建新的矩陣類對象；
unsigned int i;
this->nRow = m.GetRowsNum();
this->nColumn = m.GetColumnsNum();
//this->pElement = new double[nRow*nColumn];
this->alloc(nRow*nColumn);
for (i=0;i<nRow*nColumn;++i)
{
this->pElement[i] = m.pElement[i];
}
}
CMatrix::CMatrix(const char* pFileName)
{//由矩陣存儲文件名創建矩陣類對象，文件格式可參考附錄，但不限于采用此格式；
if(pFileName!=NULL)
{
this->InitFromFile(pFileName);
}
}
void CMatrix::InitFromFile(const char* pFileName)
{//從文件中初始化
ifstream inFile( pFileName );
if ( !inFile )
{
cerr << "unable to open input file: "<< pFileName << " -- bailing out!\n";
return;
}
inFile>>this->nRow>>this->nColumn;
this->alloc(nRow*nColumn);//分配空間
unsigned int i;
double num;
for(i=0;i<nRow*nColumn;++i)
{
inFile>>num;
this->pElement[i] = num;
}
inFile.close();
}
CMatrix::CMatrix(unsigned int r,unsigned int c):nRow(r),nColumn(c)
{//由矩陣的行數和列數創建矩陣類對象，并為矩陣元素分配存儲空間，將矩陣初始化為單位矩陣；
if(nRow>0&&nColumn>0)
{
this->nRow = r;
this->nColumn = c;
//this->pElement = new double[nRow*nColumn];
this->alloc(nRow*nColumn);
for (unsigned int i=0;i<nRow*nColumn;++i)
{
this->pElement[i] = 0;
}
}
}
CMatrix& CMatrix::operator =(const CMatrix& m)
{//重載運算符=,用于矩陣之間相互賦值
if(this!=&m)
{
this->destroy();
this->nRow = m.GetRowsNum();
this->nColumn = m.GetColumnsNum();
this->alloc(nRow*nColumn);
for (unsigned int i=0;i<nRow*nColumn;++i)
{
this->pElement[i] = m.pElement[i];
}
}
return *this;
}
double& CMatrix::operator ()(unsigned int r, unsigned int c)
{//重載運算符()，用于提取指定行(r)列(c)的元素值
return this->pElement[r*nColumn+c];
}
CMatrix& CMatrix::operator +()const
{//重載一元運算符+,即取矩陣本身
return const_cast<CMatrix&>(*this);
}
CMatrix CMatrix::operator -() const
{//重載一元運算符-，即矩陣元素取相反數
CMatrix result(nRow,nColumn);
for (unsigned int i=0;i<nRow*nColumn;++i)
{
result.pElement[i] = -pElement[i];
}
return result;
}
CMatrix CMatrix::operator +(const CMatrix& m) const
{//重載二元運算符+,即兩個矩陣求和
assert(this->nRow==m.GetRowsNum() && this->nColumn==m.GetColumnsNum());
CMatrix result(*this);
for (unsigned int i=0;i<nRow*nColumn;++i)
{
result.pElement[i]+=m.pElement[i];
}
return result;
}
CMatrix CMatrix::operator -(const CMatrix& m) const
{//重載二元運算符-,即兩個矩陣求差
assert(this->nRow==m.GetRowsNum() && this->nColumn==m.GetColumnsNum());
CMatrix result(*this);
for (unsigned int i=0;i<nRow*nColumn;++i)
{
result.pElement[i]-=m.pElement[i];
}
return result;
}
CMatrix CMatrix::operator *(const CMatrix& m) const
{//重載二元運算符*,即兩個矩陣求積
CMatrix result(*this);
int ct = 0, cm = 0, cw = 0; // compute w(i,j) for all i and j
for (unsigned int i = 1; i <= nRow; ++i)
{
// compute row i of result
for (unsigned int j = 1; j <= m.GetColumnsNum(); ++j)
{
// compute first term of w(i,j)
double sum = pElement[ct] *m.pElement[cm]; // add in remaining terms
for (unsigned int k = 2; k <= nColumn; ++k)
{
ct++; // next term in row i of *this
cm += m.GetColumnsNum(); // next in column j of m
sum += pElement[ct] *m.pElement[cm];
};
result.pElement[cw++] = sum; // save w(i,j)
// reset to start of row and next column
ct -= nColumn - 1;
cm = j;
} // reset to start of next row and first column
ct += nColumn;
cm = 0;
}
return result;
}
CMatrix CMatrix::operator *(const double& x) const
{//重載二元運算符*,即矩陣與數相乘
CMatrix result(*this);
for (unsigned int i=0;i<nRow*nColumn;++i)
{
result.pElement[i] = this->pElement[i]*x;
}
return result;
}
CMatrix CMatrix::operator *(CVector& v) const
{//重載二元運算符*，即矩陣與向量相乘
assert(this->nColumn==v.GetDegree());
CMatrix result(nRow,1);
int ct = 0, cm = 0, cw = 0;
for (unsigned int i=0;i<nRow;++i)
{
double sum = 0.0f;
for (unsigned int j=0;j<v.GetDegree();++j)
{
sum += pElement[ct++]*v[j];
}
result(i,0) = sum;
}
return result;
}
CMatrix CMatrix::operator ^(const int& t) const
{//重載二元運算符^,即矩陣求t次冪
CMatrix result(*this);
CMatrix tmp(*this);
for (int i=1;i<t;++i )
{
result = result*(tmp);
}
return result;
}
void CMatrix::operator -=(const CMatrix& m)
{//重載二元運算符-=，即自減運算
assert(nRow==m.GetRowsNum()&&nColumn==m.GetColumnsNum());
for (unsigned int i=0;i<nRow*nColumn;++i)
{
this->pElement[i] -= m.pElement[i];
}
}
void CMatrix::operator +=(const CMatrix& m)
{//重載二元運算符-=，即自加運算
assert(nRow==m.GetRowsNum()&&nColumn==m.GetColumnsNum());
for (unsigned int i=0;i<nRow*nColumn;++i)
{
this->pElement[i] += m.pElement[i];
}
}
void CMatrix::operator *=(const double x)
{//重載二元運算符*=，即自乘運算（矩陣）
for (unsigned int i=0;i<nRow*nColumn;++i)
{
this->pElement[i] *= x;
}
}
CMatrix CMatrix::operator /(const double& x ) const
{//重載二元運算符/,即矩陣與數相除
CMatrix result(*this);
for (unsigned int i=0;i<nRow*nColumn;++i)
{
result.pElement[i] = this->pElement[i]/x;
}
return result;
}
CMatrix CMatrix::Tranpose() const
{//求矩陣的轉置的函數
CMatrix result(*this);
for (unsigned int i=0;i<nRow;++i)
{
for (unsigned int j=0;j<nColumn;++j)
{
result(i,j) = this->pElement[j*nColumn+i];
}
}
return result;
}
CMatrix CMatrix::Invert() const
{//求矩陣的逆的函數
CMatrix result(nRow,nColumn*2);
unsigned int i,j,p,q;
for (i=0;i<nRow;++i)
{
for (j=0;j<nColumn;++j)
{
result(i,j) = this->pElement[i*nColumn+j];
}
for (j=nColumn;j<nColumn*2;++j)
{
if ((j-i)==nColumn)
{
result(i,j) = 1.0f;
}
else
{
result(i,j) = 0.0f;
}
}
}
for(i=0;i<nRow;++i)
{
if(result(i,i)!=1.0f)
{
double bs = result(i,i);
result(i,i)=1.0f;
for(j=i+1;j<nColumn*2;++j)
{
result(i,j)/=bs;
}
}
for(q=0;q<nRow;++q)
{
if(q!=i)
{
double bs = result(q,i);
for(p=0;p<nColumn*2;++p)
{
result(q,p) -= bs*result(i,p);
}
}
else
{
continue;
}
}
}
return result;
}
void CMatrix::Zeros()
{//矩陣歸零化，將當前矩陣的所有元素歸零
for (unsigned int i=0;i<nRow*nColumn;++i)
{
this->pElement[i] = 0.0f;
}
}
void CMatrix::Unit()
{//矩陣單位化，將當前矩陣轉換為單位矩陣
for (unsigned int i=0;i<nRow;++i)
{
for (unsigned int j=0;j<nColumn;++j)
{
if (i==j)
{
(*this)(i,j) = 1.0f;
}
else
{
(*this)(i,j) = 0.0f;
}
}
}
}
int CMatrix::AddRow(double* pe, unsigned int nr)
{//在矩陣的nr行位置插入一行，數據存放地址為pe，返回行標
CMatrix tmp(*this);
unsigned int oldRow,oldColumn;
oldRow = this->nRow;
oldColumn = this->nColumn;
this->destroy();
this->nRow = oldRow+1;
this->nColumn = oldColumn;
this->alloc(nRow*nColumn);
unsigned int i,j,k;
for (i=0;i<nr*nColumn;++i)
{
this->pElement[i] = tmp.pElement[i];
}
k = i;
for (j=0;j<nColumn;++j)
{
this->pElement[i++] = pe[j];
}
for (;i<nRow*nColumn;++i)
{
this->pElement[i] = tmp.pElement[k++];
}
return nr;
}
int CMatrix::AddColumn(double* pe, unsigned int nc)
{//在矩陣的nc列位置插入一列，數據存放地址為pe，返回列標
CMatrix tmp(*this);
unsigned int oldRow,oldColumn;
oldRow = this->nRow;
oldColumn = this->nColumn;
this->destroy();
this->nRow = oldRow;
this->nColumn = oldColumn+1;
this->alloc(nRow*nColumn);
unsigned int i,j,k;
for (i=0;i<nc;++i)
{
for (j=0;j<nRow;++j)
{
this->pElement[j*nColumn+i] = tmp.pElement[j*oldColumn+i];
}
}
k = i;
for (j=0;j<nRow;++j)
{
this->pElement[j*nColumn+i] = pe[j];
}
for (i=k+1;i<nColumn;++i)
{
for (j=0;j<nRow;++j)
{
this->pElement[j*nColumn+i] = tmp.pElement[j*oldColumn+k];
}
k++;
}
return nc;
}
double* CMatrix::DeleteRow(unsigned int nr)
{//刪除矩陣nr行，返回該行元素值（臨時存儲地址）
double* pTmp = new double[nColumn];
CMatrix tmp(*this);
unsigned int oldRow,oldColumn;
oldRow = this->nRow;
oldColumn = this->nColumn;
this->destroy();
this->nRow = oldRow-1;
this->nColumn = oldColumn;
this->alloc(nRow*nColumn);
unsigned int i,j,ct=0;
for(i=0;i<nr;++i)
{
for (j=0;j<nColumn;++j)
{
this->pElement[ct] = tmp(i,j);
ct++;
}
}
for (j=0;j<nColumn;++j)
{
pTmp[j] = tmp(nr,j);
}
for (i=nr+1;i<oldRow;++i)
{
for (j=0;j<nColumn;++j)
{
this->pElement[ct] = tmp(i,j);
ct++;
}
}
return pTmp;
}
double* CMatrix::DeleteColumn(unsigned int nc)
{//刪除矩陣nc列，返回該列元素值（臨時存儲地址）
double* pTmp = new double[nRow];
CMatrix tmp(*this);
unsigned int oldRow,oldColumn;
oldRow = this->nRow;
oldColumn = this->nColumn;
this->destroy();
this->nRow = oldRow;
this->nColumn = oldColumn-1;
this->alloc(nRow*nColumn);
unsigned int i,j,ct=0,cw=0;
for (i=0;i<nRow;++i)
{
for (j=0;j<oldColumn;++j)
{
if(j!=nc)
{
this->pElement[ct] = tmp(i,j);
ct++;
}
else
{
pTmp[cw] = tmp(i,j);
cw++;
}
}
}
return pTmp;
}
unsigned int CMatrix::GetRowsNum() const
{//獲取矩陣的行數
return this->nRow;
}
unsigned int CMatrix::GetColumnsNum() const
{//獲取矩陣的列數
return this->nColumn;
}
void CMatrix::alloc(unsigned int n/**//* =0 */)
{
this->pElement = new double[n];
}
void CMatrix::destroy()
{
if (this->pElement!=NULL)
{
delete[]this->pElement;
this->pElement = NULL;
this->nColumn = 0;
this->nRow = 0;
}
}
CMatrix::~CMatrix(void)
{
this->destroy();
}
int CMatrix::MatOut(const char* pFileName)
{//將矩陣以pFileName為文件名進行文件輸出
if(pFileName!=NULL)
{
ofstream outFile( pFileName );
if ( !outFile )
{
cerr << "unable to open output file: "<< pFileName << " -- bailing out!\n";
return -1;
}
outFile<<this->nRow<<" "<<this->nColumn<<endl;
unsigned int i;
for(i=0;i<nRow*nColumn;++i)
{
if((i+1)%nColumn==0)
{
outFile<<this->pElement[i]<<endl;
}
else
outFile<<this->pElement[i]<<" ";
}
outFile.close();
}
return 0;
}
#include "matrix.h"
class CVector;
//線性方程組類
/**//*
**author:phinecos
**date:7/17/2008
*/
class CLinearEquation :public CMatrix
{
public:
CLinearEquation(void);
CLinearEquation(CMatrix& coe, CVector& con );//通過系數矩陣和常數向量創建線性方程組
CLinearEquation(const char* pFile);//通過數據文件創建線性方程組
CLinearEquation(unsigned int ne, unsigned int nv);//通過方程個數和未知數創建線性方程組
~CLinearEquation(void);
public:
int AddVariable(double *pcoe, unsigned int pc);//為方程組增加一個變量，其系數矩陣增加一列，pcoe為增加系數地址，pc為增加系數列的序號，為最前面，默認追加在尾部，成功返回未知數個數，否則為-1
int AddEquation(double *pcoe, double con, unsigned int pr);//為方程組增加一個方程，其系數矩陣增加一行，pcoe為增加系數地址，con為增加方程的常數項，pr為增加系數行的序號，為最前面，默認追加在尾部，成功返回方程個數，否則為-1
int DeleteVariable(unsigned int pc);//刪除方程組中第pc個未知數，并刪除其系數列
int DeleteEquation(unsigned int pr);//刪除方程組中第pr個方程
CVector Gaussian();//高斯消元法解線性方程組
int CLinearEquation::MatOut(const char* pFileName);
public:
CVector* Constant;//方程組的常數向量，新增成員
//方程組系數矩陣，繼承成員，不可見
//方程組中方程個數，繼承成員，矩陣行數，不可見
//方程組中未知數個數，繼承成員，矩陣列數，不可見
private:
void InsertConstant(double num,int pos);
void DeleteConstant(unsigned int pos);
void InitFromFile(const char* pFileName);
};
線性方程組類實現
#include "stdafx.h"
#include "LinearEquation.h"
#include "Vector.h"
#include <cmath>
#include <iostream>
#include <fstream>
using namespace std;
/**//*
**author:phinecos
**date:7/17/2008
*/
CLinearEquation::CLinearEquation(void)
{
}
CLinearEquation::CLinearEquation(const char* pFile)
{//通過數據文件創建線性方程組
if(pFile!=NULL)
{
this->InitFromFile(pFile);
}
}
void CLinearEquation::InitFromFile(const char* pFileName)
{
ifstream inFile( pFileName );
if ( !inFile )
{
cerr << "unable to open input file: "<< pFileName << " -- bailing out!\n";
return;
}
inFile>>this->nRow>>this->nColumn;
this->alloc(nRow*nColumn);//分配空間
unsigned int i;
double num;
for(i=0;i<nRow*nColumn;++i)
{
inFile>>num;
this->pElement[i] = num;
}
this->Constant = new CVector(nRow);
for(i=0;i<nRow;++i)
{
inFile>>num;
(*this->Constant)[i] = num;
}
inFile.close();
}
CLinearEquation::~CLinearEquation(void)
{
this->destroy();
if(this->Constant!=NULL)
{
delete Constant;
this->Constant = NULL;
}
}
CLinearEquation::CLinearEquation(unsigned int ne, unsigned int nv)
{//通過方程個數和未知數創建線性方程組
this->nRow = ne;
this->nColumn = nv;
this->pElement = new double[nRow*nColumn];
this->Constant = new CVector(nRow);
}
CLinearEquation::CLinearEquation(CMatrix& coe, CVector& con )
{//通過系數矩陣和常數向量創建線性方程組
this->nRow = coe.GetRowsNum();
this->nColumn = coe.GetColumnsNum();
this->pElement = new double[nRow*nColumn];
for(unsigned int i=0;i<nRow*nColumn;++i)
{
this->pElement[i] = coe.pElement[i];
}
this->Constant = new CVector(con);
}
int CLinearEquation::AddVariable(double *pcoe, unsigned int pc)
{//為方程組增加一個變量，其系數矩陣增加一列，pcoe為增加系數地址，pc為增加系數列的序號，為最前面，默認追加在尾部，成功返回未知數個數，否則為-1
if(pc>=0)
this->AddColumn(pcoe,pc);
else
this->AddColumn(pcoe,this->nColumn);//默認追加在尾部
return this->nColumn;
}
int CLinearEquation::AddEquation(double *pcoe, double con, unsigned int pr)
{//為方程組增加一個方程，其系數矩陣增加一行，pcoe為增加系數地址，con為增加方程的常數項，pr為增加系數行的序號，為最前面，默認追加在尾部，成功返回方程個數，否則為-1
if(pr>=0)
{
this->AddRow(pcoe,pr);
this->InsertConstant(con,pr);
}
else
{
this->InsertConstant(con,this->nRow);
this->AddRow(pcoe,this->nRow);
}
return this->nRow;
}
int CLinearEquation::DeleteVariable(unsigned int pc)
{//刪除方程組中第pc個未知數，并刪除其系數列
this->DeleteColumn(pc);
return 0;
}
int CLinearEquation::DeleteEquation(unsigned int pr)
{//刪除方程組中第pr個方程
this->DeleteRow(pr);
this->DeleteConstant(pr);
return 0;
}
void CLinearEquation::DeleteConstant(unsigned int pos)
{
CVector tmp(*this->Constant);
unsigned int oldDegree = this->Constant->GetDegree();
this->Constant->destory();
this->Constant = new CVector(oldDegree-1);
int i,k;
for(i=0;i<(int)pos;++i)
{
(*this->Constant)[i] = tmp[i];
}
for(k=pos+1;k<(int)oldDegree;++k,++i)
{
(*this->Constant)[i] = tmp[k];
}
}
void CLinearEquation::InsertConstant(double num,int pos)
{
CVector tmp(*this->Constant);
unsigned int oldDegree = this->Constant->GetDegree();
this->Constant->destory();
this->Constant = new CVector(oldDegree+1);
int i,k;
for(i=0;i<pos;++i)
{
(*this->Constant)[i] = tmp[i];
}
k = i;
(*this->Constant)[i] = num;
++i;
for(;k<(int)oldDegree;++k,++i)
{
(*this->Constant)[i] = tmp[k];
}
}
CVector CLinearEquation::Gaussian()
{//高斯消元法解線性方程組
int *js,l,k,i,j,is,p,q;
int n = (int)this->nRow;//方程組階數
double d,t;
js = new int[n];
l=1;
for (k=0;k<=n-2;k++)
{
d=0.0f;
for (i=k;i<=n-1;i++)
for (j=k;j<=n-1;j++)
{
t=fabs(this->pElement[i*n+j]);
if (t>d) { d=t; js[k]=j; is=i;}
}
if (d+1.0==1.0)
l=0;
else
{
if (js[k]!=k)
{
for (i=0;i<=n-1;i++)
{
p=i*n+k;
q=i*n+js[k];
t=this->pElement[p];
this->pElement[p]=this->pElement[q];
this->pElement[q]=t;
}
}
if (is!=k)
{
for (j=k;j<=n-1;j++)
{
p=k*n+j;
q=is*n+j;
t=this->pElement[p];
this->pElement[p]=this->pElement[q];
this->pElement[q]=t;
}
t=(*this->Constant)[k];
(*this->Constant)[k]=(*this->Constant)[is];
(*this->Constant)[is]=t;
}
}
if (l==0)
{
delete [] js;
return(0);
}
d=this->pElement[k*n+k];
for (j=k+1;j<=n-1;j++)
{
p=k*n+j;
this->pElement[p]=this->pElement[p]/d;
}
(*this->Constant)[k]=(*this->Constant)[k]/d;
for (i=k+1;i<=n-1;i++)
{
for (j=k+1;j<=n-1;j++)
{
p=i*n+j;
this->pElement[p]=this->pElement[p]-this->pElement[i*n+k]*this->pElement[k*n+j];
}
(*this->Constant)[i]=(*this->Constant)[i]-this->pElement[i*n+k]*(*this->Constant)[k];
}
}
d=this->pElement[(n-1)*n+n-1];
if (fabs(d)+1.0==1.0)
{
delete [] js;
return(0);
}
(*this->Constant)[n-1]=(*this->Constant)[n-1]/d;
for (i=n-2;i>=0;i--)
{
t=0.0;
for (j=i+1;j<=n-1;j++)
{
t=t+this->pElement[i*n+j]*(*this->Constant)[j];
}
(*this->Constant)[i]=(*this->Constant)[i]-t;
}
js[n-1]=n-1;
for (k=n-1;k>=0;k--)
{
if (js[k]!=k)
{
t=(*this->Constant)[k];
(*this->Constant)[k]=(*this->Constant)[js[k]];
(*this->Constant)[js[k]]=t;
}
}
delete [] js;
CVector result(*this->Constant);
return result;
}
int CLinearEquation::MatOut(const char* pFileName)
{//將矩陣以pFileName為文件名進行文件輸出
if(pFileName!=NULL)
{
ofstream outFile( pFileName );
if ( !outFile )
{
cerr << "unable to open output file: "<< pFileName << " -- bailing out!\n";
return -1;
}
unsigned int i;
for(i=0;i<this->nRow;++i)
{
if(i==nRow-1)
{
outFile<<(*this->Constant)[i]<<endl;
}
else
outFile<<(*this->Constant)[i]<<" ";
}
outFile.close();
}
return 0;
}
測試程序
文章列表
留言列表
