main.cpp

电路分析小程序

//touwenjian
#include "iostream.h"
#include "stdio.h"
#include "conio.h"
#include <memory.h>
#include <math.h>
//hongdingyi
#define R     1
#define G     2
#define VS    3
#define CS    4
#define VCCS  5
#define VCVS  6
#define CCCS  7
#define CCVS  8
#define OPAMP 9
#define N     50
//全局变量
int nod=0,mod=0;extern vBranchNumber;extern NodeNumber;
int Number;
int vBranchNumber;
int NodeNumber=0;
int *vbNUM_bNUM;
int *bNUM_vbNUM;
typedef struct tagbranch
{

	int number;
	int type;
	int nfrom;
	int nto;
	float value;
	int ncfrom;
	int ncto; 
} BRANCH;
//hanshushengming
float* * input(int);
void Printzgjz(float**,int);
float* *GaussFE(float**,int);
float* GaussBS(float**,int);
void GaussResult(float*,int);
void FileSave(float**,int,int);
float** FileOpen(char*);
float** Choose();

void  sortBranch(BRANCH*,int);
void vbBranch(BRANCH*,int);
float** allMatrix(BRANCH*,int);

void main()
{	

	float* *InputArray,**GauArray;
	InputArray=Choose();//输入及处理
	Number=vBranchNumber+NodeNumber;
	cout<<"增广矩阵是:\n"<<endl;
	Printzgjz(InputArray,Number);
	cout<<"是否保存输入？y/n  \n"<<endl;
	char Choice;
	cin>>Choice;
	switch(Choice)
	{
	case 'y':

		FileSave(InputArray,vBranchNumber,NodeNumber);
		break;
	case 'n':
		break;
	default:cout<<"error!"<<endl;
	}
	GauArray=GaussFE(InputArray,Number);//高斯前消
	cout<<"Gauss前消计算中……\n"<<endl;
	Printzgjz(GauArray,Number);
	cout<<"Gauss后代计算中……\n"<<endl;
	float *result=GaussBS(GauArray,Number);
	GaussResult(result,Number);//结果显示
	getchar();
	getchar();
}

void FileSave(float* * array,int m,int n)
{
	FILE *fp;
	char name[100];
	cout<<"输入文件名和路径:\n";
	cin>>name;
	fp=fopen(name,"w");
	int Nb=m+n;
	if(fp!=NULL)
	{
		fwrite(&m,sizeof(int),1,fp);
		fwrite(&n,sizeof(int),1,fp);
		for(int i=1;i<=Nb;++i)
		{
			for(int j=1;j<=Nb+1;++j)
			{
				fwrite(&array[i][j],sizeof(float),1,fp);
			}
		}
	}	
	fclose(fp);
}

float** FileOpen(char* name)
{
	FILE *fp;
	fp=fopen(name,"r");
	if(fp==NULL)
	{
		printf("file can not be openned!");
		return 0;
	}
	fread(&mod,sizeof(int),1,fp);
	fread(&nod,sizeof(int),1,fp);
	int Nb=mod+nod;
	float**Data=new float*[Nb];
	for(int m=1;m<=Nb;++m)
	{
		Data[m]=new float[Nb+1];
	}
	for(int i=1;i<=Nb;++i)
	{	
		for(int j=1;j<=Nb+1;++j)
		{
			fread(&Data[i][j],sizeof(float),1,fp);
		}
	}	
	fclose(fp);
	return Data;
}

float** Choose()
{
	float**aMatrix=new float*[20];
	for(int m=0;m<=20;m++)
	{
		aMatrix[m]=new float[20];
	}
	 for(int i=0;i<20;i++)
		 for(int j=0;j<20;j++)
			aMatrix[i][j]=0;

	cout<<"新建'n',打开'o'"<<endl;
	char FileName[100];
	char mode=getchar();
	{
		switch(mode)
		{
		case 'o':
			cout<<"输入路径和文件名："<<endl;
			cin>>FileName;
			aMatrix=FileOpen(FileName);
		    vBranchNumber=mod;
			NodeNumber=nod;
			break;
		case 'n':
			{
				BRANCH *Branch;
				int BranchNumber=0;
				cout<<"支路个数：\n"<<endl;
				cin>>BranchNumber;
				cout<<"独立节点个数：\n"<<endl;
				cin>>NodeNumber;
				Branch=new BRANCH[BranchNumber+1];
				for(int i=1;i<=BranchNumber;i++)
				{
					cout<<"支路号：\n"<<endl;
					cin>>Branch[i].number;
					cout<<"支路类型：\n"<<endl;
					int ZhiluType=0;
					int ZhiluHao=0;
					cin>>ZhiluType;
					switch(ZhiluType)
					{
					case R: 
						ZhiluHao=R;break;
					case G :
						ZhiluHao=G;break;
					case VS:
						ZhiluHao=VS;break;
					case CS:
						ZhiluHao=CS;break;
					case 'VCCS':
					case 'vccs':
						ZhiluHao=VCCS;break;
					case VCVS:
						ZhiluHao=VCVS;break;
					case CCCS:
						ZhiluHao=CCCS;break;
					case CCVS:
						ZhiluHao=VCVS;break;
					}
					Branch[i].type=ZhiluHao;
					cout<<"始节点：\n"<<endl;
					cin>>Branch[i].nfrom;
					cout<<"终结点：\n"<<endl;
					cin>>Branch[i].nto;
					cout<<"参数值：\n"<<endl;
					cin>>Branch[i].value;
					cout<<"控制始节点：\n"<<endl;
					cin>>Branch[i].ncfrom;
					cout<<"控制终结点：\n"<<endl;
					cin>>Branch[i].ncto;
				}
			
				sortBranch(Branch,BranchNumber);
				vbBranch(Branch,BranchNumber);
				aMatrix=allMatrix(Branch,BranchNumber);
				
			}
			break;
		default:cout<<"重新输入！"<<endl;
		}
	}
	return	aMatrix;	
}

