array.cpp

此为地球物理中的

// Array.cpp: implementation of the Array class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "P_R.h"
#include "Array.h"
#include"globalExt.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Array::Array()
{
    nRow=0;
	nCol=0;
	pValue=NULL;
}
Array::Array(int r,int c)
{
	nRow=r;
    nCol=c;
    pValue=new DOUBLE* [nRow];
    VERIFY(pValue!=NULL);
    for(int i=0;i<nRow;i++)
	{
      pValue[i]=new DOUBLE[nCol]; 
      VERIFY(pValue!=NULL);
	}
}
Array::Array(const Array &m)
{
 nRow=m.nRow;
 nCol=m.nCol;
 
 pValue=new double* [nRow];
 for(int i=0;i<nRow;i++)
 {
  pValue[i]=new double[nCol];
  memcpy(pValue[i],m.pValue[i],nCol*sizeof(DOUBLE));
 } 
}

Array::~Array()
{
 if(pValue!=NULL)
 {
  for(int i=0;i<nRow;i++)
  {
   delete [] pValue[i];
   pValue[i]=NULL;
  }
  delete [] pValue;
  pValue=NULL;
 }
 
}
int  Array:: GetColSize()
{
   return nCol;
}
int  Array::GetRowSize()
{
   return nRow;
}
void Array::GetSize(int& m,int& n)
{
    m=nRow;
	n=nCol;
}
void Array::SetSize(int row,int col)
{ 
	//重新设置数组的大小；原有的保持不变；增加的置0；
 int i,j,oldRow,oldCol;
 oldRow=nRow;
 oldCol=nCol;
 if(nRow!=row || nCol!=col)
  reallocm(row,col);
 
 if((row>oldRow)&&(col<=oldCol))//行增大，列减小；
 {
  for(int i=oldRow;i<row;i++)
   for(int j=0;j<col;j++)
    pValue[i][j]=0.0;
 }
 if((col>oldCol)&&(row<=oldRow))//列增大，行减小；
 {
  for(i=0;i<row;i++)
   for(j=oldCol;j<col;j++)
    pValue[i][j]=0.0;
 }
 
 if(row>oldRow && col>oldCol)//行，列均增大；
 {
  for(i=oldRow;i<row;i++)
  {
   for(j=0;j<col;j++)
    pValue[i][j]=0.0;
  }
  for(i=0;i<oldRow;i++)
   for(j=oldCol;j<col;j++)
    pValue[i][j]=0.0;
 }
}
void Array::reallocm(int row, int col)
{
 //重新调整矩阵大小；
 //如果矩阵扩大，原矩阵与新矩阵对应位置的值不变，扩大部分的值为随机值；
 //如果矩阵减小，对应位置的值保持不变；
 if((this->nRow)==row && (this->nCol)==col)
  return;
 
 DOUBLE** Val1=new DOUBLE* [row];
 for(int i=0;i<row;i++)
  Val1[i]=new DOUBLE[col];
 
 int colSize=min(nCol,col)*sizeof(DOUBLE);
 int minRow=min(nRow,row);

 if(pValue!=NULL)
 {
 for(i=0;i<minRow;i++)

    memcpy(Val1[i],pValue[i],colSize);
 
 for(i=0;i<nRow;i++)
  delete [] pValue[i];
  delete [] pValue;
 }
  nRow=row;
  nCol=col;
  pValue=Val1;
 return;
}
Array Array::operator*(const Array& M)
{
 
 if(nCol==M.nRow)
 {
  Array s(nRow,M.nCol);
  
  for(int i=0;i<nRow;i++)
  {
   for(int j=0;j<M.nCol;j++)
   {
    s.pValue[i][j]=0;
    for(int k=0;k<nCol;k++)
     s.pValue[i][j]+=pValue[i][k]*M.pValue[k][j];
   }
  }
  return s;
 }
 else
 {
  AfxMessageBox("数组维数不满足相乘条件");
  exit(0);
 }
}


//重载矩阵乘以常数的运算；
//注意：不能写成“常数乘以矩阵”的形式；
//即：常数必须在矩阵后面；
Array Array::operator*(const DOUBLE& x)
{
 Array s(nRow,nCol);
 for(int i=0;i<nRow;i++)
  for(int j=0;j<nCol;j++)
   s.pValue[i][j]=pValue[i][j]*x;
  return s;
  
}
Array Array::operator+(const Array& M)
{
 
 if(nRow==M.nRow && nCol==M.nCol)
 {
  Array s(nRow,nCol);
  for(int i=0;i<nRow;i++)
   for(int j=0;j<nCol;j++)
    s.pValue[i][j]=this->pValue[i][j]+M.pValue[i][j]; 
   return s; 
 }
 else
 {
  AfxMessageBox("不满足数组相加的条件");
  exit(0);
 }
}

