C语言编写短路电流计算的程序.docx

C语言编写短路电流计算的程序.docx

《C语言编写短路电流计算的程序.docx》由会员分享，可在线阅读，更多相关《C语言编写短路电流计算的程序.docx（10页珍藏版）》请在冰豆网上搜索。

C语言编写短路电流计算的程序

初始条件：

如图所示电力系统，最大运行方式时，两个电源同时送电，变压器并联运行，忽略线路电阻，线路电抗0.4Ω/km。

计算k1和k2点在最大运行方式时的三相短路电流。

要求完成的主要任务:

（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）

1.写出三相短路电流的计算方法；

2.用C或FORTRAN语言实现三相短路电流的计算程序；

3.调试程序并求出计算结果；

4.撰写计算方法原理、计算流程文档及设计说明书；

5.提供计算程序代码。

代码使用C++编写的，共有三个文件，请建立工程，一起编译。

这是Plural.hpp

#ifndefPLURAL_HPP

#definePLURAL_HPP

//类名称：

Plural 

//方法：

GetR,GetI,SetRI,SetR,SetI

//数据：

m_pluralR,m_pluralI 

classPlural

{

    public:

        Plural（）;

        Plural（floatpR,floatpI）;

        ~Plural（）;

        floatGetR（）const;

        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）;

//函数名：

复数求倒数 

//参数：

den，分母，是一个复数 

//返回值：

此复数的倒数 

PluralPluralDiv（Pluralplu）;

//参数：

mat为待变换的复数矩阵的数组名，n为阶数 

//返回值：

无 

//说明：

变换后的结果依旧保存在mat中 

voidMatrixInv（Plural*mat,intn）;

#endif

#include"plural.hpp"

#include

#include

#include

//类名称：

Plural 

//方法：

GetR,GetI,SetRI,SetR,SetI

//数据：

m_pluralR,m_pluralI 

Plural:

:

Plural（）

{

  m_pluralR=0;

  m_pluralI=0;

}

Plural:

:

Plural（floatpR,floatpI）

{

  m_pluralR=pR;

  m_pluralI=pI;                           

}

Plural:

:

~Plural（）{}

floatPlural:

:

GetR（）const

{

  returnm_pluralR;

}

floatPlural:

:

GetI（）const

{

  returnm_pluralI;

}

voidPlural:

:

SetRI（floatpR,floatpI）

{

    m_pluralR=pR;

    m_pluralI=pI;

}

voidPlural:

:

SetR（floatpR）

{

    m_pluralR=pR;

}

voidPlural:

:

SetI（floatpI）

{

    m_pluralI=pI;

}

//  名称:

复数乘法，PluralMul（Pluralplural1,Pluralplural2）

//  参数：

复数plural1plural2 

//  返回值：

复数 

PluralPluralMul（Pluralplural1,Pluralplural2）

{

    Pluralresult;

    result.SetRI（plural1.GetR（）*plural2.GetR（）-plural1.GetI（）*plural2.GetI（）,plural1.GetR（）*plural2.GetI（）+plural1.GetI（）*plural2.GetR（））;

    returnresult;

}

//函数名：

复数除法，运算浮点数除以复数 

//参数：

num，分子，是一个浮点数。

den，分母，是一个复数 

//返回值：

结果的复数 

PluralPluralDiv（floatnum,Pluralden）

{

    Pluralresult;

    floatk;

    k=den.GetR（）*den.GetR（）+den.GetI（）*den.GetI（）;

    result.SetR（num*den.GetR（）/k）;

    result.SetI（-1.0*num*den.GetI（）/k）;

    returnresult; 

}

//函数名：

复数求倒数 

//参数：

den，分母，是一个复数 

//返回值：

此复数的倒数 

PluralPluralDiv（Pluralplu）

{

    Pluralresult;

    floatk;

    k=plu.GetR（）*plu.GetR（）+plu.GetI（）*plu.GetI（）;

    result.SetR（plu.GetR（）/k）;

    result.SetI（-1.0*plu.GetI（）/k）;

    returnresult; 

}

//说明：

以下3个函数组合用来求复数矩阵的逆。

double*inv（double*A,double*Ainv,intn）;

voidmulAB（double*A,double*B,double*C,intam,intan,intbm,intbn）;

//参数：

mat为待变换的复数矩阵的数组名，n为阶数 

//返回值：

无 

//说明：

变换后的结果依旧保存在mat中 

voidMatrixInv（Plural*mat,intn）;

//矩阵求逆。

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

  *（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;i<=n-1;i++）

  for（j=k;j<=n-1;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;j<=n-1;j++）

    { 

        u=k*n+j; 

        v=is[k]*n+j;

        p=Ainv[u]; 

        Ainv[u]=Ainv[v]; 

        Ainv[v]=p;

    }

  if（js[k]!

=k）

    for（i=0;i<=n-1;i++）

    { 

        u=i*n+k; 

        v=i*n+js[k];

        p=Ainv[u]; 

        Ainv[u]=Ainv[v]; 

        Ainv[v]=p;

    }

  l=k*n+k;

  Ainv[l]=1.0/Ainv[l];

  for（j=0;j<=n-1;j++）

      if（j!

=k）

      { 

        u=k*n+j; 

        Ainv[u]=Ainv[u]*Ainv[l];

      }

  for（i=0;i<=n-1;i++）

      if（i!

=k）

        for（j=0;j<=n-1;j++）

        if（j!

=k）

        { 

          u=i*n+j;

          Ainv[u]=Ainv[u]-Ainv[i*n+k]*Ainv[k*n+j];

        }

  for（i=0;i<=n-1;i++）

  if（i!

=k）

  { 

      u=i*n+k; 

      Ainv[u]=-Ainv[u]*Ainv[l];}

  }

  for（k=n-1;k>=0;k--）

  { 

      if（js[k]!

=k）

      for（j=0;j<=n-1;j++）

      {