void  sortBranch(BRANCH *Branch,int BranchNumber)
{
	BRANCH Branch0;
	int len,l,m;
	len=sizeof(Branch0);
	for(int i=1;i<BranchNumber+1;i++)
	{
		int k=Branch[i].number;
		m=i;
		for(int j=i+1;j<BranchNumber+1;j++)
		{
			 l=Branch[j].number;
			if(k>l){ k=l; m=j; }
		}
		memcpy(&Branch0,Branch+i,len);
		memcpy(Branch+i,Branch+m,len);
		memcpy(Branch+m,&Branch0,len);
	}
}

void vbBranch(BRANCH*Branch,int BranchNumber)
{
	int k,tt,j;
	bNUM_vbNUM=new int[BranchNumber+1];
	vBranchNumber=0;
	for(int i=1;i<BranchNumber+1;i++)
		bNUM_vbNUM[i]=0;
	for(i=1;i<BranchNumber+1;i++)
	{ 
		int t=Branch[i].type;
		if(t==VS||t==VCVS||t==OPAMP)
		{
			vBranchNumber++;
			bNUM_vbNUM[i]=vBranchNumber;
		}
		 else if(t==CCVS)
		 {
			 vBranchNumber++;
			 bNUM_vbNUM[i]=vBranchNumber;
			  k=Branch[i].ncfrom;
			  tt=Branch[k].type;
			 if((tt==G||tt==R)&&Branch[k].ncfrom==0&&Branch[k].ncto==0)
			 { 
				 vBranchNumber++;
				 bNUM_vbNUM[k]=vBranchNumber;
				 Branch[k].ncto=1;
			 }
		 }
		 else if(t==CCCS)
		 { 
			 k=Branch[i].ncfrom;
			 tt=Branch[k].type;
			 if((tt==G||tt==R)&&Branch[k].ncfrom==0&&Branch[k].ncto==0)
			 {
				 vBranchNumber++;
				 bNUM_vbNUM[k]=vBranchNumber;
				 Branch[k].ncto=1;
			 }
		 }
		 else if((t==G||t==R)&(Branch[i].ncfrom==1))
		 {
			 vBranchNumber++;
			 bNUM_vbNUM[k]=vBranchNumber;
		 }
	}
	vbNUM_bNUM=new int[vBranchNumber+1];
	for(i=1;i<BranchNumber+1;i++)
	{
    j=bNUM_vbNUM[i];
	vbNUM_bNUM[j]=i;
	}
 }

