sparsematrix.h

该程序是一个含直流输电系统的潮流计算程序 程序运行需要包含Boost库文件,需要在VS2005环境以上(VC6.0不完全符合C++标准,可能有些变量作用域问题,无法通过调试) 潮流程序计算主要参考

 int i,j,k;                                           
 
  if(bFactorBuilded) return false;

    FullFactorTable=new Type *[rows];
    for(i=0;i<rows;i++)
		FullFactorTable[i]=new Type[cols];

for(i=0;i<rows;i++)  
	for(j=0;j<cols;j++)
			FullFactorTable[i][j]=GetElement(i,j);

 for(i=0;i<rows;i++)                                  
 { 
 	Type aii=FullFactorTable[i][i];                         
 	for(j=i+1;j<cols;j++)	//归一化                    
 	{                                                   
 	Type temp;                                
 		temp=FullFactorTable[i][j];                         
 		if(Abs(temp)<THRESHOLD) continue;	    
 		temp/=aii;                                  
	    FullFactorTable[i][j]=temp;  
 	}                                                   
                                                      
 	for(j=i+1;j<rows;j++)	//消去                      
 	{                                                   
 		Type aji=FullFactorTable[j][i];                 
 		if(Abs(aji)<THRESHOLD) continue;            
 		for(k=i+1;k<rows;k++)                       
 		{       
			Type ajk;
 			Type aik=FullFactorTable[i][k];         
 			if(Abs(aik)<THRESHOLD) continue;         
 			ajk=FullFactorTable[j][k];         
			ajk=ajk-aik*aji; 
			if(Abs(ajk)<THRESHOLD) continue;
			FullFactorTable[j][k]=ajk;
 		}                                           
 	}                                                   
 } 

 
bFactorBuilded=true;                                   
 return true;                              
}

/*!!!!!!!!!!!!!!!!!!!原方案备份
//----------------------------------------------ResolveEquation()
template < typename Type > bool CsparMatrix<Type>::ResolveEquation(Type* pB)
{
	if(rows!=cols) return false;	//不是方阵，失败                       
	if(pB==NULL) return false;                                              
	if(bFactorBuilded==false) return false;	//没有建立因子表，失败         
                                                                               
	int i,j;                                                               
	for(i=0;i<rows;i++)	//前代                                         
	{                                                                      
		Type aii=GetElement(i,i);                                    
		pB[i]/=aii;                                                     
		for(j=i+1;j<rows;j++)                                          
		{                                                              
			Type aji=GetElement(j,i);                            
			if(myabs(aji)<SMALLEST) continue;                       
			pB[j]-=pB[i]*aji;                                        
		}                                                              
	}                                                                      
	for(i=rows-1;i>=0;i--)	//后代                                         
	{                                                                      
		for(j=i-1;j>=0;j--)                                            
		{                                                              
			Type aji=GetElement(j,i);                            
			if(myabs(aji)<SMALLEST) continue;                       
			pB[j]-=pB[i]*aji;                                        
		}                                                              
	}                                                                      
	return true;                                                           

};
*/
//----------------------------------------------ResolveEquation()
template < typename Type > bool SparseMatrix<Type>::ResolveEquation(Type* pB)
{
	if(rows!=cols) return false;	//不是方阵，失败                       
	if(pB==NULL) return false;                                              
	if(bFactorBuilded==false) return false;	//没有建立因子表，失败         
                                                                               
	int i,j;                                                               
	for(i=0;i<rows;i++)	//前代                                         
	{                                                                      
		Type aii=FullFactorTable[i][i];                                    
		pB[i]/=aii;                                                     
		for(j=i+1;j<rows;j++)                                          
		{                                                              
			Type aji=FullFactorTable[j][i];                            
			if(Abs(aji)<THRESHOLD) continue;                       
			pB[j]-=pB[i]*aji;                                        
		}                                                              
	}                                                                      
	for(i=rows-1;i>=0;i--)	//后代                                         
	{                                                                      
		for(j=i-1;j>=0;j--)                                            
		{                                                              
			Type aji=FullFactorTable[j][i]; 
			if(Abs(aji)<THRESHOLD) continue;                       
			pB[j]-=pB[i]*aji;                                        
		}                                                              
	}                                                                      
	return true;                                                           

};

//--------------------------------Display
template < typename Type > void SparseMatrix<Type>::Display(){
	Type vv;
	for(int i=0;i<rows;i++){
		for(int j=0;j<cols;j++){
			vv = GetElement(i,j);
			cout<<"("<<i+1<<","<<j+1<<") = "<<vv<<"  ";
		}
		cout<<endl;
	}
}
//--------------------------------DisplayInFile()
template < typename Type > void SparseMatrix<Type>::DisplayInFile(char *pFileName){
	
	ofstream myfile(pFileName);
	Type vv;
	for(int i=0;i<rows;i++){
		for(int j=0;j<cols;j++){
			vv = GetElement(i,j);

			myfile<<"("<<i+1<<","<<j+1<<") = "<<vv<<"  ";
		}
		cout<<endl;
	}
}