Array Array::operator+(const DOUBLE& x)
{
 
 Array s(nRow,nCol);
 for(int i=0;i<nRow;i++)
  for(int j=0;j<nCol;j++)
   s.pValue[i][j]+=x; 
  return s;
}
void Array::operator+=(const Array& M)
{
 if(M.nRow==nRow && M.nCol==nCol)
 {
  for(int i=0;i<nRow;i++)
   for(int j=0;j<nCol;j++)
    pValue[i][j]+=M.pValue[i][j];
 }
 else
 {
  AfxMessageBox("数组维数不相等，不能相加");
  exit(0);
 }
 
}

Array Array::operator-(const Array& M)
{
 
 if(nRow==M.nRow && nCol==M.nCol)
 {
  Array s(nRow,nCol);
  for(int i=0;i<nRow;i++)
   for(int j=0;j<nCol;j++)
    s.pValue[i][j]=this->pValue[i][j]-M.pValue[i][j]; 
   return s; 
 }
 else
 {
  int r=max(nRow,M.nRow);
  int c=max(nCol,M.nCol);
  
  Array a(*this);
  Array b(M);
  
  a.SetSize(r,c);
  b.SetSize(r,c);
  Array s(r,c);
  for(int i=0;i<r;i++)
  {
   for(int j=0;j<c;j++)
    s.pValue[i][j]=a.pValue[i][j]-b.pValue[i][j]; 
  }
  return s;
 }
}

Array Array::operator-(const DOUBLE& x)
{
 Array s(nRow,nCol);
 for(int i=0;i<nRow;i++)
  for(int j=0;j<nCol;j++)
   s.pValue[i][j]-=x;
  return s;
}
void Array::operator-=(const Array& M)
{
 if(M.nRow==nRow && M.nCol==nCol)
 {
  for(int i=0;i<nRow;i++)
   for(int j=0;j<nCol;j++)
    pValue[i][j]-=M.pValue[i][j];
 }
 else
 {
  AfxMessageBox("数组维数不相等，不能相减");
  exit(0);
 }
}
DOUBLE& Array::operator()(int i, int j)
{
 if(i>=nRow||j>=nCol)
 {
  AfxMessageBox("** 警告：数组越界! **");
  exit(0);
 }
 return pValue[i][j];
}
Array Array::operator=(const  Array& M)
{
 
 if(this==&M)
  return *this;
 if(this->nCol==M.nCol && this->nRow==M.nRow)
 {
  for(int i=0;i<nRow;i++)
   for(int j=0;j<nCol;j++)
    pValue[i][j]=M. pValue[i][j];
   return *this;
   
 }
 else
 {
  AfxMessageBox("数组维数不相等，不能用＝赋值");
  exit(0);
 }
}
void Array::freeMemory()
{
 if(pValue!=NULL)
 {
  for(int i=0;i<nRow;i++)
  {
   delete [] pValue[i];
   pValue[i]=NULL;
  }
  delete [] pValue;
  pValue=NULL;
  nRow=0;
  nCol=0;
  TotleCenter=1;
 }
}
BOOL Array::SaveArray()
{ 
 static char BASED_CODE szFilter[]="二进制文件(*.txt)|*.txt|Ascii 文件(*.dat)|*.dat|";
 CFileDialog dlg(false,"二进制文件.txt",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilter);
 if(dlg.DoModal()==IDOK)
 {
  CString str=dlg.GetPathName();
  CFile file(str,CFile::modeCreate|CFile::modeReadWrite);
  CArchive ar(&file,CArchive::store);
  
  int i,j;
  CString s;
  CString s1;
  BOOL bAscii;
  CString sss=dlg.GetFileExt();
  if(sss=="dat")
       bAscii=true;
  else
      bAscii=false;
  if(bAscii)
  {
   
   s1.Format("%d  %d  \r\n",nRow,nCol);
   s=s+s1;
   ar.WriteString(s1);
   for(i=0;i<=nRow-1;i++)
   {
    s="";
    for(j=0;j<=nCol-1;j++)
    {
     s1.Format("%.8lf  ", pValue[i][j]);
     s=s+s1; 
    }
    ar.WriteString(s);
    ar.WriteString("\r\n");//回车换行符号；
   }   
   return true;