float** allMatrix(BRANCH*Branch,int BranchNumber)
 {  
	float val;
	BRANCH *br;
	int nb=NodeNumber+vBranchNumber+1;
	float**bMatrix=new float*[20];
	for(int m=0;m<=20;m++)
	{
		bMatrix[m]=new float[20];
	}
	 for(int i=0;i<nb+1;i++)
		 for(int j=0;j<nb+2;j++)
			 bMatrix[i][j]=0.00;
	 for(i=1;i<BranchNumber+1;i++)
	 {       
		 br=Branch+i;
		 int t=br->type;
		 int nf=br->nfrom;
		 int nt=br->nto;
		 int ncf=br->ncfrom;
		 int nct=br->ncto;
		 val=br->value;
		 if(t==R)
		 {
			 if(ncf==0&&nct==0)
			 {
				 val=(float)1.0/val;
				 if(nf==0) bMatrix[nt][nt]+=val;
				 else if(nt==0)bMatrix[nf][nf]+=val;
				 else {
					 bMatrix[nf][nf]+=val;
					 bMatrix[nt][nt]+=val;
					 bMatrix[nf][nt]-=val;
					 bMatrix[nt][nf]-=val;
				 }
			 }
			 else{
				 int k=br->number;
				 k=bNUM_vbNUM[k];
				 k=k+NodeNumber;
				 bMatrix[nf][k]+=1.0;
				 bMatrix[nt][k]+=-1.0;
				 bMatrix[k][nf]+=1.0;
				 bMatrix[k][nt]-=1.0;
				 bMatrix[k][k]-=(float)1.0*val;
			 }
		 }
		 else if(t==G)
		 {
			 if(ncf==0&&nct==0)
			 {  if(nf==0) bMatrix[nt][nt]+=val;
			 else if(nt==0)bMatrix[nf][nf]+=val;
			 else {
				 bMatrix[nf][nf]+=val;
				 bMatrix[nt][nt]+=val;
				 bMatrix[nf][nt]-=val;
				 bMatrix[nt][nf]-=val;
			 }
			 }
			 else{
				int  k=br->number;
				 k=bNUM_vbNUM[k];
				 k=k+NodeNumber;
				 bMatrix[nf][k]+=1.0;
				 bMatrix[nt][k]-=1.0;
				 bMatrix[k][nf]+=1.0;
				 bMatrix[k][nt]-=1.0;
				 bMatrix[k][k]-=(float)1.0/val;
			 }
		 }
		 else if(t==VCCS)
		 {  bMatrix[nf][ncf]+=val;
		 bMatrix[nf][nct]-=val;
		 bMatrix[nt][ncf]-=val;
		 bMatrix[nt][nct]+=val;
		 }
		 else if(t==CCCS)
		 {  
		 int k=ncf;
		 k=bNUM_vbNUM[k];
		 k=k+NodeNumber;
		 bMatrix[nf][k]=val;
		 bMatrix[nt][k]-=(float)1.0*val;
		 }
		 else if(t==VCVS)
		 {  
		 int k=br->number;
		 k=bNUM_vbNUM[k];
		 k=k+NodeNumber;
		 bMatrix[nf][k]+=1.0;
		 bMatrix[nt][k]-=1.0;
		 bMatrix[k][nf]+=1.0;
		 bMatrix[k][nt]-=1.0;
		 bMatrix[k][ncf]-=(float)1.0*val;
		 bMatrix[k][nct]+=val;
		 }
		 else if(t==CCVS)
		 { 
	     int kk=br->ncfrom;
		 kk=bNUM_vbNUM[kk];
		 kk=kk+NodeNumber;
		 int k=br->number;
		 k=bNUM_vbNUM[k];
		 k=k+NodeNumber;
		 bMatrix[nf][k]+=1.0;
		 bMatrix[nt][k]-=1.0;
		 bMatrix[k][nf]+=1.0;
		 bMatrix[k][nt]-=1.0;
		 bMatrix[k][kk]-=(float)1.0*val;
		 }
		 else if(t==OPAMP)
		 { 
	     int k=br->number;
		 k=bNUM_vbNUM[k];
		 k=k+NodeNumber;
		 bMatrix[nf][k]+=1.0;
		 bMatrix[nt][k]-=1.0;
		 bMatrix[k][ncf]+=1.0;
		 bMatrix[k][nct]-=1.0;
		 }
		 else if(t==CS)
		 { bMatrix[nf][nb]-=val;//+ or -?
		 bMatrix[nt][nb]+=val;
		 }
		 else if(t==VS)
		 { 
		 int k=br->number;
		 k=bNUM_vbNUM[k];
		 k=k+NodeNumber;
		 bMatrix[nf][k]+=1.0;
		 bMatrix[nt][k]-=1.0;
		 bMatrix[k][nf]+=1.0;
		 bMatrix[k][nt]-=1.0;
		 bMatrix[k][nb]+=val;
		 }
	 }
	 return bMatrix;
 }



float* * input(int Number)
{	
	cout<<"输入增广矩阵(按行)"<<endl;
	float* *p = new float*[Number];
	for(int i=0;i<Number;++i)
	{
		p[i]=new float[Number+1];
	}
	for(int rl=0;rl<Number;++rl)
	{
		for(int cl=0;cl<Number+1;++cl)
		{
			cin>>p[rl][cl];
		}

	}
	return p;
}

void Printzgjz(float* *InputArray,int Number)
{
	for(int i=1;i<=Number;++i)
	{
		for(int j =1;j<=Number+1;++j)
		{
			printf("%f\t",*(*(InputArray+i)+j));
		}
	printf("\n");
	}
}

void GaussResult(float*result,int Number)
{
	for(int i=1;i<=vBranchNumber;i++)
	{
		printf("Vn(%d) = %f V\n",i,result[i]);
	}
	for(int h=vBranchNumber+1;h<=Number;h++)
	{
		printf("Iv(%d) = %f A\n",h-vBranchNumber,result[i]);
	}

}