C语言进行潮流计算
电力系统课程设计
C语言潮流计算
学院：电气工程
班级：电092班
学号：0912002020
学生姓名：闵凯
2013.3.7
电力系统的潮流计算是对电力系统分析的最基本步骤也是最重要的步骤，是指在一
定的系统结构和运行条件下，确定系统运行状态的计算，也即是对各母线（节点）电压，各元件（支路）传输电线或功率的计算。通过计算出的节点电压和功率分布用以检查系统各元件是否过负荷，各点电压是否合理，以及功率损耗等。
即使对于一个简单的电力系统，潮流计算也不是一件简单就可以完成的事，其运算量很大，因此如果对于一个大的、复杂的电网来说的话，由于其节点多，分支杂，其计算量可想而知，人工对其计算也更是难上加难了。特别是在现实生活中，遇到一个电力系统不会像我们期望的那样可以知道它的首端电压和首端功率或者是末端电压和末端功率，而是只知道它的首端电压和末端功率，更是使计算变的头疼万分。为了使计算变的简单，我们就可以利用计算机，用C 语言编程来实现牛顿-拉夫逊（Newton-Raphson ）迭代法，最终实现对电力系统潮流的计算。
一．
用牛顿-拉夫逊迭代法进行电力系统潮流计算的相关概念
1.节点导纳矩阵
如图所示的电力网络,将节点i 和j 的电压用?
U i 和?
.U j 表示,它们之间的支路导纳表示为y ij ,那么有基尔霍夫电流定律可知注入接点I 的电流?
.I i (设流入节点的电流为正)等于离开节点I 的电流之和,因此有
)(.
00?
?
≠=≠=?
?
-==∑∑j i n
i
j ij
n
i
j ij i U U I I y (1-1)
∴ ?
≠=≠=?
?∑∑-=U y y U I n
i
j ij n
i
j ij i 00 (1-2)
如令
ii n
i
j ij
Y y
=∑≠=0
ij ij Y y =-则可将(1-2)改写为:
∑≠=?
?
=
n
i
j ij ij
i U Y
I 1 I=1,2,…,n. (1-3)
上式也可以写为: I =YU (1-4)
其中Y 为节点导纳矩阵，也称为稀疏的对称矩阵，它是n×n 阶方阵。对角元Y ii 称为自导纳，它等于与该节点I 直接相连的所有支路导纳总和；非对角元Y ij （i ≠j ）称为互导纳或转移导纳，它等于连结节点I ，j 支路导纳的负数，且有Y ij =Y ji ，当节点I ，j 之间没有支路直接相连时，Y ij =Y ji =0。
电力系统的分析计算中，往往要作不同的运行方式下的潮流计算，如果系统发生变化，如投切一条线路或一台变压器，由于改变了一条支路的状态或参数只影响该支路两端节点的自导纳和他们之间的互导纳，因而对每一种运行方式不必重新形成导纳矩阵，只需对原有导纳矩阵作相应的修改即可。
2．潮流计算的功率方程
在实际的电力系统中，已知的条件往往不是节点的注入电流而是负荷和发电机功率，且这些功率一般不随节点的电压变化而变化，而节点的电流则是随电压的变化而变化的，因此在已知节点导纳矩阵的情况下，必须用已知的节点功率来替代未知的节点注入电流，才能求
I i i δ∠
S ~Li jQ +
Li Gi i P P P -= （1-5）
Li Gi i Q Q Q -= （1-6） Θ ∑=?
?
=
n
j j ij
i U Y
I 1
(1-7)
节点注入电流用功率和电压表示为：
i
i
i i Li Gi Li Gi i i i U jQ P U Q Q j P P U S I ??)()(??-=
---==?
（1-8） ∴
功率方程可以表示为：
∑=?=-n j j ij i i
i U Y U jQ P 1
? （1-9）
3．节点分类
对于有n 个节点的电力网络，可以列出n 个功率方程，由图可知一个节点有四个变量：注入有功功率P i ，注入无功功率Q i ，节点电压幅值U i 和相角i δ。n 个节点有4n 个变量,但只有2n 个关系式,所以为了使潮流有确定解,必须给定其中2n 个变量。根据给定节点变量的不同，可以有以下三种类型的节点：
（1）
PQ 节点：给定注入功率P i ，Q i ，即已知P Gi ，P Li ，Q Gi ，Q Li ，待求U i ，δi 。例如：降压变电所母线（负荷节点），固定出力的发电厂母线。
（2） PV 节点：给定了注入有功功率P i （P Gi ，P Li ），U i 和Q Li ，待求Q Gi （Q i ），δi 。
例如：有一定无功电源的降压变电所母线，有一定储备的发电厂母线。
（3） 平衡节点：给定了U i ，δi 和P Li ，Q Li ，待求P Gi ，Q Gi ，即P i ，Q i ，用来平衡
全电网的功率，通常在一个独立的电力系统中只设一个平衡节点。
4．牛顿-拉夫逊迭代法
牛顿-拉夫逊迭代法将解非线性方程组的过程转化为反复求与之相对应的线性方程的求解过程。
对于一个n 维非线性方程组：i n i y x x x f =),...,,(21 n=1,2,3,…,n
假定其初值为x 1(0),x 2(0),…,x n (0),也即其近似解,它与真值之间的误差为
)
0()0(2)0(1,...,,n
x x x ???也即各变量与真解之间的修正量。
将这n 个方程式都在初值的附近展开成Taylor 级数且忽略二次项及高次项,则可得修正方程
i n i y x x f =???++???+
?)
0(0
n n )0(1011(0)
n (0)2(0)1x f ...x f )x ,,x ,x (, I=1,2,…n. (1-10) 将修正方程写成矩阵形式:
(1-11)
其中令J= ???
????
?
????????????????0n n 01n 0n 10
11x f ...x f .........x f ...x f ,称之为雅可比(Jacobi)方阵。
它的第I 行，第j 列交点的元素为第I 个函数),...,(21n i x x x f 对第j 个变量x j 的偏导数在点（x 1(0),x 2(0),…,x n (0)）的值，所以方程组是线性方程，可用于求出)
0()
0(2)
0(1,...,,n
x x x ???，从
而得到新的近似解，
)
0()
0()
1(i i
i
x x x ?+= （1-12）
于是得到一般迭代式：
??
?
?
?
????????
?????
?
?
??
??????????????=???????????-?-)0()0(10n n 01n 0n 10
11
(0)n (0)2(0)1(0)n (0)2(0)111...x f ...x f .........
x f ...x f )x ,,x ,x (:)x ,,x ,x (n n n x x f y f y
???
?
?????????
???????
??
??????????????=???????????-?-)()(1
n n 1n n 111
(k )n (k )2(k )1(k )n (k )
2(k )
111...x f ...x f .........
x f ...
x f )x ,,x ,x (:)x ,,x ,x (k n k k k
k k
n n x x f y f y （1-13）
于是得到近似解： )
()
()
1(k i
k i
k i
x x x ?+=+ （1-14）
迭代一直进行到Max{|y i -f i (x 1(0),x 2(0),…,x n (0))|}<ε或Max{|Δx i (k)|}<ε为止。
二．
用牛顿-拉夫逊迭代法进行潮流计算
设网络中除参考节点外有n 个节点，其中1个平衡节点（并令第n 个节点为平衡节点），m 个PQ 节点（为第1~m 个节点），有n-m-1个PV 节点。运用牛顿-拉夫逊法直接求解功率方程（1-9），并将Y ij =G ij +jB ij 及.
.
.
i i i f e U +=代入得：
()
i i i i n
j ij ij
i i jQ P jf e jB G
jf e +=--+∑=))((1
将实部和虚部分开得：
∑==++-n
j i j ij j ij i j ij j
ij
i
P e B f G f f B e
G e 1)]()([ (2-1)
∑==+--n
j i j ij j ij i i ij j
ij
i
Q e B f G e f B e
G f 1
)]()([ (2-2)
此外由于系统中还有PV 节点，所以还应补充一组方程： 2
22i i i U f e =+ (2-3)
在式（2-3）中，e i 、f i 分别为迭代过程中求得的节点电压的实部和虚部，P i 为PQ 节点和PV 节点的注入有功功率，Q i 为PQ 节点的注入无功功率，U i 为PV 节点的电压大小。由（2-1），（2-2），（2-3）三式所组成的方程组一共有2（n-1）个独立方程，其中，式（2-1）类型的有(n-1)个,包括除平衡节点以外所有节点的有功功率P i 的表达式;式(3-2)类型的有(m-1)个,包括所有PQ 节点无功功率Q i 的表达式,式(2-3)类型的有(n-m)个,包括所有PV 节点电压U i 2的表达式.平衡节点s 的功率和电压之所以不包括在这方程组内,是由于平衡节点的注入功率不可能事先给定,从而不可能列出P s ,Q s 的表达式,而平衡节点的电压s s s jf e U +=?
则不必求取. 于是建立修正方程式如下:
??
??????
?
?
???
????????????????????????????????
???????????????????=????????????????
???
???
???
???????????n n p p nn nn
np
np
n n n n nn nn np np n n n n pn pn pp pp p p p p pn pn pp pp p p p p n n p p n n p p n n p p n n p p n n p p e f e f e f e f S R S R S R S R N H N H N H N H S R S R S R S R N H N H N H N H L J L J L J L J N H N H N H N H L J L J L J L J
N H N H N H N H U P U P Q P Q P M Λ
ΛΛΛM M M M M M M M M ΛΛΛΛM 22112
2
1
1
2211221122112222222221212222222221211111121211111111121211
11222211 (2-4) 式中的
∑=++--=?n
j j ij j ij i j ij j ij i i i e B f G f f B e G e P P 1
)]()([ (2-5)
∑=+---
=?n
j j ij j ij i i ij j
ij
i
i i e B f G e f B e
G f Q Q 1
)]
()([(2-6)
)(2222i i i i f e U U +-=? (2-7)
当j ≠I 时雅可比方阵的各个元素分别为： i ij i ij j i ij f G e B f P H +-=??=
； i ij i ij j i ij f B e G e P
N +=??=； ij j i ij N f Q J -=??=
； ij i
i
ij H e Q L =??=； ;021=??=j ij f U R 02
1=??=j
ij e U S
当j=I 时雅可比方阵的各个元素分别为： ii i ii i ii i i ii b f G e B f P H ++-=??=
; ii ii i ii i
i ii a f B e G e P
N ++=??=; ii ii i ii j i ii a f B e G e Q N +--=??=
; ii i ii i ii i
i ii b f G e B f P
H -+-=??=; i i i ii f f U R 22=??=; i i
i ii e e U S 22
=??=
其中：)()(1
∑≠=++
-=n
i
j i ij i ij
i ii i ii ii f B f G
f B e G a
∑≠=++-=n
i
j j ij j ij
j ii j ii ii e B f G
f B e G b 1)()(
三．用C 语言编程计算潮流的流程图
四．
用编程方法求解实际问题
如图所示的一个电力网络，
1
2
已知：006.11j U +=?
为定值，其余四个节点都是PQ 节点，且给定的注入功率分别为：
10.060.0~
,05.040.0~,15.045.0~,20.020.0~5432j S j S j S j S --=--=--=+= 由上图可得相应的节点导纳矩阵
Y=[6.25-18.75i -5+15i -1.25+3.75i 0 0; -5+15i 10.834-32.5i -1.667+5i -1.667+5i -2.5+7.5i; -1.25+3.75i -1.667+5i 12.917-38.75i -10+30i 0;
0 -1.667+5i -10+30i 12.917-38.75i -1.25+3.75i;
0 -2.5+7.5i 0 -1.25+3.75i 3.75-11.25i ]
五．程序清单
#include
float divRe(b1,b2,b3,b4) float b1,b2,b3,b4; {
float a1r;
a1r=(b1*b3+b2*b4)/(b3*b3+b4*b4); return(a1r); }
float divIm(b1,b2,b3,b4) float b1,b2,b3,b4; {
float a1i;
a1i=(b2*b3-b1*b4)/(b3*b3+b4*b4);
return(a1i);
}
float mulRe(b1,b2,b3,b4)
float b1,b2,b3,b4;
{
float a2r;
a2r=b1*b3-b2*b4;
return(a2r);
}
float mulIm(b1,b2,b3,b4)
float b1,b2,b3,b4;
{
float a2i;
a2i=b2*b3+b1*b4;
return(a2i);
}
float Max(float a[],int n)
{int i;
float max;
for(i=0;i if(a[i]>a[i+1]) {max=a[i];a[i]=a[i+1];a[i+1]=max;} return(max); } main() { int i,j,k,n,km; float eps,sumpi1,sumpi2,sumqi1,sumqi2,max,sumir,sumii,I1r,I1i; float pi0[5],qi0[5],detpi[5],detqi[5],Iir0[5],Iii0[5],J0[8][8],detsi[8],detui[8], u[8][8],l[8][8],y[8],ui1[8],H[4][4],N[4][4],J[4][4],L[4][4],ei1[5],fi1[5]; static float ybr[5][5]={{6.250,-5.000,-1.250,0,0},{-5.000,10.834,-1.667,-1.667,-2.500}, {-1.250,-1.667,12.917,-10.000,0},{0,-1.667,-10.000,12.917,-1.250}, {0,-2.500,0,-1.250,3.750}}; static float ybi[5][5]={{-18.750,15.000,3.750,0,0},{15.000,-32.500,5.000,5.000,7.500}, {3.750,5.000,-38.750,30.000,0},{0,5.000,30.000,-38.750,3.750}, {0,7.500,0,3.750,-11.250}}; float ei0[5]={1.06,1.0,1.0,1.0,1.0}; float fi0[5]={0,0,0,0,0}; float pi[5]={0,0.2,-0.45,-0.4,-0.6}; float qi[5]={0,0.2,-0.15,-0.05,-0.1}; k=0; km=6; eps=0.00001; do{ k+=1; printf("Now start...\n"); printf("The %d times\n",k); for(i=1;i<5;i++) printf("pi[%d]=%-14.6f",i,pi[i]); sumpi2=0; sumqi2=0; for(i=1;i<5;i++) {for(j=0;j<5;j++) { sumpi1=(ei0[i]*(ybr[i][j]*ei0[j]-ybi[i][j]*fi0[j])+fi0[i]*(ybr[i][j]*fi0[j]+ybi[i][j]*ei0[j])); sumpi2+=sumpi1; } pi0[i]=sumpi2; printf("pi0[%d]=%-13.6f",i,pi0[i]); sumpi2=0; } for(i=1;i<5;i++) {for(j=0;j<5;j++) { sumqi1=(fi0[i]*(ybr[i][j]*ei0[j]-ybi[i][j]*fi0[j])-ei0[i]*(ybr[i][j]*fi0[j]+ybi[i][j]*ei0[j])); sumqi2+=sumqi1; } qi0[i]=sumqi2; printf("qi0[%d]=%-13.6f",i,qi0[i]); sumqi2=0; } for(i=1;i<5;i++) { detpi[i]=pi[i]-pi0[i]; detqi[i]=qi[i]-qi0[i]; printf("detpi[%d]=%-21.6f",i,detpi[i]); printf("detqi[%d]=%-21.6f\n",i,detqi[i]); } for(i=1;i<5;i++) {Iir0[i]=divRe(pi0[i],-qi0[i],ei0[i],-fi0[i]); Iii0[i]=divIm(pi0[i],-qi0[i],ei0[i],-fi0[i]); printf("Iir0[%d]=%-22.6f",i,Iir0[i]); printf("Iii0[%d]=%-22.6f\n",i,Iii0[i]); } for(i=0;i<4;i++) {for(j=0;j<4;j++) if(i==j) { H[i][j]=-ybi[i+1][j+1]*ei0[i+1]+ybr[i+1][j+1]*fi0[i+1]+Iii0[i+1]; N[i][j]=ybr[i+1][j+1]*ei0[i+1]+ybi[i+1][j+1]*fi0[i+1]+Iir0[i+1]; J[i][j]=-ybr[i+1][j+1]*ei0[i+1]-ybi[i+1][i+1]*fi0[i+1]+Iir0[i+1]; L[i][j]=-ybi[i+1][j+1]*ei0[i+1]+ybr[i+1][j+1]*fi0[i+1]-Iii0[i+1]; } else { H[i][j]=ybr[i+1][j+1]*fi0[i+1]-ybi[i+1][j+1]*ei0[i+1]; N[i][j]=ybr[i+1][j+1]*ei0[i+1]+ybi[i+1][j+1]*fi0[i+1]; J[i][j]=-ybi[i+1][j+1]*fi0[i+1]-ybr[i+1][j+1]*ei0[i+1]; L[i][j]=ybr[i+1][j+1]*fi0[i+1]-ybi[i+1][j+1]*ei0[i+1]; } } for(i=0;i<8;i++) for(j=0;j<8;j++){ if(i%2==0&&j%2==0) J0[i][j]=H[i/2][j/2]; else if(i%2==0&&j%2!=0) J0[i][j]=N[i/2][(j-1)/2]; else if(i%2!=0&&j%2==0) J0[i][j]=J[(i-1)/2][j/2]; else J0[i][j]=L[i/2][(j-1)/2]; } printf("输出雅可比矩阵：\n"); for(i=0;i<8;i++) for(j=0;j<8;j++) printf("%-10.4f",J0[i][j]); for(i=0;i<8;i++) {if(i%2==0) detsi[i]=detpi[(i+2)/2]; else detsi[i]=detqi[(i+1)/2]; printf("detsi[%d]=%-11.6f",i,detsi[i]); } for(i=0;i<8;i++) u[i][i]=1.000; for(n=0;n<8;n++) {for(i=n;i<8;i++) {l[i][n]=J0[i][n]; for(j=0;j<=n-1;j++) l[i][n]-=(l[i][j]*u[j][n]); } for(j=n+1;j<8;j++) {u[n][j]=J0[n][j]; for(i=0;i<=n-1;i++) u[n][j]-=(l[n][i]*u[i][j]); u[n][j]/=l[n][n]; } } for(i=0;i<8;i++) {y[i]=detsi[i]; for(j=0;j<=i-1;j++) y[i]-=(l[i][j]*y[j]); y[i]/=l[i][i]; } for(i=7;i>=0;i--) {detui[i]=y[i]; for(j=i+1;j detui[i]-=(u[i][j]*detui[j]); } for(i=0;i<8;i++) printf("detui[%d]=%-11.6f",i,detui[i]); for(i=0;i<8;i++) { {if(i%2==0) ui1[i]=detui[i]+fi0[i/2+1]; else ui1[i]=detui[i]+ei0[(i+1)/2]; } printf("ui1[%d]=%-13.6f",i,ui1[i]); } for(i=1;i<5;i++) {ei1[i]=ui1[2*i-1]; fi1[i]=ui1[2*i-2]; } for(i=1;i<5;i++) {printf("ei1[%d]=%-13.6f",i,ei1[i]); printf("fi1[%d]=%-13.6f",i,fi1[i]); } max=Max(detui,8); printf("max=%f\n",max); for(i=1;i<5;i++) {ei0[i]=ei1[i]; fi0[i]=fi1[i]; } for(i=1;i<5;i++) {pi[i]=detpi[i]+pi0[i]; qi[i]=detqi[i]+qi0[i]; } }while(max>eps&&k printf("All do %d times\n",k); sumir=0; sumii=0; for(i=0;i<5;i++) { I1r=mulRe(ybr[0][i],-ybi[0][i],ei0[i],-fi0[i]); I1i=mulIm(ybr[0][i],-ybi[0][i],ei0[i],-fi0[i]); sumir+=I1r; sumii+=I1i; } pi[0]=mulRe(ei0[0],fi0[0],sumir,sumii); qi[0]=mulIm(ei0[0],fi0[0],sumir,sumii); printf("S1=%f+j%f\n",pi[0],qi[0]); ei1[0]=ei0[0]; fi1[0]=fi0[0]; for(i=0;i<5;i++) printf("u%d=%f<%f\n",i+1,sqrt(ei1[i]*ei1[i]+fi1[i]*fi1[i]),atan(fi1[i]/ei1[i])*180/3.14159); } 六．运行结果： Now start... The 1 times pi[1]=0.200000 pi[2]=-0.450000 pi[3]=-0.400000 pi[4]=-0.600000 pi0[1]=-0.300000 pi0[2]=-0.075001 pi0[3]=0.000000 pi0[4]=0.000000 qi0[1]=-0.900000 qi0[2]=-0.225000 qi0[3]=0.000000 qi0[4]=0.000000 detpi[1]=0.500000 detqi[1]=1.100000 detpi[2]=-0.374999 detqi[2]=0.075000 detpi[3]=-0.400000 detqi[3]=-0.050000 detpi[4]=-0.600000 detqi[4]=-0.100000 Iir0[1]=-0.300000 Iii0[1]=0.900000 Iir0[2]=-0.075001 Iii0[2]=0.225000 Iir0[3]=0.000000 Iii0[3]=0.000000 Iir0[4]=0.000000 Iii0[4]=0.000000 输出雅可比矩阵： 33.4000 10.5340 -5.0000 -1.6670 -5.0000 -1.6670 -7.5000 -2.5000 -11.1340 31.6000 1.6670 -5.0000 1.6670 -5.0000 2.5000 -7.5000 -5.0000 -1.6670 38.9750 12.8420 -30.0000 -10.0000 0.0000 0.0000 1.6670 -5.0000 -1 2.9920 38.5250 10.0000 -30.0000 0.0000 0.0000 -5.0000 -1.6670 -30.0000 -10.0000 38.7500 12.9170 -3.7500 -1.2500 1.6670 -5.0000 10.0000 -30.0000 -1 2.9170 38.7500 1.2500 - 3.7500 -7.5000 -2.5000 0.0000 0.0000 -3.7500 -1.2500 11.2500 3.7500 2.5000 -7.5000 0.0000 0.0000 1.2500 - 3.7500 -3.7500 11.2500 detsi[0]=0.500000 detsi[1]=1.100000 detsi[2]=-0.374999 detsi[3]=0.075000 detsi[4]=-0.400000 detsi[5]=-0.050000 detsi[6]=-0.600000 detsi[7]=-0.100000 detui[0]=-0.047295 detui[1]=0.042961 detui[2]=-0.086292 detui[3]=0.015391 detui[4]=-0.092225 detui[5]=0.014105 detui[6]=-0.107605 detui[7]=0.009342 ui1[0]=-0.047295 ui1[1]=1.042961 ui1[2]=-0.086292 ui1[3]=1.015391 ui1[4]=-0.092225 ui1[5]=1.014105 ui1[6]=-0.107605 ui1[7]=1.009342 ei1[1]=1.042961 fi1[1]=-0.047295 ei1[2]=1.015391 fi1[2]=-0.086292 ei1[3]=1.014105 fi1[3]=-0.092225 ei1[4]=1.009342 fi1[4]=-0.107605 max=0.042961 Now start... The 2 times pi[1]=0.200000 pi[2]=-0.450000 pi[3]=-0.400000 pi[4]=-0.600000 pi0[1]=0.277045 pi0[2]=-0.449244 pi0[3]=-0.410254 pi0[4]=-0.616366 qi0[1]=0.222040 qi0[2]=-0.118305 qi0[3]=-0.013816 qi0[4]=-0.036371 detpi[1]=-0.077045 detqi[1]=-0.022040 detpi[2]=-0.000756 detqi[2]=-0.031695 detpi[3]=0.010254 detqi[3]=-0.036184 detpi[4]=0.016366 detqi[4]=-0.063629 Iir0[1]=0.255454 Iii0[1]=-0.224478 Iir0[2]=-0.429431 Iii0[2]=0.153007 Iir0[3]=-0.400000 Iii0[3]=0.050001 Iir0[4]=-0.600000 Iii0[4]=0.100000 输出雅可比矩阵： 33.1594 13.0920 -5.1360 -1.9751 -5.1360 -1.9751 -7.7040 -2.9621 -12.5811 33.6083 1.9751 -5.1360 1.9751 -5.1360 2.9621 -7.7040 -4.9331 -2.1241 38.3848 16.0302 -29.5988 -12.7427 0.0000 0.0000 2.1241 -4.9331 -16.8890 38.0788 12.7427 -29.5988 0.0000 0.0000 -4.9168 -2.1516 -29.5009 -12.9078 38.1553 16.2729 -3.6876 -1.6135 2.1516 -4.9168 12.9078 -29.5009 -17.0729 38.0553 1.6135 -3.6876 -7.3011 -3.3304 0.0000 0.0000 -3.6505 -1.6652 11.0516 4.3956 3.3304 -7.3011 0.0000 0.0000 1.6652 -3.6505 -5.5956 10.8516 detsi[0]=-0.077045 detsi[1]=-0.022040 detsi[2]=-0.000756 detsi[3]=-0.031695 detsi[4]=0.010254 detsi[5]=-0.036184 detsi[6]=0.016366 detsi[7]=-0.063629 detui[0]=-0.000435 detui[1]=-0.007504 detui[2]=0.001742 detui[3]=-0.010067 detui[4]=0.002076 detui[5]=-0.010761 detui[6]=0.003195 detui[7]=-0.013070 ui1[0]=-0.047730 ui1[1]=1.035457 ui1[2]=-0.084550 ui1[3]=1.005324 ui1[4]=-0.090149 ui1[5]=1.003344 ui1[6]=-0.104410 ui1[7]=0.996272 ei1[1]=1.035457 fi1[1]=-0.047730 ei1[2]=1.005324 fi1[2]=-0.084550 ei1[3]=1.003344 fi1[3]=-0.090149 ei1[4]=0.996272 fi1[4]=-0.104410 max=0.003195 Now start... The 3 times pi[1]=0.200000 pi[2]=-0.450000 pi[3]=-0.400000 pi[4]=-0.600000 pi0[1]=0.200525 pi0[2]=-0.449917 pi0[3]=-0.400025 pi0[4]=-0.599997 qi0[1]=0.200204 qi0[2]=-0.149683 qi0[3]=-0.049610 qi0[4]=-0.099159 detpi[1]=-0.000525 detqi[1]=-0.000204 detpi[2]=-0.000083 detqi[2]=-0.000317 detpi[3]=0.000025 detqi[3]=-0.000390 detpi[4]=-0.000003 detqi[4]=-0.000841 Iir0[1]=0.184354 Iii0[1]=-0.201847 Iir0[2]=-0.431957 Iii0[2]=0.185219 Iir0[3]=-0.391092 Iii0[3]=0.084584 Iir0[4]=-0.585382 Iii0[4]=0.160879 输出雅可比矩阵： 32.9334 12.9537 -5.0977 -1.9648 -5.0977 -1.9648 -7.6466 -2.9466 -12.5850 33.3371 1.9648 -5.0977 1.9648 -5.0977 2.9466 -7.6466 -4.8857 -2.0986 38.0494 15.8301 -29.3142 -12.5897 0.0000 0.0000 2.0986 -4.8857 -16.6940 37.6790 12.5897 -29.3142 0.0000 0.0000 -4.8664 -2.1233 -29.1988 -12.7379 37.7997 16.0624 -3.6499 -1.5922 2.1233 -4.8664 12.7379 -29.1988 -16.8446 37.6305 1.5922 -3.6499 -7.2110 -3.2738 0.0000 0.0000 -3.6055 -1.6369 10.9774 4.3253 3.2738 -7.2110 0.0000 0.0000 1.6369 -3.6055 -5.4960 10.6556 detsi[0]=-0.000525 detsi[1]=-0.000204 detsi[2]=-0.000083 detsi[3]=-0.000317 detsi[4]=0.000025 detsi[5]=-0.000390 detsi[6]=-0.000003 detsi[7]=-0.000841 detui[0]=-0.000003 detui[1]=-0.000089 detui[2]=0.000010 detui[3]=-0.000123 detui[4]=0.000013 detui[5]=-0.000133 detui[6]=0.000024 detui[7]=-0.000173 ui1[0]=-0.047733 ui1[1]=1.035368 ui1[2]=-0.084540 ui1[3]=1.005201 ui1[4]=-0.090137 ui1[5]=1.003211 ui1[6]=-0.104386 ui1[7]=0.996099 ei1[1]=1.035368 fi1[1]=-0.047733 ei1[2]=1.005201 fi1[2]=-0.084540 ei1[3]=1.003211 fi1[3]=-0.090137 ei1[4]=0.996099 fi1[4]=-0.104386 max=0.000024 Now start... The 4 times pi[1]=0.200000 pi[2]=-0.450000 pi[3]=-0.400000 pi[4]=-0.600000 pi0[1]=0.199999 pi0[2]=-0.450001 pi0[3]=-0.400000 pi0[4]=-0.600000 qi0[1]=0.199996 qi0[2]=-0.149998 qi0[3]=-0.049999 qi0[4]=-0.099998 detpi[1]=0.000001 detqi[1]=0.000005 detpi[2]=0.000001 detqi[2]=-0.000002 detpi[3]=0.000000 detqi[3]=-0.000001 detpi[4]=-0.000000 detqi[4]=-0.000002 Iir0[1]=0.183871 Iii0[1]=-0.201641 Iir0[2]=-0.432066 Iii0[2]=0.185560 Iir0[3]=-0.391085 Iii0[3]=0.084977 Iir0[4]=-0.585400 Iii0[4]=0.161737 输出雅可比矩阵： 32.9307 12.9524 -5.0973 -1.9646 -5.0973 -1.9646 -7.6459 -2.9464 -12.5846 33.3340 1.9646 -5.0973 1.9646 -5.0973 2.9464 -7.6459 -4.8851 -2.0984 38.0451 15.8281 -29.3106 -12.5882 0.0000 0.0000 2.0984 -4.8851 -16.6922 37.6740 12.5882 -29.3106 0.0000 0.0000 -4.8658 -2.1230 -29.1950 -12.7362 37.7951 16.0602 -3.6494 -1.5920 2.1230 -4.8658 12.7362 -29.1950 -16.8424 37.6252 1.5920 -3.6494 -7.2098 -3.2731 0.0000 0.0000 -3.6049 -1.6366 10.9764 4.3243 3.2731 -7.2098 0.0000 0.0000 1.6366 -3.6049 -5.4951 10.6529 detsi[0]=0.000001 detsi[1]=0.000005 detsi[2]=0.000001 detsi[3]=-0.000002 detsi[4]=0.000000 detsi[5]=-0.000001 detsi[6]=-0.000000 detsi[7]=-0.000002 detui[0]=0.000000 detui[1]=0.000000 detui[2]=0.000000 detui[3]=-0.000000 detui[4]=0.000000 detui[5]=-0.000000 detui[6]=0.000000 detui[7]=-0.000000 ui1[0]=-0.047733 ui1[1]=1.035368 ui1[2]=-0.084540 ui1[3]=1.005201 ui1[4]=-0.090136 ui1[5]=1.003211 ui1[6]=-0.104386 ui1[7]=0.996099 ei1[1]=1.035368 fi1[1]=-0.047733 ei1[2]=1.005201 fi1[2]=-0.084540 ei1[3]=1.003211 fi1[3]=-0.090136 ei1[4]=0.996099 fi1[4]=-0.104386 max=0.000000 All do 4 times 24447.029816.111~ 1j i jS r S S +=+= ο006.11∠=? U ο63960.203647.12-∠=? U ?-∠=? 80742.400875.13U ?-∠=?13412.500725.14U ?-∠=98247.500155.15U 七．总结及感想 此次课程设计首先让我明白了要使电力系统运行的稳定，必须经过精密的设计和计算。在进行课题设计的过程中，加深了我对潮流计算的认识，尤其是对牛顿拉夫逊潮流计算的求解思路有了比较透彻的理解。同时由于求解过程中用到求节点导钠矩阵，求矩阵的逆等等，又使我对以前所学的知识有了一次很好的温习。同时也看到了研究性学习的效果，从研究中去学习，理论结合实际，将理论运用到实际，同时在实践中发现问题，然后解决问题，而且在此次课程设计中，我发现了自己的基础知识有很多的不足。这些基础的缺乏给我的设计计划造成了不小的障碍。 在这个过程中，我明白了，只要用心去做，认真去做，持之以恒，就会有新的发现，有意外的收获。过本次通课程设计，自己加深了《电力系统基础》和《电力系统分析》课程中所学的理论知识，基本掌握变电所电气部分设计的一般方法，也提高了电气设计的设计能力。在本次课程设计中，由于是第一次独立完成，感觉时间紧迫且困难重重。其中最难完成的是高低压进出线的选择和电路图的连接，不过通过本次联系我对自己更有信心，也期待以后更加困难的课业挑战。 利用这种方法进行潮流的计算，其收敛的速度是显而易见的，如上面这到题，在经过三次迭代以后已经达到我们要求的水平，但必须建立在有一个比较优的初值的基础上。 此次课程设计的完成，要感谢老师的帮助以及同学的协力合作，团结才能出成绩。 课程设计说明书 题目计算器程序设计 起讫日期 2006 年 7月 3日至 2006 年 8月 6日 所在院系软件学院 专业机械+软件班级 04-2 学生姓名偶偶哦学号 指导教师 2006年 8 月日 摘要 当今社会是信息社会，科技经济高速发展的社会！为了更方便人们的工作生活和加速人们处理信息的速度，计算器应运而生。由于它体积小巧，携带方便，价格便宜，构造简单等诸多的优点成为人们生活中的必备品！ 随着科技的发展计算器的种类变得更多，功能变得更强大，体积变得更小！电脑的出现改变人们的生活习惯，很多事情都可以电脑来完成！电脑的更大一个优点就是可以通过软件的应用无限的延伸电脑功能的外延！下面我们将用我们学习的c语言编写一个简易的计算器程序！实现简单的初步的计算功能！ 本程序的编写基础是Tubro 汉化版,它在tubro c的原有基础上实现了多汉字的支持方便了我们的使用。生成的程序可移植性强兼容性好稳定！现在只实现了加、减、乘、除、求幂、求模，求平方根，求Sin，求Cos，求Log10，以及一个时钟原代码。这个系统是基于软件发展的生命周期来研制的，它可以直接输入数学表达式，不需要任何转换，就可以直接输出数学四则运算的结果。但是，每次只能运算一个表达式。不能运算多个表达式。在程序里面在添加一组选择函数即可。本论文主要介绍了本课题的开发背景，开发的过程和所要完成的功能。重点的说明了系统设计思想，设计的步骤、难点技术和解决方案。 关键词：C语言 Tubro c 汉化版计算器时钟 目录 第一章综述 (1) 1．1 课题的现实意义 (1) 1．2 软件环境 (1) 1．3 硬件环境 (1) 第二章系统设计流程图 (2) 2．1 系统流程图 (2) 2．2 主要功能表 (2) 第三章系统分析和设计 (3) 3．1 图形的绘制和输出 (3) 3．2 文本的输出显示 (3) 3．3 计算函数的调用 (4) 3．4 程序的运行和退出 (5) 第四章系统测试 (6) 4．1 系统测试 (6) 4．2 调试 (6) 4．3 错误原因分析一 (6) 4．4 错误原因分析二 (6) 第五章用户使用说明书 (8) 目录 一.课程设计目的 (1) 二.设计环境 (1) 三.设计内容 (1) 四.设计说明 (2) 五.设计程序流程图 (2) 六.调试 (4) (1)错误原因分析一 (4) (2)语法错误 (5) (3)逻辑错误 (5) 七. 调试结果图 (6) 八. 结论与心得体会 (7) 九.附录 (8) 具体代码实现 (8) 十．参考文献 (18) 一.课程设计目的 1.通过一个学期的学习，我认为要学号C语言程序这门课程，不仅要认真阅读课本知识，更重要的是要通过上机实践来巩固我 们的知识，特别是学计算机专业的，我们更应该注重这一环节， 只有这样我们才能成为一个合格的计算机人才。通过这一个课程 设计，进一步来巩固所学的语句，如：循环，和分支结构的运用。还要熟悉四则运算和函数的算法。 2.通过这次课程设计扩展自己的知识面，课本上的东西是远 远不够的，可以通过上网或去图书馆查资料等方式得到一些新的 知识， 3.通过课程设计，加深对课程化设计思想的理解，能进行一 个系统功能分析，并设计一个合理的模块化结构，提高程序开发 能力。 二.设计环境 1.硬件：一台完整的电脑，包括键盘、鼠标，最小硬盘空间1GHz 2.软件：安装有Microsoft visual c++6.0 三.设计内容 以简易计算器为例，通过对简单应用软件计算器的设计，编制、调试，实现 简单的加，减，乘，除等运算，以学习应用MFC库类编写对话框的原理，加深对C++类的学习及应用。 （1）定义一个结构体类型数组，输入0~9及+、--、*等符号的信息，将其信息存入文件中； （2）输入简单的加减乘除算术计算式，并在屏幕上显示计算结果； （3）画出部分模块的流程图； （4）编写代码； （5）程序分析与调试。 四.设计说明 1)包含的功能有：加、减、乘、除运算，开方、平方等功能。 (2)计算器上数字0—9为一个控件数组，加、减、乘、除为一个控件数组，其余为单一的控件。 (3)输入的原始数据、运算中间数据和结果都显示在窗口顶部的同一个标签中。 (4)计算功能基本上是用系统内部函数。 (5)程序可以能自动判断输入数据的正确性，保证不出现多于一个小数点、以0开头等不正常现象。 (6)“CE”按钮可以清除所有已输入的数据从头计算 五.设计程序流程图 课程设计名称：C语言课程设计课程设计题目：简单计算器程序 目录 第1章需求分析 (1) 1.1设计要求 (1) 1.2任务 (1) 第2章总体设计 (2) 2.1设计简介及设计方案论述 (2) 2.2功能模块层次图 (2) 第3章详细设计 (3) 3.3由（后缀）逆波兰表达式计算中缀表达式原理 (8) 3.3.1算法描述 (8) 第4章调试分析 (10) 4.1程序设计中所遇到的错误及犯错的原因 (10) 4.2错误的解决方法 (10) 第5章用户手册 (11) 总结 (15) 参考文献 (16) 附录（程序清单） (17) 第1章需求分析 1.1 设计要求 （1）用 C 语言数据结构实现程序设计； （2）利用结构体、栈、进行相关信息处理； （2）系统的各个功能模块要求用函数的形式实现； （4）界面简单，可操作性高。 1.2任务 （1）定义一个结构体类型数组，输入0~9 及+、--、*等符号的信息，将其信息存储起来； （2）输入简单的加减乘除算术计算式，并在屏幕上显示逆波兰（后缀式）表达式和计算结果； （3）编写代码； （4）程序分析与调试。 说明： 本课程设计将实现一个简单计算器。在功能上尽量模仿windows 的计算器。系统界面不做牵制要求。该程序能实现标准型中+、-、*、/、（、）、.、的混合运算表达式（一般意义上的中缀表达式），将其转换成逆序波兰表达式（后缀表达式）并计算输出结果。在进行运算后可以选择继续运算或者结束当前运算。即时准确地获得需要的计算的结果，充分降低了数字计算的难度和节约了时间，对人们的生活有一定的帮助。 第2章 总体设计 2.1设计简介及设计方案论述 逆波兰表达式又叫做后缀表达式。在通常的表达式中，二元运算符总是置于与之相 关的两个运算对象之间，所以，这种表示法也称为中缀表达式。波兰逻辑学家 J.Lukasiewicz 于 1929 年提出了另一种表示表达式的方法。按此方法，每一运算符都置 于其运算对象之后，故称为后缀表达式。 后缀表达式的优点是显而易见的， 编译器在处理时候按照从左至右的顺序读取逆波 兰表达式，遇到运算对象直接压入堆栈，遇到运算符就从堆栈提取后进的两个对象进行计算，这个过程正好符合了计算机计算的原理。后缀表达式比前缀表达式更加易于转换，并且它的最左面一定为数字，这一点在实 际编程的时候就会体会到它的好处了。 逆波兰表达式有一个更大的优点，就是拆括号，根据运算符的级别将中缀表达式转 换成逆波兰表达式后，运算顺序就已经替代了运算符的级别，这样也避免了括号提高运 算级别的特殊处理。 2.2功能模块层次图 将算术表达式转化为逆波兰表达式 计算逆波兰表达式的值 简单计算器 表 达 式 格 式 转 换 系统 求 值 计 算 系 统 实验一多功能计算器 一、问题描述 设计一个多功能计算器,可以完成基本的计算。 设计要求: 1、具备整型数据、浮点型数据的算术(加、减、乘、除)运算功能。依次输入第一个运算数、运算符(+,-,*,/)、第二个运算数,然后输出结果。结果可以作为下一个运算的第一运算数。按‘C’清屏,按‘R’返回菜单。 例如:输入:2 + 5 输出:7 2、实现单运算符表达式计算的功能。输入的操作数可以包含整数或浮点数。输入表达式如下: 例如:输入:2+5 输出:7 二、算法说明 1.数据结构说明(可以图示说明,也可以文字说明) 本程序主要根据选择菜单编写了六个自定义函数,用于在main()函数中调用,在main()中,用一个字符变量num1来记录下菜单选项的标号,根据num1的值来决定调用哪个函数。 程序要完成的功能及所要用到的函数如下: 下面就是整个程序的流程图: 2.算法说明(即函数说明) void suanshuyunsuan() //做算术运算时调用的函数 void suanshuyunsuan2() //选择继续做算术运算调用的函数,将上次运算的结果做为下次算术运算的第一个操作数//判断算术运算就是否继续 void panduan() //判断算术运算就是否继续 void biaodashiyunsuan() //单运算符表达式实现函数 void qingping() //清除屏幕 void fanhuicaidan() //显示菜单 三、测试结果(这部分需文字与图示结合) 1.第一组测试用例 (1)测试输入: 测试目的:测试算术运算的功能 结果输出: (2)再一次输入:1测试目的:测试算术运算就是否能继续 结果输出: (3)这时输入:0 测试目的:退出算术运算 结果输出: C++语言编写。。 #include char *base; }stack_char; stack_num S_num;//定义 stack_char S_char;//定义 char fu[18] = {'\n', ')', '+', '-', '*', '/', '%', '^', 'Q', 'L', 'C', 'S', 'T', 'c', 's', 't', '('}; int compare[1000];//表现出各运算符号的优先级 double shu[1000];//存储"数"的数组 double dai_result;//运算的结果，是为了处理M运算(简介函数里有M的定义) int biao = 0;//和dia_result一样，为了处理M运算 char line[SIZE];//输入的所要计算的表达式 void init()//初始化 { compare[fu[0]] = -2;//用数字的大小表现出符号的优先级 compare[fu[1]] = -1; compare[fu[2]] = 2; compare[fu[3]] = 2; compare[fu[4]] = 4; compare[fu[5]] = 4; compare[fu[6]] = 4; AT89C51单片机简易计算器的设计 一、总体设计 根据功能和指标要求，本系统选用MCS-51系列单片机为主控机。通过扩展必要的外围接口电路，实现对计算器的设计。具体设计如下：（1）由于要设计的是简单的计算器，可以进行四则运算，为了得到较好的显示效果，采用LCD 显示数据和结果。 （2）另外键盘包括数字键（0～9）、符号键（+、-、×、÷）、清除键和等号键，故只需要16 个按键即可，设计中采用集成的计算键盘。 （3）执行过程：开机显示零，等待键入数值，当键入数字，通过LCD显示出来，当键入+、-、*、/运算符，计算器在内部执行数值转换和存储，并等待再次键入数值，当再键入数值后将显示键入的数值，按等号就会在LCD上输出运算结果。 （4）错误提示：当计算器执行过程中有错误时，会在LCD上显示相应的提示,如：当输入的数值或计算得到的结果大于计算器的表示范围时，计算器会在LCD上提示溢出；当除数为0时，计算器会在LCD 上提示错误。 系统模块图： 二、硬件设计 （一）、总体硬件设计 本设计选用AT89C51单片机为主控单元。显示部分：采用LCD 静态显示。按键部分：采用4*4键盘；利用MM74C922为4*4的键盘扫描IC，读取输入的键值。 总体设计效果如下图： （二）、键盘接口电路 计算器输入数字和其他功能按键要用到很多按键，如果采用独立按键的方式，在这种情况下，编程会很简单，但是会占用大量的I/O 口资源，因此在很多情况下都不采用这种方式，而是采用矩阵键盘的方案。矩阵键盘采用四条I/O 线作为行线，四条I/O 线作为列线组成键盘，在行线和列线的每个交叉点上设置一个按键。这样键盘上按键的个数就为4×4个。这种行列式键盘结构能有效地提高单片机系统中I/O 口的利用率。 矩阵键盘的工作原理： 计算器的键盘布局如图2所示：一般有16个键组成，在单片机中正好可以用一个P口实现16个按键功能，这种形式在单片机系统中也最常用。 图 2 矩阵键盘布局图 矩阵键盘内部电路图如图3所示： C语言制作简单计算器 一、项目介绍 我们要用c语言做一个简单的计算器，进行加、减、乘、除操作。本程序涉及的所有数学知识都很简单，但输入过程会增加复杂性。我们需要检查输入，确保用户没有要求计算机完成不可能的任务。还必须允许用户一次输入一个计算式，例如：32.4+32 或者9*3.2 项目效果图 编写这个程序的步骤如下： ?获得用户要求计算机执行计算所需的输入。 ?检查输入，确保输入可以理解。 ?执行计算。 ?显示结果。 三、解决方案 1.步骤1 获得用户输入是很简单的，可以使用printf()和scanf()。下面是读取用户输入的程序代码： #include 数码管显示计算器C语言程序如下： #include C语言课程设计报告题目：设计一个简单计算器 目录 1. 设计目的 2. 内容 3. 总体设计（有流程图） 4. 源程序编写（附上了运行图） 5. 执行结果 6. 心得体会 一、设计目的 设计一个简单计算器，在功能上功能尽量模拟windows 操作系统中的计算器，系统界面不做强制要求。 全面熟悉、掌握C语言基本知识，掌握C程序设计中的顺序、分支、循环三种结构及数组、函数、指针和文件的操作，把编程和实际结合起来，增强对不同的问题运用和灵活选择合适的数据结构以及算法描述的本领，熟悉编制和调试程序的技巧，掌握分析结果的若干有效方法，进一步提高上机动手能力，培养使用计算机解决实际问题的能力，规范编程思想，为以后在专业 课程中应用计算机系统解决计算、分析、实验和设计等学习环节打下较扎实的基础。 二、内容 1、程序设计的一般步骤 a、确定数据结构 b、确定算法 C、编程 d、调试 e、总结资料 2、基本要求 a .设计正确，方案合理，能实现相应功能。 b .界面友好，使用方便。 c .程序精炼，结构清晰。 d .设计报告含程序设计说明，用户使用说明，源程序清单及程序框图。 e .上机演示。 三、总体设计（程序设计组成框图、流程图） 四、源程序编与 #in clude 扬州大 学 题目一个简易计算器的设计与实现 班级 学号 姓名 指导教师 成绩 老师评语： 扬州大学信息工程学院 2010 年6 月25 目录 一、程序设计目的： (1) 二、程序设计内容： (1) 三、课程设计所补充的内容：补充的函数或算法…………3，4 四、系统总体设计 (4) 五、系统详细设计………………………………………5，6，7，8 六、运行结果………………………………………………8，9，10 七、系统调试…………………………………………8，9，10，11 八、课程设计体会总结………………………………8，9，10，11 1 课程设计目的 （1）.课程设计是一项综合性实践环节，是对平时实验的一个补充，课程设计内容包括课程的主要理论知识，但由于C语言对初学者较难掌握，因而对一个完整的C语言程序不适合平时实验。通过课程设计可以达到综合设计C语言程序的目的。 （2）通过本课程设计，可以培养独立思考，综合运用所学有关相应知识的能力，能更好地使用C语言的知识，更好地了解C语言的好处和其可用性！掌握基本的程序设计过程和技巧，掌握基本的分析问题和利用计算机求解问题的能力，具备初步的高级程序设计能力。为后续各门计算机课程的学习和毕业设计打下坚实基础！ （3）通过本程序训练程序设计的基本技能，掌握字符串的表示方法和字符串函数的功能、自学掌握四则运算的算法及WIN-TC的图形操作的基本知识、键盘上特殊键的获取及图形方式下光标的显示。 2 课程设计内容 目的：本课程的课程设计要求学生模拟实现一个简单计算器，要求（1）能够实现四则运算，并能支持优先级运算。（2）三角与反三角运算：如sinx，cosx等。（3）指数对数运算：如log（x）,lnx,e的x次方等。（4）其他运算：如X！，x 的累加等。（4）不允许调用库函数，使用自行开发的程序实现常用函数运算。（5）进一步考虑计算器外观设计，用可视化界面给出计算器外观、功能按键及输入界面。 使用说明：执行加法运算，'—'表示执行减法运算，表示执行乘法运算，'/'表示除法运算．‘Q’表示退出计算器‘C’表示清零,’=’表示得出结果'^'表示执行x的y次方,'e'表示执行e的x次方操作，'&'表示执行累加操作.，你可以可以用键盘上的上下左右键对光标进行移动，当光标移动到计算器按键上时，按ENTER即可执行该键的操作!最后按“=”则可得出结果。 3 课题设计的补充知识 本程序通过int specialkey（void）和#include C语言计算器源代码 #include C语言课程设计报告书题目：简易计算器 院系： 班级： 学号： 姓名： 摘要 该软件为用户提供在windows 系统上的简易计算器，能进行简单的加、减、 乘、除四则运算与混合运算。目的是为了巩固和加深 C 语言课程的基本知识的理 解和掌握，利用 C语言进行基本的软件设计，掌握 C 语言的编程和程序调试 的基本技能，掌握书写程序设计说明文档的能力，提高运用 C 语言解决实际问 题的能力。 关键词： C; 简易计算器 ; 程序 ; 基本算法；混合运算 SUMMARY the software provides a simple calculator in Windows system for users ,can be a simple add,subtract,multiply,divide.The purpose is to consolidate and deepen the basic knowledge of C language courses to understand and master, The use of C language for software design basic, To master the basic skills of C language programming and program debugging, Master the writing program design documentation ability,improve the ability to use C language to solve practical problems. 2013-2014学年第二学期 《高级语言程序设计》 课程设计报告 题目：简单计算器 专业：数字媒体技术 班级：13级1班 姓名：邢洪波 指导教 师：王辉 成绩： 计算机与信息工程系 二0一四年二月二十日 1设计内容及要求 利用本学期所学的《C语言程序设计》课程，运用相关知识，查阅相关资料，编写C语言程序，设计一个简单计算器，要求编写的简单计算器能够模拟windows系统的计算器，用户能够用键盘输入相关数据，能够进行简单的加、减、乘、除运算，并且在程序运行过程中能够正常的退出程序。? 在计算器程序运行中，输入数据时如果遇到输入错误的情况，能够能过键盘上的退格键进行删除，并且重新输入正确的数据。在数据输入完成后， 如果需要放弃本次计算操作，可以利用程序中设置好的按键进行清零，并为下一次运算作准备。 运用相关知识，查阅相关资料，编写一个简单的计算器，能够实现简单的基本的加减乘除运算，在计算器工作时用户能利用键盘或鼠标进行相应操作。程序基本功能要求实现完整，并有简单的验证。程序还须有符合标准的 程序设计报告。 2概要设计 系统流程图 系统流程图主要功能表 主要功能表 3设计过程或程序代码 #include<> #include<> #include<> /*malloc的头文件代表在内存中开辟存储空间*/ double jisuan(char a[]) { int i=1,j,k,m,cnt=0,t1=0,t2=0,t3=0; /*定义整型变量i,j,k,m,n,cnt,t1,t2,t3*/ char nibo[50],zhan2[50]; /*定义字符型数组*/ double x,n,l,z=0,zhan3[50]; /*定义双精度变量x,n,l,z,zhan3[50]*/ typedef struct /*表示可以用con定义结构体变量*/ { double d1; int d2; }dd; typedef struct { dd data[50]; int top; }zhan1; zhan1 *shu; /*定义指针变量*/ shu=(zhan1 *)malloc(sizeof(zhan1)); shu->top=0; while(a[i]!='\0') /*外循环是用while语句*/ { C语言_程序设计_计算器 课程设计说明书 题目多功能计算器起讫日期 2006 年 7月 3日至 2006 年 8月 6日 所在院系 专业班级 学生姓名学号 指导教师 2006年 8 月 1 日 摘要 当今社会，随着人们物质生活的不断提高，电子产品已经走进家家户户，无论是生活和学习还是娱乐和消遣几乎样样都离不开电子产品，计算器可谓是我们最亲密的电子伙伴之一。 随着科技的发展，人们对计算要求的精确度越来越高，各种不同功能的计算器已经悄悄走进我们的生活和学习中。对于学生来说一个功能齐全的计算器对我们的学习有着莫大的帮助。借着C语言程序设计的机会，我决定自己动手来研究一下计算器。在练习巩固C语言学习的同时又可以从中体会到计算器的强大功能，然而由于学习的内容和时间有限，至今为止我只能实现四则运算加、减、乘、除、平方、立方和开方的一些简单功能，并且在计算器的里面加了一个漂亮的时钟，用来方便我们的学习。在今后的学习中，我会继续研究，争取进一步来完善它的功能。 本系统采用Turbo C语言开发,生成可执行文件在任何系统下都可以执行，具有很好的数据处理能力和稳定性。本论文主要介绍了该课题的开发背景以及过程和 所要完成的功能。并且重点的说明了系统设计思想，设计的步骤、难点技术和解决方案。由于“初来乍到”，这个程序设计还有一些漏洞和缺陷，希望您多多提出～关键字:Turbo c c语言计算器程序四则数值运算 目录 第一章综述...........................................................................1 1(1 课题的现实意义...............................................................1 1(2 软件环境........................................................................1 1(3 硬件环境 (1) 第二章系统设计流程图............................................................2 2(1 系统流程图.....................................................................2 2(2 主要功能表.....................................................................2 第三章系统分析和设计............................................................3 3(1 图形的绘制和输出............................................................3 3(2 文本的输出显示...............................................................3 3(3 计算函数的调用...............................................................4 3(4 程序的运行和退出 (5) 第四章系统测试.....................................................................6 4(1 缺少变量定义，定义位置不正确..........................................6 4(2 语法错误........................................................................6 4(3 注释的位置.....................................................................6 4(4 逻辑错误 (6) 第五章用户使用说明书……………………………………………………8 5(1 运行Turbo C程序进入计算器界面…………………………………8 5(2 计算器的使 作品：科学计算器 作者：欧宗龙 编写环境：vc++ 语言：c #include "" #include <> #include <> #include <> #include "" #include "" #include <> #include <> #define PI BOOL A_Op=FALSE; BOOL WINAPI Main_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch(uMsg) { HANDLE_MSG(hWnd, WM_INITDIALOG, Main_OnInitDialog); HANDLE_MSG(hWnd, WM_COMMAND, Main_OnCommand); HANDLE_MSG(hWnd,WM_CLOSE, Main_OnClose); } return FALSE; } BOOL Main_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam) { return TRUE; } void TrimNumber(char a[]) { for(unsigned j=strlen(a)-1;j>=i;j--) { if(a[j]=='0') { a[j]='\0'; } else if(a[j]=='.') { a[j]='\0'; } else break; } } } } double Operate(char Operator,double n1,double n2) ; strcat(a,DecP); } ; } DELTIMES++; SetDlgItemText(hwnd,IDC_EDIT,str); A_Op=FALSE; } break; case IDC_BUTTONADD: //加法运算 { RNum[1]=atof(str); RNum[0]=RNum[1]; RNum[1]=RNum[2]; RNum[2]=Operate(Operator,RNum[1],RNum[0]); 一、设计思想 计算算术表达式可以用两种方法实现： 1.中缀转后缀算法 此算法分两步实现：先将算术表达式转换为后缀表达式，然后对后缀表达式进行计算。具体实现方法如下： （1）中缀转后缀 需要建一个操作符栈op和一个字符数组exp，op栈存放操作符，字符数组用来存放转换以后的后缀表达式。首先，得到用户输入的中缀表达式，将其存入str数组中。 对str数组逐个扫描，如果是数字或小数点，则直接存入exp数组中，当扫描完数值后，在后面加一个#作为分隔符。 如果是操作符，并且栈为空直接入栈，如果栈不为空，与栈顶操作符比较优先等级，若比栈顶优先级高，入栈；如果比栈顶优先级低或相等，出栈将其操作符存到exp数组中，直到栈顶元素优先等级低于扫描的操作符，则此操作符入栈；如果是左括号，直接入栈，如果是右括号，出栈存入exp数组，直到遇到左括号，左括号丢掉。然后继续扫描下一个字符，直到遇到str中的结束符号\0，扫描结束。结束后看op栈是否为空，若不为空，继续出栈存入exp数组中，直到栈为空。到此在exp数组最后加结束字符\0。 我们就得到了后缀表达式。 （2）后缀表达式计算 此时需要一个数值栈od来存放数值。对exp数组进行逐个扫描，当遇到数字或小数点时，截取数值子串将其转换成double类型的小数，存入od栈中。当遇到操作符，从栈中取出两个数，进行计算后再放入栈中。继续扫描，知道扫描结束，此时值栈中的数值就是计算的结果，取出返回计算结果。 2.两个栈实现算法 此算法需要两个栈，一个值栈od，一个操作符栈op。将用户输入的数学表达式存入str数组中，对其数组进行逐个扫描。 当遇到数字或小数点，截取数值子串，将其转换成double类型的数值存入od栈中； 当遇到左括号，直接入op栈；遇到右括号，op栈出栈，再从值栈od中取出两个数值，计算将其结果存入值栈中，一直进行此操作，直到操作符栈栈顶为左括号，将左括号丢掉。 如果遇到操作符，若op栈为空，直接入栈；若栈不为空，与栈顶元素比较优先等级，若比栈顶操作符优先等级高，直接入op栈，如果低于或等于栈顶优先等级，op栈出栈，再从值栈中取出两个数值，计算将其结果存入值栈中，一直进行此操作，直到栈顶优先等级低于扫描的操作符等级，将此操作符入op栈。继续扫描直到遇到str中的结束字符\0，扫描结束。此时看操作符栈是否为空，若不为空，出栈，再从值栈中取出两个数值进行计算，将其结果存入值栈，一直进行此操作，直到操作符栈为空。此时把值栈中的数值取出，即为所得的最终计算结果。 二、算法流程图 第一种算法：中缀转后缀算法 目录 1.题目内容---------------------------------------------2 2.程序特点及功能------------------------------------3 3.总体思路---------------------------------------------3 4.详细设计---------------------------------------------4 5.程序清单---------------------------------------------6 6.运行结果与分析------------------------------------13 7.参考文献---------------------------------------------22 课程设计名称：小型特殊计算器 1.设计内容： 实现一个特殊的计算器，可以实现复数、有理数、矩阵和集合的特殊计算。程序可以实现复数、有理数的加、减、乘、除，可以实现矩阵的加法、减法和乘法运算，也可以实现集合的求交集、并集、子集的运算。 2.设计目的与要求： 2.1设计目的 1.达到熟练掌握C++语言的基本知识和技能； 2.基本掌握面向对象程序设计的基本思路和方法； 3.能够利用所学的基本知识和技能，解决简单的面向对象程序设计问题。 2.2设计要求 1.要求利用面向对象的方法以及C++的编程思想来完成系统的设计； 2.要求在设计的过程中，建立清晰的类层次； 3.在系统的设计中，至少要用到面向对象的一种机制。 3.系统分析与设计 《一》主要知识点 运算符重载增加了C++语言的可扩充性。运算符的重载实际上就是一种函数调用的形式，可以用成员函数重载运算符，就是将运算符重载定义为一个类的成员函数的形式；也可以用友元函数重载。用友元重载运算符的友元函数是独立于类以外的一般函数。《二》关键技术 程序中每一种数据类型用一个类来实现，共设计了4个类。复数类complex，矩阵类matrix，有理数类rational以及集合类set。每一种类都定义了相应的运算符重载函数。具体定义如下所示： （1）类complex 类complex中，成员变量image表示虚部，real表示实部。成员函数print()用来显示数据。运算符重载函数都是用友元函数来实现的。分别重载+、-、*、/运算符。 （2）类matrix 类matrix中，成员变量elems用来存放矩阵的所有元素，rows表示矩阵的行，cols 表示矩阵的列。成员函数SetElems()用来给矩阵中的每一个元素赋值，Disp()用来显示矩阵中的所有元素。其它友元函数分别重载+、-、*、/运算符。 （3）类rational 类rational中，有两个成员变量：denominator用来表示有理数的分母，numerator 表示有理数的分子。有理数成员函数print()用来显示有理数，optimization()用来优化有理数函数。友元函数real()用来将有理数转换为实数，其它友元函数分别重载+、-、*、/运算符。 （4）类set 类set中，有两个成员变量：elems用来存储集合中的元素，card表示集合中元素的个数。成员函数print()用来输出集合中的元素，additem()用来给集合增加元素。友元函数分别重载了&、==、!=、+、*、<、<=运算符。 供应链管理 用C语言设计简易计算器 班级:工业工程1103班 姓名: 2014/5/6 一、设计内容 我设计的是一款简易计算器，界面清楚，操作方便，它能实现以下功能：1．以界面形式给出计算器功能 2．简单的四则混合运算（支持小括号、优先级） 3．弦、余弦函数计算 4．指数、对数的运算 二、总体设计 简单计算器由五大模块组成，模块设计如下： 模块调用图 1.主函数 void main() 功能：调用各个主要模块，实现简单计算器的整体功能。2. 主界面函数void JieMian() 功能：使用有关图形函数模拟出可视化的计算器外观界面，并提供用户输入窗口。 3.四则混合运算函数void SiZeHunHeYunSuan() 功能：实现简单的加减乘除混合运算，并支持优先级和带括号的运算。 4.三角运算函数void SanJiaoYunSuan() 功能：实现基本的三角函数运算：sin(x)和cos(x)。 5.指对数函数void ZhiDuiShuYunSuan() 功能：实现基本的指数和对数运算。 三、采取的解决措施： 1.去图书馆借相关图书，上网查资料，通过自己的阅读，研究，不断的尝试，运行，修改，最终做出了简单的界面，但仍存在很多不足的地方，只能模拟出大体的外观，没能模拟出计算器中的各个键。 2.查在界面显示的函数原型，对比自己的程序，不断修改，对比，调试，检查，反思，最后发现是语句顺序错误，显示写在了判断的后面，修改成功。 3.在编写ln函数的时候，遇到很大困难，最后通过查阅资料，向别人请教编写出了函数。 四、详细代码： #include c语言程序设计课程计算器设计报告
C语言简易计算器的实现
C语言课程设计 简单计算器程序
C语言实现计算器功能
大学计算机c语言计算器源代码
AT89C51单片机C实现简易计算器
C语言制作简单计算器
计算器C语言程序
设计一个简单计算器的C语言课程设计报告
C语言课程设计--计算器(图形界面)
C语言编写的计算器源代码
(完整word版)C语言简易计算器课程设计.doc
C语言简单计算器的编写课程设计
C语言_程序设计_计算器
用c语言编写的计算器源代码
数学表达式计算(c语言实现)
C语言程序课程设计报告(小型计算器)
用C语言编写简易计算器