//---------------------------------DisplayMatlab()
template < typename Type > void SparseMatrix<Type>::DisplayMatlab(char *pFileName){
	
	ofstream myfile(pFileName);
	Type vv;
	for(int i=0;i<rows;i++){
		for(int j=0;j<cols;j++){
			vv = GetElement(i,j);
            myfile<<vv<<", ";
		}
		myfile<<";";
	}
}


//-------------------------------------备份
//---先检测是否初始化，因子表化，然后才开始备份

template < typename Type > bool SparseMatrix<Type>::BackupElements()
{
	bool bSuc;
	int i,j,colum;
	Type Elem;
    CMNode <Type> *p2 ;
    CMNode <Type> *p1 ;
	CMNode<Type> * p3;
	CMNode <Type> *p0 ;

   if(!bInitialized) return false;
   if(bFactorBuilded) return false;
   if(bBackuped)  //如果已经备份，则删除原来的备份
   {
	 bSuc=DelBackupedElements();
     if(!bSuc) return false;
   }

	H0 = new CMtNode<Type>[rows];   

   for(i=0;i<rows;i++)
   {
		H0[i].nnz_row=H[i].nnz_row;
		p0=H[i].right;
		
		if(p0==NULL) continue;
	   for(j=0;j<H[i].nnz_row;j++)
	   {
		Elem=p0->value;
		colum=p0->col;	
        p1 = H0[i].right;		
        if(p1 == NULL){
			p3 = new CMNode<Type>(Elem);
			p3->col =colum;
			H0[i].right= p3;
			p2=p3;
		} 
		else
		{
			p3 = new CMNode<Type>(Elem);
			p3->col =colum;
		    p2->right=p3;
			p2=p3;
		}
		p0=p0->right;
		if(p0==NULL) break;
	   }
   }
    bBackuped=true;
	return true;
}


 //矩阵元素改变或清空矩阵内容则要删除已备份的元素
template < typename Type > bool SparseMatrix<Type>::DelBackupedElements()	
{
	int I;

	if(!bBackuped) return false;

	for(I = 0; I < rows;I++){
		CMNode<Type> * p;
		p = H0[I].right;
		do{
			if(p == NULL)break;
			CMNode<Type> *pt = p;
			p = p->right;
			delete pt;
		}while(true);
	}
	delete []H0;	

	bBackuped=false;
	return true;
}

//清空矩阵内容则要删除元素和已备份的元素
template < typename Type > bool SparseMatrix<Type>::DeleteAllElements()
{	
	 if(!bInitialized) return false;

	for(int I = 0; I < rows;I++){
		CMNode<Type> * p;
		p = H[I].right;
		do{
			if(p == NULL)break;
			CMNode<Type> *pt = p;
			p = p->right;
			delete pt;
		}while(true);
	}
	delete []H;

  if(bBackuped)
  {
	DelBackupedElements();
  }

  if(bFactorBuilded)
  {
	   for(int i=0;i<rows;i++)
		  delete [] FullFactorTable[i];

  		bFactorBuilded=false;
  }

	bBackuped=false;
   //初始化，重新分配空间
	Initialize(rows,cols);
	return true;
}   
	
//-------------------------------------恢复备份的元素
//---先检测是否备份过，然后删除元素，再恢复

 template < typename Type > bool SparseMatrix<Type>::RestoreBackupedElems()
 {
 	
	int i,j;
	Type Elem;
	int colum;
	CMNode <Type> *p0 ;
    CMNode <Type> *p2 ;
    CMNode <Type> *p1 ;
	CMNode<Type> * p3;

//没有备份，返回false
   if(!bBackuped) return false;
   
//先清空元素
    DeleteElements();
    bBackuped=true;

//赋值
  for(i=0;i<rows;i++)
  {
	  p0=H0[i].right;
	  H[i].nnz_row= H0[i].nnz_row;
	  if(p0==NULL) continue;
	  
	   for(j=0;j<cols;j++)
	   {
		Elem=p0->value;
		colum=p0->col;

       	p1=H[i].right;
        if(p1 == NULL){
			p3 = new CMNode<Type>(Elem);
			p3->col =colum;
			H[i].right = p3;
			p2=p3;
		} 
		else
		{
			p3 = new CMNode<Type>(Elem);
			p3->col =colum;
		    p2->right=p3;
			p2=p3;
		}

		 p0=p0->right;
		 if(p0==NULL) break;
	   }

  }
	return true;


 }	
	 
//清空已有的元素	
template < typename Type > void SparseMatrix<Type>::DeleteElements()
 {
 	
 //删除已有元素
  	for(int I = 0; I < rows;I++){
		CMNode<Type> * p;
		p = H[I].right;
		do{
			if(p == NULL)break;
			CMNode<Type> *pt = p;
			p = p->right;
			delete pt;
		}while(true);
	}
	delete []H;


 if(bFactorBuilded)
  {
	   for(int i=0;i<rows;i++)
		  delete [] FullFactorTable[i];

  		bFactorBuilded=false;
  }

//初始化，重新分配空间
	Initialize(rows,cols);
}

#endif