最新C语言编写短路电流计算的程序文档格式.docx
《最新C语言编写短路电流计算的程序文档格式.docx》由会员分享，可在线阅读，更多相关《最新C语言编写短路电流计算的程序文档格式.docx（15页珍藏版）》请在冰豆网上搜索。
floatGetI（）const;
voidSetRI（floatpR,floatpI）;
voidSetR（floatpR）;
voidSetI（floatpI）;
private:
floatm_pluralR;
floatm_pluralI;
};
//名称:
复数乘法，PluralMul（Pluralplural1,Pluralplural2）
//参数：
复数plural1plural2
//返回值：
复数
PluralPluralMul（Pluralplural1,Pluralplural2）;
//函数名：
复数除法，运算浮点数除以复数
num，分子，是一个浮点数。
den，分母，是一个复数
结果的复数
PluralPluralDiv（floatnum,Pluralden）;
复数求倒数
此复数的倒数
PluralPluralDiv（Pluralplu）;
mat为待变换的复数矩阵的数组名，n为阶数
无
//说明：
变换后的结果依旧保存在mat中
voidMatrixInv（Plural*mat,intn）;
#endif
#include"
plural.hpp"
#include<
stdio.h>
stdlib.h>
math.h>
Plural:
:
Plural（）
m_pluralR=0;
m_pluralI=0;
}
Plural（floatpR,floatpI）
m_pluralR=pR;
m_pluralI=pI;
~Plural（）{}
floatPlural:
GetR（）const
returnm_pluralR;
GetI（）const
returnm_pluralI;
voidPlural:
SetRI（floatpR,floatpI）
m_pluralR=pR;
m_pluralI=pI;
SetR（floatpR）
SetI（floatpI）
//
名称:
参数：
返回值：
PluralPluralMul（Pluralplural1,Pluralplural2）
Pluralresult;
result.SetRI（plural1.GetR（）*plural2.GetR（）-plural1.GetI（）*plural2.GetI（）,plural1.GetR（）*plural2.GetI（）+plural1.GetI（）*plural2.GetR（））;
returnresult;
PluralPluralDiv（floatnum,Pluralden）
floatk;
k=den.GetR（）*den.GetR（）+den.GetI（）*den.GetI（）;
result.SetR（num*den.GetR（）/k）;
result.SetI（-1.0*num*den.GetI（）/k）;
PluralPluralDiv（Pluralplu）
k=plu.GetR（）*plu.GetR（）+plu.GetI（）*plu.GetI（）;
result.SetR（plu.GetR（）/k）;
result.SetI（-1.0*plu.GetI（）/k）;
//说明：
以下3个函数组合用来求复数矩阵的逆。
double*inv（double*A,double*Ainv,intn）;
voidmulAB（double*A,double*B,double*C,intam,intan,intbm,intbn）;
//矩阵求逆。
A为原矩阵，Ainv为求逆之后矩阵，n为阶数
double*inv（double*A,double*Ainv,intn）
{
int*is,*js,i,j,k,l,u,v;
doubled,p;
for（i=0;
i<
n*n;
i++）
*（Ainv+i）=*（A+i）;
is=（int*）malloc（n*sizeof（int））;
js=（int*）malloc（n*sizeof（int））;
for（k=0;
k<
=n-1;
k++）
d=0.0;
for（i=k;
for（j=k;
j<
j++）
{
l=i*n+j;
p=fabs（Ainv[l]）;
if（p>
d）
d=p;
is[k]=i;
js[k]=j;
}
if（d+1.0==1.0）
free（is）;
free（js）;
returnNULL;
if（is[k]!
=k）
for（j=0;
u=k*n+j;
v=is[k]*n+j;
p=Ainv[u];
Ainv[u]=Ainv[v];
Ainv[v]=p;
if（js[k]!
for（i=0;
u=i*n+k;
v=i*n+js[k];
l=k*n+k;
Ainv[l]=1.0/Ainv[l];
if（j!
u=k*n+j;
Ainv[u]=Ainv[u]*Ainv[l];
if（i!
for（j=0;
u=i*n+j;
Ainv[u]=Ainv[u]-Ainv[i*n+k]*Ainv[k*n+j];
if（i!
Ainv[u]=-Ainv[u]*Ainv[l];
for（k=n-1;
k>
=0;
k--）
if（js[k]!
=k）
v=js[k]*n+j;
v=i*n+is[k];
returnAinv;
a为原矩阵，b为逆矩阵，c为结果。
其他在此都为n
voidmulAB（double*a,double*b,double*c,intam,intan,intbm,intbn）
inti,j,l,u;
if（an!
=bm）
printf（"
不能完成原矩阵和其逆矩阵矩阵相乘\n"
）;
return;
}
am;
bn;
u=i*bn+j;
c[u]=0.0;
for（l=0;
l<
an;
l++）
c[u]=c[u]+a[i*an+l]*b[l*bn+j];
//复数矩阵求逆。
mat为待求矩阵，n为阶数
voidMatrixInv（Plural*mat,intn）
inti,j;
doublepluralR[n][n],pluralI[n][n];
double*a=NULL,*b=NULL,*c=NULL;
double*resultR=NULL,*resultI=NULL;
Pluralresult[n][n];
n;
{
for（j=0;
pluralR[i][j]=mat[i*n+j].GetR（）;
pluralI[i][j]=mat[i*n+j].GetI（）;
printf（"
原始矩阵为:
\n"
for（i=0;
i<
i++）
for（j=0;
j<
j++）
%10.4f+j%0.4f\t"
（*pluralR）[i*n+j],（*pluralI）[i*n+j]）;
}
a=（double*）malloc（n*n*sizeof（double））;
b=（double*）malloc（n*n*sizeof（double））;
c=（double*）malloc（n*n*sizeof（double））;
resultR=inv（*pluralR,a,n）;
resultI=inv（*pluralI,b,n）;
if（resultI!
=NULL）
\n求逆之后虚部是:
if（n%2==0）
resultR==NULL?
0:
resultR[i*n+j],resultI==NULL?
resultI[i*n+j]）;
else
-1.0*resultI[i*n+j]）;
测试所求实部逆矩阵
mulAB（*pluralR,a,c,n,n,n,n）;
\n\n求逆后原实部和现在的实部乘积是\n"
j++）
%10.4f\t"
c[i*n+j]）;
测试用所求逆矩阵
mulAB（*pluralI,b,c,n,n,n,n）;
\n\n求逆之后原虚部和现在的虚部乘积是:
-1.0*c[i*n+j]）;
mat[i*n+j].SetRI（resultR==NULL?
resultR[i*n+j],resultI==NULL?
free（a）;
free（b）;
free（c）;
iostream>
//#include"
input.hpp"
usingnamespacestd;
voidNodInit（）
floatg1S,g1X,g2S,g2X,l1L,l1D,l2L,l2D,t1S,t1U,t2S,t2U;
cout<
<
"
请输入发电机G1的容量S（无穷大请输入0）：
"
;
cin>
>
g1S;
请输入发电机G1的电抗Xd（没有请输入0）：
g1X;
endl<
******************************************"
<
endl;
请输入发电机G2的容量S（无穷大请输入0）：
g2S;
请输入发电机G2的电抗Xd（没有请输入0）：
g2X;
请输入线路1的长度L（KM）：
l1L;
请输入线路1每千米电抗值：
l1D;
请输入线路2的长度L（KM）：
l2L;
请输入线路2每千米电抗值：
l2D;
请输入变压器T1的容量S（MVA）：
t1S;
请输入变压器T1的Uk%：
t1U;
请输入变压器T2的容量S（MVA）：
t2S;
请输入变压器T2的Uk%：
t2U;
intmain（）
NodInit（）;
Pluralmatrix2[3][3];
matrix2[0][0].SetRI（0,1）;
matrix2[0][1].SetRI（0,2）;
matrix2[1][0].SetRI（0,1）;
matrix2[1][1].SetRI（0,1）;
matrix2[0][2].SetRI（0,2）;
matrix2[1][2].SetRI（0,1）;
matrix2[2][0].SetRI（0,3）;
matrix2[2][1].SetRI（0,2）;
matrix2[2][2].SetRI（0,1）;
MatrixInv（*matrix2,3）;
\n1点短路电流是\n"
%f+j%f"
PluralDiv（matrix2[0][0]）.GetR（）,PluralDiv（matrix2[0][0]）.GetI（））;
\n2点短路电流是\n"
PluralDiv（matrix2[1][1]）.GetR（）,PluralDiv（matrix2[1][1]）.GetI（））;
\n3点短路电流是\n"
升级会员 