Simple算法_fortran语言编写
Cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
Cccc This computer program was copied from the graduate student course program
Cccc of the University of Minnesota. Part of it was re-formulated to meet the
Cccc personal computer environment. Some inappropriate expressions were also
Cccc corrected. The program is used only for teaching purpose. No part of it
Cccc may be published. You may use it as a frame to re-develop your own code
Cccc for research purpose. XJTU Instructor, 1995.11
**************************************************************************** *----------------------------MAIN PROGRAM-----------------------------------
**************************************************************************** LOGICAL LSTOP
COMMON/CNTL/LSTOP
**************************************************************************** OPEN(08,FILE='teresul')
CALL SETUP0
CALL GRID
CALL SETUP1
CALL START
10 CALL DENSE
CALL BOUND
CALL OUTPUT
IF(.NOT.LSTOP) GO TO 15
CLOSE(08)
STOP
15 CALL SETUP2
GO TO 10
END
*---------------------------------------------------------------------------
SUBROUTINE DIFLOW
**************************************************************************** COMMON/COEF/FLOW,DIFF,ACOF
**************************************************************************** ACOF=DIFF
IF(FLOW .EQ.0.0)RETURN
TEMP=DIFF-ABS(FLOW)*0.1
ACOF=0.
IF(TEMP .LE. 0. ) RETURN
TEMP=TEMP/DIFF
ACOF=DIFF*TEMP**5
RETURN
END
*--------------------------------------------------------------------------
SUBROUTINE SOLVE
****************************************************************************
DOUBLE PRECISION TITLE
LOGICAL LSOLVE,LPRINT,LBLK,LSTOP
COMMON F(22,22,10),P(22,22),RHO(22,22),GAM(22,22),CON(22,22),
& AIP(22,22),AIM(22,22),AJP(22,22),AJM(22,22),AP(22,22),
& X(22),XU(22),XDIF(22),XCV(22),XCVS(22),
& Y(22),YV(22),YDIF(22),YCV(22),YCVS(22),
& YCVR(22),YCVRS(22),ARX(22),ARXJ(22),ARXJP(22),
& R(22),RMN(22),SX(22),SXMN(22),XCVI(22),XCVIP(22)
COMMON DU(22,22),DV(22,22),FV(22),FVP(22),
& FX(22),FXM(22),FY(22),FYM(22),PT(22),QT(22)
COMMON /INDX/NF,NFMAX,NP,NRHO,NGAM,L1,L2,L3,M1,M2,M3,
& IST,JST,ITER,LAST,TITLE(13),RELAX(13),TIME,DT,XL,YL,
&IPREF,JPREF,LSOLVE(10),LPRINT(13),LBLK(10),MODE,NTIMES(10),RHOCON
**************************************************************************** ISTF=IST-1
JSTF=JST-1
IT1=L2+IST
IT2=L3+IST
JT1=M2+JST
JT2=M3+JST
**************************************************************************** DO 999 NT=1,NTIMES(NF)
DO 999 N=NF,NF
*---------------------------------------------------------------------------
IF(.NOT. LBLK(NF)) GO TO 10
PT(ISTF)=0.
QT(ISTF)=0.
DO 11 I=IST,L2
BL=0.
BLP=0.
BLM=0.
BLC=0.
DO 12 J=JST,M2
BL=BL+AP(I,J)
IF(J .NE. M2) BL=BL-AJP(I,J)
IF(J .NE. JST) BL=BL-AJM(I,J)
BLP=BLP+AIP(I,J)
BLM=BLM+AIM(I,J)
BLC=BLC+CON(I,J)+AIP(I,J)*F(I+1,J,N)+AIM(I,J)*F(I-1,J,N)
& +AJP(I,J)*F(I,J+1,N)+AJM(I,J)*F(I,J-1,N)-AP(I,J)*F(I,J,N)
12 CONTINUE
DENOM=BL-PT(I-1)*BLM
DENO=1.E15
IF(ABS(DENOM/BL) .LT. 1.E-10) DENOM=1.E20*DENO
QT(I)=(BLC+BLM*QT(I-1))/DENOM
11 CONTINUE
BL=0.
DO 13 II=IST,L2
I=IT1-II
BL=BL*PT(I)+QT(I)
DO 13 J=JST,M2
13 F(I,J,N)=F(I,J,N)+BL
*--------------------------------------------------------------------------- PT(JSTF)=0.
QT(JSTF)=0.
DO 21 J=JST,M2
BL=0.
BLP=0.
BLM=0.
BLC=0.
DO 22 I=IST,L2
BL=BL+AP(I,J)
IF(I .NE. L2) BL=BL-AIP(I,J)
IF(I .NE. IST) BL=BL-AIM(I,J)
BLP=BLP+AJP(I,J)
BLM=BLM+AJM(I,J)
BLC=BLC+CON(I,J)+AIP(I,J)*F(I+1,J,N)+AIM(I,J)*F(I-1,J,N)
& +AJP(I,J)*F(I,J+1,N)+AJM(I,J)*F(I,J-1,N)-AP(I,J)*F(I,J,N)
22 CONTINUE
DENOM=BL-PT(J-1)*BLM
IF (ABS(DENOM/BL) .LT. 1E-10) DENOM=1.E20*DENO
PT(J)=BLP/DENOM
QT(J)=(BLC+BLM*QT(J-1))/DENOM
21 CONTINUE
BL=0.
DO 23 JJ=JST,M2
J=JT1-JJ
BL=BL*PT(J)+QT(J)
DO 23 I=IST,L2
23 F(I,J,N)=F(I,J,N)+BL
10 CONTINUE
*-----------------------------------------------------------------------
DO 90 J=JST,M2
PT(ISTF)=0.
QT(ISTF)=F(ISTF,J,N)
DO 70 I=IST,L2
DENOM=AP(I,J)-PT(I-1)*AIM(I,J)
TEMP=CON(I,J)+AJP(I,J)*F(I,J+1,N)+AJM(I,J)*F(I,J-1,N)
QT(I)=(TEMP+AIM(I,J)*QT(I-1))/DENOM
70 CONTINUE
DO 80 II=IST,L2
I=IT1-II
80 F(I,J,N)=F(I+1,J,N)*PT(I)+QT(I)
90 CONTINUE
*----------------------------------------------------------------------- DO 190 JJ=JST,M3
J=JT2-JJ
PT(ISTF)=0.
QT(ISTF)=F(ISTF,J,N)
DO 170 I=IST,L2
DENOM=AP(I,J)-PT(I-1)*AIM(I,J)
PT(I)=AIP(I,J)/DENOM
TEMP=CON(I,J)+AJP(I,J)*F(I,J+1,N)+AJM(I,J)*F(I,J-1,N)
QT(I)=(TEMP+AIM(I,J)*QT(I-1))/DENOM
170 CONTINUE
DO 180 II=IST,L2
I=IT1-II
180 F(I,J,N)=F(I+1,J,N)*PT(I)+QT(I)
190 CONTINUE
*----------------------------------------------------------------------- DO 290 I=IST,L2
PT(JSTF)=0.
QT(JSTF)=F(I,JSTF,N)
DO 270 J=JST,M2
DENOM=AP(I,J)-PT(J-1)*AJM(I,J)
PT(J)=AJP(I,J)/DENOM
TEMP=CON(I,J)+AIP(I,J)*F(I+1,J,N)+AIM(I,J)*F(I-1,J,N)
QT(J)=(TEMP+AJM(I,J)*QT(J-1))/DENOM
270 CONTINUE
DO 280 JJ=JST,M2
J=JT1-JJ
280 F(I,J,N)=F(I,J+1,N)*PT(J)+QT(J)
290 CONTINUE
*----------------------------------------------------------------------- DO 390 II=IST,L3
I=IT2-II
PT(JSTF)=0.
QT(JSTF)=F(I,JSTF,N)
DO 370 J=JST,M2
DENOM=AP(I,J)-PT(J-1)*AJM(I,J)
TEMP=CON(I,J)+AIP(I,J)*F(I+1,J,N)+AIM(I,J)*F(I-1,J,N)
QT(J)=(TEMP+AJM(I,J)*QT(J-1))/DENOM
370 CONTINUE
DO 380 JJ=JST,M2
J=JT1-JJ
380 F(I,J,N)=F(I,J+1,N)*PT(J)+QT(J)
390 CONTINUE
************************************************************************ 999 CONTINUE
DO 400 J=2,M2
DO 400 I=2,L2
CON(I,J)=0.
AP(I,J)=0.
400 CONTINUE
RETURN
END
************************************************************************ SUBROUTINE SETUP
************************************************************************ DOUBLE PRECISION TITLE
LOGICAL LSOLVE,LPRINT,LBLK,LSTOP
COMMON F(22,22,10),P(22,22),RHO(22,22),GAM(22,22),CON(22,22),
& AIP(22,22),AIM(22,22),AJP(22,22),AJM(22,22),AP(22,22),
& X(22),XU(22),XDIF(22),XCV(22),XCVS(22),
& Y(22),YV(22),YDIF(22),YCV(22),YCVS(22),
&YCVR(22),YCVRS(22),ARX(22),ARXJ(22),ARXJP(22),
&R(22),RMN(22),SX(22),SXMN(22),XCVI(22),XCVIP(22)
COMMON DU(22,22),DV(22,22),FV(22),FVP(22),
& FX(22),FXM(22),FY(22),FYM(22),PT(22),QT(22)
COMMON /INDX/NF,NFMAX,NP,NRHO,NGAM,L1,L2,L3,M1,M2,M3,
& IST,JST,ITER,LAST,TITLE(13),RELAX(13),TIME,DT,XL,YL,
& IPREF,JPREF,LSOLVE(10),LPRINT(13),LBLK(10),MODE,NTIMES(10),RHOCON
COMMON/CNTL/LSTOP
COMMON/SORC/SMAX,SSUM
COMMON/COEF/FLOW,DIFF,ACOF
DIMENSION U(22,22),V(22,22),PC(22,22)
EQUIVALENCE (F(1,1,1),U(1,1)),(F(1,1,2),V(1,1)),(F(1,1,3),PC(1,1))
************************************************************************
1 FORMAT(//15X,'COMPUTATION IN CARTISIAN COORDINATES')
2 FORMAT(//15X,'COMPUTATION FOR AXISYMMETRICAL SITUATION')
3 FORMAT(//15X,' COMPUTATION IN POLAR COORDINATES ')
4 FORMAT(1X,14X,40(1H*),//)
*-----------------------------------------------------------------------
ENTRY SETUP0
NFMAX=10
NP=11
NRHO=12
NGAM=13
LSTOP=.FALSE.
DO 779 I=1,10
LSOLVE(I)=.FALSE.
LBLK(I)=.TRUE.
779 NTIMES(I)=1
DO 889 I=1,13
LPRINT(I)=.FALSE.
889 RELAX(I)=1.
MODE=1
LAST=5
TIME=0.
ITER=0
DT=1.0E+10
IPREF=1
JPREF=1
RHOCON=1
RETURN
*----------------------------------------------------------------------- ENTRY SETUP1
L2=L1-1
L3=L2-1
M2=M1-1
M3=M2-1
X(1)=XU(2)
DO 5 I=2,L2
5 X(I)=0.5*(XU(I+1)+XU(I))
X(L1)=XU(L1)
Y(1)=YV(2)
DO 10 J=2,M2
10 Y(J)=0.5*(YV(J+1)+YV(J))
Y(M1)=YV(M1)
DO 15 I=2,L1
15 XDIF(I)=X(I)-X(I-1)
DO 18 I=2,L2
18 XCV(I)=XU(I+1)-XU(I)
DO 20 I=3,L2
20 XCVS(I)=XDIF(I)
XCVS(3)=XCVS(3)+XDIF(2)
XCVS(L2)=XCVS(L2)+XDIF(L1)
DO 22 I=3,L3
XCVI(I)=0.5*XCV(I)
22 XCVIP(I)=XCVI(I)
XCVIP(2)=XCV(2)
XCVI(L2)=XCV(L2)
DO 35 J=2,M1
35 YDIF(J)=Y(J)-Y(J-1)
DO 40 J=2,M2
40 YCV(J)=YV(J+1)-YV(J)
DO 45 J=3,M2
45 YCVS(J)=YDIF(J)
YCVS(3)=YCVS(3)+YDIF(2)
YCVS(M2)=YCVS(M2)+YDIF(M1)
IF (MODE .NE. 1) GO TO 55
DO 52 J=1,M1
RMN(J)=1.
52 R(J)=1.
GO TO 56
55 DO 50 J=2,M1
50 R(J)=R(J-1)+YDIF(J)
RMN(2)=R(1)
DO 60 J=3,M2
60 RMN(J)=RMN(J-1)+YCV(J-1)
RMN(M1)=R(M1)
56 CONTINUE
DO 57 J=1,M1
SX(J)=1.
SXMN(J)=1.
IF(MODE .NE. 3) GO TO 57
SX(J)=R(J)
IF(J .NE. 1) SXMN(J)=RMN(J)
57 CONTINUE
DO 62 J=2,M2
YCVR(J)=R(J)*YCV(J)
ARX(J)=YCVR(J)
IF (MODE .NE. 3) GO TO 62
ARX(J)=YCV(J)
62 CONTINUE
DO 64 J=4,M3
64 YCVRS(J)=0.5*(R(J)+R(J-1))*YDIF(J)
YCVRS(3)=0.5*(R(3)+R(1))*YCVS(3)
YCVRS(M2)=0.5*(R(M1)+R(M3))*YCVS(M2) IF(MODE .NE. 2) GO TO 67
DO 65 J=3,M3
ARXJ(J)=0.25*(1.+RMN(J)/R(J))*ARX(J)
65 ARXJP(J)=ARX(J)-ARXJ(J)
GO TO 68
67 DO 66 J=3,M3
ARXJ(J)=0.5*ARX(J)
66 ARXJP(J)=ARXJ(J)
68 ARXJP(2)=ARX(2)
ARXJ(M2)=ARX(M2)
DO 70 J=3,M3
FV(J)=ARXJP(J)/ARX(J)
70 FVP(J)=1.-FV(J)
DO 85 I=3,L2
FX(I)=0.5*XCV(I-1)/XDIF(I)
85 FXM(I)=1.-FX(I)
FX(2)=0.
FXM(2)=1.
FX(L1)=1.
FXM(L1)=0.
DO 90 J=3,M2
FY(J)=0.5*YCV(J-1)/YDIF(J)
90 FYM(J)=1.-FY(J)
FY(2)=0.
FYM(2)=1.
FY(M1)=1.
FYM(M1)=0.
*---CON,AP,U,V,RHO,PC AND P ARRAYS ARE INITIALIZED HERE---- DO 95 J=1,M1
DO 95 I=1,L1
PC(I,J)=0.
U(I,J)=0.
V(I,J)=0.
CON(I,J)=0.
AP(I,J)=0.
RHO(I,J)=RHOCON
P(I,J)=0.
95 CONTINUE
IF(MODE .EQ. 1) WRITE(8,1)
IF(MODE .EQ. 2) WRITE(8,2)
IF(MODE .EQ. 3) WRITE(8,3)
WRITE(8,4)
RETURN
*----------------------------------------------------------------------
ENTRY SETUP2
*---COEFFICIENTS FOR THE U EQUATION----
NF=1
IF(.NOT. LSOLVE(NF)) GO TO 100
IST=3
JST=2
CALL GAMSOR
REL=1.-RELAX(NF)
DO 102 I=3,L2
FL=XCVI(I)*V(I,2)*RHO(I,1)
FLM=XCVIP(I-1)*V(I-1,2)*RHO(I-1,1)
FLOW=R(1)*(FL+FLM)
DIFF=R(1)*(XCVI(I)*GAM(I,1)+XCVIP(I-1)*GAM(I-1,1))/YDIF(2)
CALL DIFLOW
102 AJM(I,2)=ACOF+AMAX1(0.,FLOW)
DO 103 J=2,M2
FLOW=ARX(J)*U(2,J)*RHO(1,J)
DIFF=ARX(J)*GAM(1,J)/(XCV(2)*SX(J))
CALL DIFLOW
AIM(3,J)=ACOF+AMAX1(0.,FLOW)
DO 103 I=3,L2
IF(I .EQ. L2) GO TO 104
FL=U(I,J)*(FX(I)*RHO(I,J)+FXM(I)*RHO(I-1,J))
FLP=U(I+1,J)*(FX(I+1)*RHO(I+1,J)+FXM(I+1)*RHO(I,J))
FLOW=ARX(J)*0.5*(FL+FLP)
DIFF=ARX(J)*GAM(I,J)/(XCV(I)*SX(J))
GO TO 105
104 FLOW=ARX(J)*U(L1,J)*RHO(L1,J)
DIFF=ARX(J)*GAM(L1,J)/(XCV(L2)*SX(J))
105 CALL DIFLOW
AIM(I+1,J)=ACOF+AMAX1(0.,FLOW)
AIP(I,J)=AIM(I+1,J)-FLOW
IF (J .EQ. M2) GOTO 106
FL=XCVI(I)*V(I,J+1)*(FY(J+1)*RHO(I,J+1)+FYM(J+1)*RHO(I,J))
FLM=XCVIP(I-1)*V(I-1,J+1)*(FY(J+1)*RHO(I-1,J+1)+FYM(J+1)*
& RHO(I-1,J))
GM=GAM(I,J)*GAM(I,J+1)/(YCV(J)*GAM(I,J+1)+YCV(J+1)*GAM(I,J)+ & 1.0E-30)*XCVI(I)
GMM=GAM(I-1,J)*GAM(I-1,J+1)/(YCV(J)*GAM(I-1,J+1)+YCV(J+1)*
& GAM(I-1,J)+1.E-30)*XCVIP(I-1)
DIFF=RMN(J+1)*2.*(GM+GMM)
GO TO 107
106 FL=XCVI(I)*V(I,M1)*RHO(I,M1)
FLM=XCVIP(I-1)*V(I-1,M1)*RHO(I-1,M1)
DIFF=R(M1)*(XCVI(I)*GAM(I,M1)+XCVIP(I-1)*GAM(I-1,M1))/YDIF(M1) 107 FLOW=RMN(J+1)*(FL+FLM)
CALL DIFLOW
AJM(I,J+1)=ACOF+AMAX1(0.,FLOW)
AJP(I,J)=AJM(I,J+1)-FLOW
VOL=YCVR(J)*XCVS(I)
APT=(RHO(I,J)*XCVI(I)+RHO(I-1,J)*XCVIP(I-1))
& /(XCVS(I)*DT)
AP(I,J)=AP(I,J)-APT
CON(I,J)=CON(I,J)+APT*U(I,J)
AP(I,J)=(-AP(I,J)*VOL+AIP(I,J)+AIM(I,J)+AJP(I,J)+AJM(I,J))
& /RELAX(NF)
CON(I,J)=CON(I,J)*VOL+REL*AP(I,J)*U(I,J)
DU(I,J)=VOL/(XDIF(I)*SX(J))
CON(I,J)=CON(I,J)+DU(I,J)*(P(I-1,J)-P(I,J))
DU(I,J)=DU(I,J)/AP(I,J)
103 CONTINUE
CALL SOLVE
100 CONTINUE
*---COEFFICIENTS FOR THE V EQUATION----
NF=2
IF(.NOT. LSOLVE(NF)) GO TO 200
IST=2
JST=3
CALL GAMSOR
REL=1.-RELAX(NF)
DO 202 I=2,L2
AREA=R(1)*XCV(I)
FLOW=AREA*V(I,2)*RHO(I,1)
DIFF=AREA*GAM(I,1)/YCV(2)
CALL DIFLOW
202 AJM(I,3)=ACOF+AMAX1(0.,FLOW)
DO 203 J=3,M2
FL=ARXJ(J)*U(2,J)*RHO(1,J)
FLM=ARXJP(J-1)*U(2,J-1)*RHO(1,J-1)
FLOW=FL+FLM
DIFF=(ARXJ(J)*GAM(1,J)+ARXJP(J-1)*GAM(1,J-1))/(XDIF(2)*SXMN(J)) CALL DIFLOW
AIM(2,J)=ACOF+AMAX1(0.,FLOW)
DO 203 I=2,L2
IF(I .EQ. L2)GO TO 204
FL=ARXJ(J)*U(I+1,J)*(FX(I+1)*RHO(I+1,J)+FXM(I+1)*RHO(I,J))
FLM=ARXJP(J-1)*U(I+1,J-1)*(FX(I+1)*RHO(I+1,J-1)+FXM(I+1)*
& RHO(I,J-1))
GM=GAM(I,J)*GAM(I+1,J)/(XCV(I)*GAM(I+1,J)+XCV(I+1)*GAM(I,J)+ & 1.E-30)*ARXJ(J)
GMM=GAM(I,J-1)*GAM(I+1,J-1)/(XCV(I)*GAM(I+1,J-1)+XCV(I+1)*
& GAM(I,J-1)+1.0E-30)*ARXJP(J-1)
DIFF=2.*(GM+GMM)/SXMN(J)
GO TO 205
204 FL=ARXJ(J)*U(L1,J)*RHO(L1,J)
FLM=ARXJP(J-1)*U(L1,J-1)*RHO(L1,J-1)
DIFF=(ARXJ(J)*GAM(L1,J)+ARXJP(J-1)*GAM(L1,J-1))/(XDIF(L1)*SXMN(J)) 205 FLOW=FL+FLM
CALL DIFLOW
AIM(I+1,J)=ACOF+AMAX1(0.,FLOW)
AIP(I,J)=AIM(I+1,J)-FLOW
IF(J .EQ. M2) GO TO 206
AREA=R(J)*XCV(I)
FL=V(I,J)*(FY(J)*RHO(I,J)+FYM(J)*RHO(I,J-1))*RMN(J)
FLP=V(I,J+1)*(FY(J+1)*RHO(I,J+1)+FYM(J+1)*RHO(I,J))*RMN(J+1)
FLOW=(FV(J)*FL+FVP(J)*FLP)*XCV(I)
DIFF=AREA*GAM(I,J)/YCV(J)
GO TO 207
206 AREA=R(M1)*XCV(I)
FLOW=AREA*V(I,M1)*RHO(I,M1)
DIFF=AREA*GAM(I,M1)/YCV(M2)
207 CALL DIFLOW
AJM(I,J+1)=ACOF+AMAX1(0.,FLOW)
AJP(I,J)=AJM(I,J+1)-FLOW
VOL=YCVRS(J)*XCV(I)
SXT=SX(J)
IF(J .EQ. M2) SXT=SX(M1)
SXB=SX(J-1)
IF(J .EQ. 3) SXB=SX(1)
APT=(ARXJ(J)*RHO(I,J)*0.5*(SXT+SXMN(J))+ARXJP(J-1)*RHO(I,J-1)*
& 0.5*(SXB+SXMN(J)))/(YCVRS(J)*DT)
AP(I,J)=AP(I,J)-APT
CON(I,J)=CON(I,J)+APT*V(I,J)
AP(I,J)=(-AP(I,J)*VOL+AIP(I,J)+AIM(I,J)+AJP(I,J)+AJM(I,J))
& /RELAX(NF)
CON(I,J)=CON(I,J)*VOL+REL*AP(I,J)*V(I,J)
DV(I,J)=VOL/YDIF(J)
CON(I,J)=CON(I,J)+DV(I,J)*(P(I,J-1)-P(I,J))
DV(I,J)=DV(I,J)/AP(I,J)
203 CONTINUE
CALL SOLVE
200 CONTINUE
*---COEFIICIENTS FOR THE PRESSURE CORRECTION EQUATION----
NF=3
IF(.NOT. LSOLVE(NF)) GO TO 500
IST=2
JST=2
CALL GAMSOR
SMAX=0.
SSUM=0.
DO 410 J=2,M2
DO 410 I=2,L2
VOL=YCVR(J)*XCV(I)
410 CON(I,J)=CON(I,J)*VOL
DO 402 I=2,L2
ARHO=R(1)*XCV(I)*RHO(I,1)
CON(I,2)=CON(I,2)+ARHO*V(I,2)
402 AJM(I,2)=0.
DO 403 J=2,M2
ARHO=ARX(J)*RHO(1,J)
CON(2,J)=CON(2,J)+ARHO*U(2,J)
AIM(2,J)=0.
DO 403 I=2,L2
IF(I .EQ. L2) GO TO 404
ARHO=ARX(J)*(FX(I+1)*RHO(I+1,J)+FXM(I+1)*RHO(I,J))
FLOW=ARHO*U(I+1,J)
CON(I,J)=CON(I,J)-FLOW
CON(I+1,J)=CON(I+1,J)+FLOW
AIP(I,J)=ARHO*DU(I+1,J)
AIM(I+1,J)=AIP(I,J)
GO TO 405
404 ARHO=ARX(J)*RHO(L1,J)
CON(I,J)=CON(I,J)-ARHO*U(L1,J)
AIP(I,J)=0.
405 IF(J .EQ. M2) GO TO 406
ARHO=RMN(J+1)*XCV(I)*(FY(J+1)*RHO(I,J+1)+FYM(J+1)*RHO(I,J)) FLOW=ARHO*V(I,J+1)
CON(I,J)=CON(I,J)-FLOW
CON(I,J+1)=CON(I,J+1)+FLOW
AJP(I,J)=ARHO*DV(I,J+1)
AJM(I,J+1)=AJP(I,J)
GO TO 407
406 ARHO=RMN(M1)*XCV(I)*RHO(I,M1)
CON(I,J)=CON(I,J)-ARHO*V(I,M1)
AJP(I,J)=0.
407 AP(I,J)=AIP(I,J)+AIM(I,J)+AJP(I,J)+AJM(I,J)
PC(I,J)=0.
SMAX=AMAX1(SMAX,ABS(CON(I,J)))
SSUM=SSUM+CON(I,J)
403 CONTINUE
CALL SOLVE
*---COMEE HERE TO CORRECT THE PRESSURE AND VELOCITIES DO 501 J=2,M2
DO 501 I=2,L2
P(I,J)=P(I,J)+PC(I,J)*RELAX(NP)
IF(I .NE. 2) U(I,J)=U(I,J)+DU(I,J)*(PC(I-1,J)-PC(I,J))
IF(J .NE. 2) V(I,J)=V(I,J)+DV(I,J)*(PC(I,J-1)-PC(I,J))
501 CONTINUE
500 CONTINUE
*---COEFFICIENTS FOR OTHER EQUATIONS----
IST=2
JST=2
DO 600 N=4,NFMAX
NF=N
IF(.NOT. LSOLVE(NF)) GO TO 600
CALL GAMSOR
REL=1.-RELAX(NF)
DO 602 I=2,L2
AREA=R(1)*XCV(I)
FLOW=AREA*V(I,2)*RHO(I,1)
DIFF=AREA*GAM(I,1)/YDIF(2)
CALL DIFLOW
602 AJM(I,2)=ACOF+AMAX1(0.,FLOW)
DO 603 J=2,M2
FLOW=ARX(J)*U(2,J)*RHO(1,J)
DIFF=ARX(J)*GAM(1,J)/(XDIF(2)*SX(J))
CALL DIFLOW
AIM(2,J)=ACOF+AMAX1(0.,FLOW)
DO 603 I=2,L2
IF(I .EQ. L2) GO TO 604
FLOW=ARX(J)*U(I+1,J)*(FX(I+1)*RHO(I+1,J)+FXM(I+1)*RHO(I,J))
DIFF=ARX(J)*2.*GAM(I,J)*GAM(I+1,J)/((XCV(I)*GAM(I+1,J)+
& XCV(I+1)*GAM(I,J)+1.0E-30)*SX(J))
GO TO 605
604 FLOW=ARX(J)*U(L1,J)*RHO(L1,J)
DIFF=ARX(J)*GAM(L1,J)/(XDIF(L1)*SX(J))
605 CALL DIFLOW
AIM(I+1,J)=ACOF+AMAX1(0.,FLOW)
AIP(I,J)=AIM(I+1,J)-FLOW
AREA=RMN(J+1)*XCV(I)
IF(J .EQ. M2) GO TO 606
FLOW=AREA*V(I,J+1)*(FY(J+1)*RHO(I,J+1)+FYM(J+1)*RHO(I,J))
DIFF=AREA*2.*GAM(I,J)*GAM(I,J+1)/(YCV(J)*GAM(I,J+1)+
& YCV(J+1)*GAM(I,J)+1.0E-30)
GO TO 607
606 FLOW=AREA*V(I,M1)*RHO(I,M1)
DIFF=AREA*GAM(I,M1)/YDIF(M1)
607 CALL DIFLOW
AJM(I,J+1)=ACOF+AMAX1(0.,FLOW)
AJP(I,J)=AJM(I,J+1)-FLOW
VOL=YCVR(J)*XCV(I)
APT=RHO(I,J)/DT
AP(I,J)=AP(I,J)-APT
CON(I,J)=CON(I,J)+APT*F(I,J,NF)
AP(I,J)=(-AP(I,J)*VOL+AIP(I,J)+AIM(I,J)+AJP(I,J)+AJM(I,J))
& /RELAX(NF)
CON(I,J)=CON(I,J)*VOL+REL*AP(I,J)*F(I,J,NF)
603 CONTINUE
CALL SOLVE
600 CONTINUE
TIME=TIME+DT
ITER=ITER+1
IF(ITER .GE. LAST) LSTOP=.TRUE.
RETURN
END
*-----------------------------------------------------------------------
SUBROUTINE SUPPLY
************************************************************************ DOUBLE PRECISION TITLE
LOGICAL LSOLVE,LPRINT,LBLK,LSTOP
COMMON F(22,22,10),P(22,22),RHO(22,22),GAM(22,22),CON(22,22),
& AIP(22,22),AIM(22,22),AJP(22,22),AJM(22,22),AP(22,22),
& X(22),XU(22),XDIF(22),XCV(22),XCVS(22),
& Y(22),YV(22),YDIF(22),YCV(22),YCVS(22),
&YCVR(22),YCVRS(22),ARX(22),ARXJ(22),ARXJP(22),
&R(22),RMN(22),SX(22),SXMN(22),XCVI(22),XCVIP(22)
COMMON DU(22,22),DV(22,22),FV(22),FVP(22),
&FX(22),FXM(22),FY(22),FYM(22),PT(22),QT(22)
COMMON/INDX/NF,NFMAX,NP,NRHO,NGAM,L1,L2,L3,M1,M2,M3,
& IST,JST,ITER,LAST,TITLE(13),RELAX(13),TIME,DT,XL,YL,
& IPREF,JPREF,LSOLVE(10),LPRINT(13),LBLK(10),MODE,NTIMES(10),RHOCON
DIMENSION U(22,22),V(22,22),PC(22,22)
EQUIVALENCE (F(1,1,1),U(1,1)),(F(1,1,2),V(1,1)),(F(1,1,3),PC(1,1))
************************************************************************
10 FORMAT(1X,26(1H*),3X,A10,3X,26(1H*))
20 FORMAT(1X,4H I =,I6,6I9)
30 FORMAT(1X,1HJ)
40 FORMAT(1X,I2,3X,1P7E9.2)
50 FORMAT(1X,1H )
51 FORMAT(1X,' I =',2X,7(I4,5X))
52 FORMAT(1X,' X =',1P7E9.2)
53 FORMAT(1X,'TH =',1P7E9.2)
54 FORMAT(1X,'J =',2X,7(I4,5X))
55 FORMAT(1X,'Y =',1P7E9.2)
************************************************************************ ENTRY UGRID
XU(2)=0.
DX=XL/FLOAT(L1-2)
DO 1 I=3,L1
1 XU(I)=XU(I-1)+DX
YV(2)=0.
DY=YL/FLOAT(M1-2)
DO 2 J=3,M1
2 YV(J)=YV(J-1)+DY
RETURN
************************************************************************ ENTRY PRINT
IF(.NOT. LPRINT(3)) GO TO 80
*---CALCULATE THE STREAM FUNTION----------------------------------------
F(2,2,3)=0.
DO 82 I=2,L1
IF(I .NE. 2) F(I,2,3)=F(I-1,2,3)-RHO(I-1,1)*V(I-1,2)
& *R(1)*XCV(I-1)
DO 82 J=3,M1
RHOM=FX(I)*RHO(I,J-1)+FXM(I)*RHO(I-1,J-1)
82 F(I,J,3)=F(I,J-1,3)+RHOM*U(I,J-1)*ARX(J-1)
80 CONTINUE
*
IF( .NOT. LPRINT(NP)) GO TO 90
*
*---CONSTRUCT BOUNDARY PRESSURES BY EXTRAPOLATION
DO 91 J=2,M2
P(1,J)=(P(2,J)*XCVS(3)-P(3,J)*XDIF(2))/XDIF(3)
91 P(L1,J)=(P(L2,J)*XCVS(L2)-P(L3,J)*XDIF(L1))/XDIF(L2)
DO 92 I=2,L2
P(I,1)=(P(I,2)*YCVS(3)-P(I,3)*YDIF(2))/YDIF(3)
92 P(I,M1)=(P(I,M2)*YCVS(M2)-P(I,M3)*YDIF(M1))/YDIF(M2)
P(1,1)=P(2,1)+P(1,2)-P(2,2)
P(L1,1)=P(L2,1)+P(L1,2)-P(L2,2)
P(1,M1)=P(2,M1)+P(1,M2)-P(2,M2)
P(L1,M1)=P(L2,M1)+P(L1,M2)-P(L2,M2)
PREF=P(IPREF,JPREF)
DO 93 J=1,M1
DO 93 I=1,L1
93 P(I,J)=P(I,J)-PREF
90 CONTINUE
*
IF(TIME.GT.0.5*DT) GOTO 320
WRITE (8,50)
IEND=0
301 IF(IEND .EQ. L1) GO TO 310
IBEG=IEND+1
IEND=IEND+7
IEND=MIN0(IEND,L1)
WRITE (8,50)
WRITE(8,51) (I,I=IBEG,IEND)
IF(MODE .EQ. 3) GO TO 302
WRITE(8,52) (X(I),I=IBEG,IEND)
GO TO 303
302 WRITE (8,53) (X(I),I=IBEG,IEND)
303 GO TO 301
310 JEND=0
WRITE(8,50)
311 IF(JEND .EQ. M1) GO TO 320
JBEG=JEND+1
JEND=JEND+7
JEND=MIN0(JEND,M1)
WRITE(8,50)
WRITE(8,54) (J,J=JBEG,JEND)
WRITE(8,55) (Y(J),J=JBEG,JEND)
GO TO 311
320 CONTINUE
*
DO 999 N=1,NGAM
NF=N
IF(.NOT. LPRINT(NF)) GO TO 999
WRITE(8,50)
WRITE(8,10) TITLE(NF)
IFST=1
JFST=1
IF(NF .EQ. 1 .OR. NF .EQ. 3) IFST=2
IF(NF .EQ. 2 .OR. NF .EQ. 3) JFST=2
IBEG=IFST-7
110 CONTINUE
IBEG=IBEG+7
IEND=IBEG+6
IEND=MIN0(IEND,L1)
WRITE(8,50)
WRITE(8,20) (I,I=IBEG,IEND)
WRITE(8,30)
JFL=JFST+M1
DO 115 JJ=JFST,M1
J=JFL-JJ
WRITE(8,40) J,(F(I,J,NF),I=IBEG,IEND) 115 CONTINUE
IF(IEND .LT. L1) GO TO 110
999 CONTINUE
RETURN
END
FORTRAN程序设计复习题及答案
FORTRAN程序设计复习题 一、选择题 B (1)下列各FORTRAN表达式中合法的是 A) S+T*2P >= B) .NOT. (A*B+C) C) A2+B2/(C+D) <= D) (A+B).NOT．A*B．GT．(.NOT.只跟一个表达式) C (2)数学式(3/5)ex+y的FORTRAN表达式是 A) 3*EXP(X+Y)/5 B) 3*E* *(X+Y)/ C) (3/5)*EXP(X+Y)D) EXP(X+Y) D (3)下列FORTRAN77表达式中不合法的是 A) A．GT．B．EQV．C．GT．D B) A．AND．B．AND．C．AND．D C) .NOT．(X．LE．D) A．LT．B．LT．C．LT．D D(4)下列叙述中不正确的是 A) FORTRAN子程序可以单独编译 B) 对一个FORTRAN源程序进行编译和连接无误后可生成可执行文件 C) 即使编译和连接都正确无误，FORTRAN程序运行时仍可能出错 D) FORTRAN连接的主要任务是把函数库中的函数翻译成机器指令(正确描述：主要任务为连接目标文件) B (5)在下列FORTRAN77运算符中，优先级最高的是 A) .AND. B) .NOT. C) .OR. D) .EQ. B (6)FORTRAN表达式"6/5+9/2**3/2"的值为 A) 33 B) 1 C) 5 D) 3 A (7)下列FORTRAN77表达式中，合法的是： A) .AND.. B) 10.0 C) D) 提示：A）相当于 .AND.（.NOT.（）） D (8)关于编译一个FORTRAN源程序文件，下列说法中错误的是 A) 允许编译只有一个主程序而没有子程序的源文件 B) 允许编译有多个子程序的源文件 C) 允许编译只有一个子程序而没有主程序的源文件 D) 允许编译有多个主程序的源文件 C (9)在FORTRAN77源程序中，续行标志符必须放在 A) 第1列 B) 第1-6列C) 第6列D) 第5列 D (10)下列关于"SUBROUTIN E MAP(X，Y)"语句行的叙述中，不正确的是 A) 这是子程序的第一个语句 B) 字符串"MAP"是子程序名 C) 变量X是子程序的形参D) 子程序执行后，MAP将返回整型数据 提示：子程序无返回值，自定义函数才有） A (11)FORTRAN表达式"2/4+"的值是 A) B) 1 C) D) 0 提示：2/4默认等于整型，=》 D (12)FORTRAN表达式"MOD，"的值是 A) B)0.0 C) D) A (13下列FORTRAN运算符中，优先级最低的是 A）逻辑运算符.AND. B）算术运算符*
(完整)Fortran经典编程语言笔记(你值得拥有)
FORTRAN笔记 2014.10.07 目录 第七讲_FORTRAN的基本知识.ppt (2) FORTRAN语言程序设计初步 (2) FORTRAN源程序的书写格式（以77为例） (2) 变量 (2) 变量类型 (2) 算术运算符和运算优先级 (3) 赋值语句 (3) 参数语句（PARAMETER语句） (3) END语句 (3) PAUSE语句 (3) 逻辑运算和选择结构 (4) 关系表达式 (4) FORTRAN中数组的定义及使用 (4) 其他 (5) 1. fortran语言定义CHARACTER*6 TTL(14,3),CNAM(400)是什么意思? (5) 2. fortran里character*10 是什么意思 (5) 3. Fortran中kind是什么函数？ (5)
第七讲_FORTRAN的基本知识.ppt FORTRAN语言程序设计初步 FORTRAN是Formula Translation的缩写，意为“公式翻译”，它是为科学、工程问题或企事业管理中的那些能够用 数学公式表达的问题而设计的，其数值计算的功能较强。 常用的是FORTRAN77和FORTRAN90两种标准。 1、一个程序由若干个程序单位组成。主程序和每一个子程序分别是一个独立的程序单位。 2、每一个程序单位都是以“END”结束的。 3、一个程序单位包括若干行。 1）语句行。由一个FORTRAN语句组成。 2）非语句行，即注释行。 4、FORTRAN程序中的语句可以没有标号，也可以有标号，根据需要而定。标号的作用是标志一个语句以便被其 他语句引用。 5、一个程序单位中各类语句的位置是有一定规定的。 6、FORTRAN源程序必须按一定的格式书写。 FORTRAN源程序的书写格式（以77为例） 每一行有80列，分别如下： 1、第1-5列为标号区。一行中第一列为“C”或“*”，该行即被认为是注释行。 2、第6列为“续行标志区”，如果在一行的第6列上写一个非空格和非零的字符，则该行作为其上一行的续行。 3、第7-72列为语句区。 4、第73-80列，注释区。 变量 变量名：一个变量需要用一个名字（变量名）来识别。在同一个程序单位中不能用同一个变量名代表两个不同的变 量。 FORTRAN的变量名按以下规则选定： 1）第一个字符必须是字母，即变量名必须以字母开头； 2）在一个字母后面可以跟1-5为数字或字母。 如果选定的变量名超过6个字符，则只有前面6个字符有效。 注：在变量名中大写与小写字母是等价的。 变量类型 整型变量Integer、实型变量Real、双精度变量Double Precision、复型变量Complex、逻辑型变量Logical和字符型变量Character。 1、隐含约定（I-N规则） FORTRAN规定：在程序中的变量名，凡以字母I，J，K，L，M，N六个字母开头的，即认为该变量为整型变量。 在程序中，凡是变量名以字母I,J,K,L,M,N,i,j,k,l,m,n开头的变量被默认为整型变量，以其他字母开头的变量被 默认为实型变量。 2、用类型说明语句确定变量类型 1）INTEGER语句（整型说明语句） 2）REAL语句（实型说明语句） 3）DOUBLE PRECISION语句（双精度说明语句） 4）COMPLEX语句（复型说明语句） 5）LOGICAL语句（逻辑型说明语句）
fortran语法手册
1 FORTRAN77四则运算符 + - * / ** (其中**表示乘方) 在表达式中按优先级次序由低到高为：+或-→*或/→**→函数→() 2 FORTRAN77变量类型 2.1 隐含约定：I-N规则 凡是以字母I，J，K，L，M，N六个字母开头的，即认为是整型变量，其它为实型变量。 如IMPLICIT REAL (I,J) 三种定义的优先级别由低到高顺序为：I-N规则→IMPLICIT语句→类型说明语句，因此，在程序中IMPLICIT语句应放在类型说明语句之前。 2.4 数组的说明与使用 使用I-N规则时用DIMENSION说明数组，也可在定义变量类型同时说明数组，说明格式为：数组名(下标下界,下标上界），也可省略下标下界，此时默认为1，例： DIMENSION IA(0:9),ND(80:99),W(3,2),NUM(-1:0),A(0:2,0:1,0:3) REAL IA(10),ND(80:99)使用隐含DO循环进行数组输入输出操作：例如WRITE(*,10) ('I=',I,'A=',A(I),I=1,10,2) 10FORMAT(1X,5(A2,I2,1X,A2,I4)) 2.5 使用DATA语句给数组赋初值 变量表中可出现变量名,数组名,数组元素名,隐含DO循环，但不许出现任何形式的表达式：例如 DATA A,B,C/-1.0,-1.0,-1.0/ DATA A/-1.0/,B/-1.0/,C/-1.0/ DATA A,B,C/3*-1.0/CHARACTER*6 CHN(10)
DATA CHN/10*' '/INTEGER NUM(1000) DATA (NUM(I),I=1,500)/500*0/,(NUM(I),I=501,1000)/500*1/ 3 FORTRAN77程序书写规则 程序中的变量名，不分大小写； 变量名称是以字母开头再加上1到5位字母或数字构成，即变更名字串中只有前6位有效； 一行只能写一个语句； 程序的第一个语句固定为PROGRAM 程序名称字符串 某行的第１个字符至第５个字符位为标号区，只能书写语句标号或空着或注释内容； 某行的第１个字符为Ｃ或＊号时，则表示该行为注释行，其后面的内容为注释内容； 某行的第６个字符位为非空格和非０字符时，则该行为上一行的续行，一个语句最多可有19个续行； 某行的第７至７２字符位为语句区，语句区内可以任加空格以求美观； 某行的第７３至８０字符位为注释区，８０字符位以后不能有内容。 4 FORTRAN77关系运算符 .GT. 大于 .GE. 天于或等于 .LT. 小于 .LE. 小于或等于 .EQ. 等于 .NE. 不等于 .AND. 逻辑与 .OR. 逻辑或 .NOT. 逻辑非 .EQV. 逻辑等 .NEQV. 逻辑不等 运算符优先级由高到低顺序为:()→**→*或/→+或-→.GT.或.GE.或.LT. 或.LE.或.EQ.或.NE.→.NOT.→.AND.→.OR.→.EQV.或.NEQV 5 FORTRAN77语句
FORTRAN 95 语法速查
FORTRAN 95 语法速查 ----------白云、李学哲、陈国新、贾波编著《FORTRAN95程序设计》读书笔记 目录：一、应用程序的创建与运行/FORTRAN 95所用的字符/ 变量类型及其声明，常量声明/表达式与运算符 二、输入与输出：表控、有格式 三、选择语句与结构：IF语句、CASE结构 四、DO循环结构 五、数组：数组的声明，数组的引用，数组的算术运算，数组的输入、输出，给数组赋初值， 动态数组，WHERE、FORALL语句 六、子程序：语句函数，内部子程序，调用子程序时的虚实结合：形参为数组、非定界数组、子 程序名、星号，递归子程序，外部子程序，纯子程序，逐元子程序 七、派生数据类型与结构体 八、指针与动态链表 九、文件：存取方式，基本操作语句，各类文件的读写操作 十、接口、模块 十一、公用区、存储关联、数据块子程序 十二、绘图：坐标系、设置图形颜色、创建图形程序/ 常用过程：设置线型、绘一像素点、设置当前位置、绘直线、绘弧线、绘矩形、绘多边形、绘制扇形（圆、椭圆）/ 文字信息的显示 附/录：标准函数与标准子例行程序 一、基础部份 1-1 FORTRAN 95 应用程序的创建与运行 创建或运行FORTRAN 95程序必须在Microsoft Developer Studio平台上进行。尽管程序文本及相关文件的编辑可以在任一文本编辑器上进行，然后再拷到Studio的文档窗口中。但最好还是一开始就进入Studio环境。创建FORTRAN 95 程序的步骤大致如下： 1）启动Microsoft Developer Studio 可以通过不同方式运行dfdev.exe程序以启动Microsoft Developer Studio [开始] \ Compaq Visual Fortran 6 \ Developer Studio \ dfdev.exe：或 ……\CVF66 \https://www.360docs.net/doc/5f1963812.html,\MSDEV98\dfdev.exe Microsoft Developer Studio的界面如下图所示： 文档窗口 工作空间窗口 输出窗口
Fortran常用函数
1、RANDOM_NUMBER Syntax ['sint?ks] n. 语法 CALL RANDOM_NUMBER (harvest结果) Intrinsic Subroutine（固有子程序）：Returns a pseudorandom number greater than or equal to zero and less than one from the uniform distribution. 返回大于或等于0且小于1，服从均匀分布的随机数 2、RNNOA/ DRNNOA （Single/Double precision） Generate pseudorandom numbers from a standard normal distribution using an acceptance/rejection method. 产生服从标准正态分布的随机数 Usage（用法） CALL RNNOA (NR, R) Arguments（参数） NR— Number of random numbers to generate. (Input) 要产生随机数的个数 R— Vector of length NR containing the random standard normal deviates. (Output) 输出长度为NR，随机正态分布的向量 Comments（注解） The routine RNSET can be used to initialize the seed of the random number generator. The routine RNOPT can be used to select the form of the generator. 程序RNSET可以用来初始化随机数发生器的种子 Example In this example, RNNOA is used to generate five pseudorandom deviates from a standard normal distribution. INTEGER ISEED, NOUT, NR REAL R(5) EXTERNAL RNNOA, RNSET, UMACH C CALL UMACH (2, NOUT) NR = 5 ISEED = 123457 CALL RNSET (ISEED) CALL RNNOA (NR, R) WRITE (NOUT,99999) R 99999 FORMAT (' Standard normal random deviates: ', 5F8.4) END Output Standard normal random deviates: 2.0516 1.0833 0.0826 1.2777 -1.2260
计算机程序设计语言(FORTRAN语言)
计算机程序设计语言(FORTRAN语言) (总分：36.00，做题时间：90分钟) 一、 (总题数：36，分数：36.00) 1.编译程序能将高级语言编写的源程序转换成( )。 A．解释程序 B．汇编程序 C．映象程序 D．目标程序 （分数：1.00） A. B. C. D. √ 解析： 2.一个完整的FORTRAN源程序( )。 A．至少包括一个主程序 B．至少包括一个主程序和一个子程序 C．由一个主程序与一个以上的子程序组成 D．由一个主程序与一个子程序组成 （分数：1.00） A. √ B. C. D. 解析： 3.语句函数定义语句在程序内合法的位置是( )。 A．在程序块开头语句之后，END语句之前 B．在程序块开头语句之后，可执行语句之前 C．在说明语句之后，END语句之前 D．在说明语句之后，可执行语句之前 （分数：1.00） A. B. C. D. √ 解析： 4.下列关于函数子程序虚实参数的错误说法是( )。 A．可以没有形参数 B．虚实结合的数组长度可以不同 C．实参表与虚参表类型可以不同 D．函数名可以作为虚参
（分数：1.00） A. B. C. √ D. 解析： 5.下列叙述中正确的是( )。 A．FORTRAN程序块中，无名公用语句只能有一个B．FORTRAN子程序中，至少应有一个RETURN语句C．FORTRAN程序块中，最后一行必须是END语句D．FORTRAN程序块中，必须有变量说明语句 （分数：1.00） A. B. C. √ D. 解析： 6.运行下面的程序时得不到所需的结果，其主要原因是( )。INTEGER X(11) DATA X/9，8，7，6，5，4，3，2，1，0，-1/ DO 10 1=1，X(1) ，-1 WRITE(*，*)1.0/SQRT(25.0-REAL(X(1) )* * 2) 10 CONTINUE END A．没有给X(11) 赋初值 B．发生除以零的情况 C．发生负数开平方的情况 D．循环参数设置错误 （分数：1.00） A. B. C. D. √ 解析： 7.下列数据中，不符合FORTRAN常量表示法的是( )。 A．-25.6 B．2.758D3 C．'FOOT"=' D．TRUE （分数：1.00） A. B. C. D. √ 解析：
fortran语言语法
FORTRAN是世界上最早出现的高级编程语言，是工程界最常用的编程语言，它在科学计算中（如航空航天、地质勘探、天气预报和建筑工程等领域）发挥着极其重要的作用。经过40多年的发展，伴随着FORTRAN语言多次版本的更新及相应开发系统的出现，其功能不断完善，最新版本的开发系统几乎具备了VC、VB的所有特点，如图形界面编程、数据库等。目前，工科院校开设的计算机编程语言课首选仍然是FORTRAN :< 说实话，从科技发展的趋势来说这不是好事。您可以设想一下，如果需要用鹅毛笔抄写大量的古籍是什么感受！ 强烈建议阅读《发掘C#特性赋予科学计算项目以威力》 1 FORTRAN77四则运算符 + - * / ** (其中**表示乘方) 在表达式中按优先级次序由低到高为： +或-→*或/→**→函数→() 2 FORTRAN77变量类型 隐含约定：I-N规则 凡是以字母I，J，K，L，M，N六个字母开头的，即认为是整型变量，其它为实型变量。 用类型说明语句确定变量类型：可以改变I-N规则
用IMPLICIT语句将某一字母开头的全部变量指定为所需类型 如IMPLICIT REAL (I,J) 三种定义的优先级别由低到高顺序为：I-N规则→IMPLICIT语句→类型说明语句，因此，在程序中IMPLICIT语句应放在类型说明语句之前。 数组的说明与使用 使用I-N规则时用DIMENSION说明数组，也可在定义变量类型同时说明数组，说明格式为：数组名(下标下界,下标上界），也可省略下标下界，此时默认为1，例：DIMENSION IA(0:9),ND(80:99),W(3,2),NUM(-1:0),A(0:2,0:1,0:3)
FORTRAN知识点总结
F O R T R A N 第2章FORTRAN90基础知识： 程序单元的概念: fortran90程序是一种分块形式的程序，整个程序由若干程序单元块组成。每个程序只有一个主程序单元。各单元体的程序体形式上相同。 程序单元可以是主程序、子程序（外部过程或内部过程）、模块MODULE （供其他程序单元引用即把该程序单元内的全部语句复制到程序单元中）或块数据程序单元BLOCK 。 语言元素：指在程序设计中用到的基本成分，如字符集、常量、变量、记号（标号、关键字、名字、常数、运算符和定界符）以及其他的基本结构等。 字符集：英文字母、阿拉伯数字、下划线、21个特殊字符（$和？没有规定用法）。 数据结构： 整型INTEGER （34-2下划线后面是种别参数），n 位字长的计算机的数据表示范围一般为12~211-+---n n ，种别参数由内在询问函数KIND 送回，种别值提供的最小范围由内在函数SELECTED-INT-KIND 送回，表示十进制幂的范围由内在函数RANGE 送回； 实型REAL ，小数形式和指数形式；复型COMPLEX （种别类
型参数值取实部与虚部中较大者）； 字符型CHARACTER，由一对单撇号或双撇号之间的字符序列组成； 逻辑型LOGICAL。 派生数据类型TYPE； 数组INTEGER,DIMENSION(1,50)::A，可直接对数组元素进行运算如3*A,SQRT(A)； 字符子串，在字符串CHARACTER(LEN=80)::ROW中，ROW(1:3)就表示字符串ROW中第1到第3个元素组成的子串。 变量名的命名规则：不能超过31个字符；组成成分是字母、数字、下划线；第一个字符必须是字母。 第3章基本语句： 类型说明语句：类型说明（种别说明），属性说明：：变量名表 尽量避免把两个实数作相等或不相等的比较。淘汰隐式说明IMPLICIT NONE 种别说明：种别参数即对可移植数据精度和范围进行选择的机制 KIND(X) 返回变元X的种别参数值 SELECTED-REAL-KIND(n,m) 产生一个种别值，它表示某一精度和范围。N指十进制有效位数，m指明值范围内以10为底的幂次。
fortran心得
Read 的规则： 按行读取，每次读一行，读完后光标自动跳到下一行的开头，空格和逗号代表结束（所以空格和逗号也是读取的一部分的话，需要使用“输入输出格式”） 如果想要将一行数据读入数组，代码为： Read(10,*) s(:,:,:) 不用规定输入输出格式，因为会根据s(:,:,:)确定需要读入的数字的个数，然后fortran会按部就班的读取，甚至文件中当前这一行的数字个数不足以填满s(:,:,:)的时候，read会自动跳到下一行继续搜索数字，直到填满s(:,:,:)为止。 但是需要注意给数组赋值的顺序：read会把它搜索到的第一个数字给s(1,1,1),第二个给s(2,1,1),第三个给s(3,1,1)… 程序9 1: 将read(unit=field,fmt="(A79)",iostat=status)buffer 中的A79改为A2，结果只输出每行的前两个字符，说明read是按整行整行读取的。 中间空了几行之后，空行之后的内容还是能被读取和输出，这说明，空行和空白是不一样的：空行也算是一种文本内容，因此不会终止读取，而空白意味着结束。 !读取文件 program main implicit none character(len=79)::filename="number.txt",buffer integer,parameter::field=10 integer::status=0 logical alive inquire(file=filename,exist=alive) if(alive)then open(unit=field,file=filename) do while(.true.) read(unit=field,fmt="(A79)",iostat=status)buffer if(status/=0)exit write(*,"(A79)")buffer end do else write(*,*)filename,"does't exist." end if pause stop end program main ============================================= 附number.txt =============================== 1234555666
fortran语法手册
1F O R T R A N77四则运算符+ - */ ** (其中**表示乘方) 在表达式中按优先级次序由低到高为：+或-→*或/→**→函数→() 2 FORTRAN77变量类型 隐含约定：I-N规则 凡是以字母I，J，K，L，M，N六个字母开头的，即认为是整型变量，其它为实型变量。 如IMPLICIT REAL (I,J) 三种定义的优先级别由低到高顺序为：I-N规则→IMPLICIT语句→类型说明语句，因此，在程序中IMPLICIT语句应放在类型说明语句之前。 数组的说明与使用 使用I-N规则时用DIMENSION说明数组，也可在定义变量类型同时说明数组，说明格式为：数组名(下标下界,下标上界），也可省略下标下界，此时默认为1，例：DIMENSION IA(0:9),ND(80:99),W(3,2),NUM(-1:0),A(0:2,0:1,0:3) REAL IA(10),ND(80:99)使用隐含DO循环进行数组输入输出操作：例如 WRITE(*,10) ('I=',I,'A=',A(I),I=1,10,2) 10FORMAT(1X,5(A2,I2,1X,A2,I4)) 使用DATA语句给数组赋初值 变量表中可出现变量名,数组名,数组元素名,隐含DO循环，但不许出现任何形式的表达式：例如 DATA A,B,C/,, DATA A/,B/,C/ DATA A,B,C/3*CHARACTER*6 CHN(10) DATA CHN/10*''/INTEGER NUM(1000) DATA (NUM(I),I=1,500)/500*0/,(NUM(I),I=501,1000)/500*1/ 3 FORTRAN77程序书写规则
FORTRAN 90 程序编程规范
FORTRAN 90 程序编程规范 Fortran 90 编程规范，使程序代码高度组织化，更加易读、易懂、易于维护，程序更加高效。使编出的程序更易懂、易于维护。 1 语言选择 数值预报创新系统软件开发应避免使用Fortran77 的某些过时特征以Fortran 90不一致的特征。选择Fortran 90 作为开发语言，并采用Fortran 90 的新功能，如动态内存的分配(dynamic memory allocation)、递归（recursion ）, 模块(modules)、POINTER 、长变量名、自由格式等。 Fortran 77其中某些只是一些冗余的功能，这些功能已经过时，另外，还有一些在Fortran90 中被证明是不好的用法，建议不要使用。 2 Fortran 90 的新特性 2.1.1 建议使用的Fortran 90 新特性 建议使用Fortran 90 提供的模块（module ），并用Use ONLY 指定module 中哪些变量或派生类型定义可用于调用程序。 尽量使用数组下标三元组，这样可优化并减少所需的代码行数。为提高可读性，要在括号内表明数组的维数，例如： 1dArrayA(:) = 1dArrayB(:) + 1dArrayC(:) 2dArray(: , :) = scalar * Another2dArray(: , :) 当访问数组的子集时，例如在有限差分等式中，可以通过使用下标三元组实现。例如：2dArray(: , 2:len2) = scalar *（ & Another2dArray(:, 1:len2 -1) & - Another2dArray(:, 2:len2) & ) 对程序单元（program units ）命名，并使用End program ，End subroutine ，End interface ，End module 等结构再次指定“program unit ”的名称。 在逻辑表达式中使用>、 >=、 ==、 <、 <=、 /=，它们分别代 替.gt.、.ge.、.eq.、.lt.、.le.、.ne. 。新的表示方法更接近标准的数学符号 在变量定义中始终使用“：：”；始终用“DIMENSION ”定义数组形状；始终用（len=）的语法格式声明字符变量的长度。
fortran语言内部函数
附录 FORTRAN 90标准函数 符号约定： ●I代表整型;R代表实型;C代表复型;CH代表字符型;S代表字符串;L代表逻辑型;A代表数组;P代表指针;T代表派生类型;AT为任意类型。 ●s:P表示s类型为P类型(任意kind值)。s:P(k)表示s类型为P类型(kind值=k)。 ●[…]表示可选参数。 ●*表示常用函数。 表1 数值和类型转换函数 函数名说明 ABS(x)*求x的绝对值∣x∣。x:I、R,结果类型同x; x:C,结果:R AIMAG(x)求x的实部。x:C,结果:R AINT(x[,kind])*对x取整,并转换为实数(kind)。x:R, kind:I,结果:R(kind) AMAX0(x1,x2,x3,…)*求x1,x2,x3,…中最大值。x I:I,结果:R AMIN0(x1,x2,x3,…)*求x1,x2,x3,…中最小值。x I:I,结果:R ANINT(x[,kind])*对x四舍五入取整,并转换为实数(kind)。x:R, kind:I,结果:R(kind) CEILING(x)*求大于等于x的最小整数。x:R,结果:I CMPLX(x[,y][,kind]))将参数转换为x、(x,0.0)或(x,y)。x:I、R、C, y:I、R,kind:I,结果:C(kind) CONJG(x)求x的共轭复数。x:C,结果:C DBLE(x)*将x转换为双精度实数。x:I、R、C,结果:R(8) DCMPLX(x[,y])将参数转换为x、(x,0.0)或(x,y)。x:I、R、C, y:I、R,结果:C(8) DFLOAT(x)将x转换为双精度实数。x:I,结果:R(8) DIM(x,y)*求x-y和0中最大值,即MAX(x-y,0)。x:I、R, y的类型同x,结果类型同x DPROD(x,y)求x和y的乘积,并转换为双精度实数。x:R, y:R,结果:R(8)
fortran用法总结
我的Fortran基本用法小结 周日, 10/14/2007 - 21:00 — gator 一、说明 二、概述 三、数据类型及基本输入输出 四、流程控制 五、循环 六、数组 七、函数 八、文件 一、说明 本文多数内容是我读彭国伦《Fortran 95 程序设计》的笔记。只读到第九章，主要是3~9 章，都是最基本的用法（原书共16章）。这里主要摘录了我看书过程中总结的一些Fortran和C不同的地方，主要是语法方面。希望这份笔记能够给学过C但没有接触过Fortran的同学带去一些帮助。要想得更清楚些，推荐看一下原书，觉得作者真的写得很好，很清楚；如果有C语言的基础， 看完前九应该很快的，花一两天就行了。觉得如果耐心看完本文，基本功能应该也可以顺利用起 来了。外，由于我之前没有用过Fortran，这次为了赶文档看书又看得很粗浅，大多数东西看过 之后都没得及仔细想，只是按着作者的意思去理解。所以这份笔记还处于纸上谈兵的层次。如果 有不妥的方，希望大家指正。谢谢！ 文中蓝色的部分是程序代码，!后面的内容为注释。 二、概述 1、名词解释 Fortran=For mula Tran slator/Translation 一看就知道有什么特色了：可以把接近数学语言的文本翻译成机械语言。的确，从一开始 ，IBM设计的时候就是为了方便数值计算和科学数据处理。设计强大的数组操作就是为了实现这一 目标。ortran奠定了高级语言发展的基础。现在Fortran在科研和机械方面应用很广。 2、Fortran的主要版本及差别 按其发展历史，Fortran编译器的版本其实很多。现在在广泛使用的是Fortran 77和Fortr an90。ortran 90在Fortran 77基础上添加了不少使用的功能，并且改良了77编程的版面格式， 所以编程时推荐使用90。鉴于很多现成的程序只有77版本，有必要知道77的一些基本常识，至少保证能够看77程序。以下是77和90的一些格式上的区别。 Fortran 77：固定格式（fixed format），程序代码扩展名：.f或.for （1）若某行以C,c或*开头，则该行被当成注释； （2）每行前六个字符不能写程序代码，可空着，或者1~5字符以数字表明行代码（用作格 式化输入出等）；7~72为程序代码编写区；73往后被忽略； （3）太长的话可以续行，所续行的第六个字符必须是"0"以外的任何字符。 Fortran 90：自由格式（free format），扩展名：.f90 （1）以"!"引导注释； （2）每行可132字符，行代码放在每行最前面； （3）以&续行，放在该行末或下行初。 以下都是讨论Fortran 90。 3、Fortran的一些特点，和C的一些不同 其实很多，在下面涉及具体方面时可以看到。这里只是大致提一些。
Fortran基本用法小结档
Fortran基本用法小结 目录： 一、说明 二、概述 三、数据类型及基本输入输出 四、流程控制 五、循环 六、数组 七、函数 八、文件 一、说明 本文多数内容是我读彭国伦《Fortran 95 程序设计》的笔记。只读到第九章，主要是3~9章，都是些最基本的用法（原书共16章）。这里主要摘录了我看书过程中总结的一些Fortran和C不同的地方，主要是语法方面。希望这份笔记能够给学过C但没有接触过Fortran的同学带去一些帮助。要想弄得更清楚些，推荐看一下原书，觉得作者真的写得很好，很清楚；如果有C语言的基础，看完前九章应该很快的，花一两天就行了。觉得如果耐心看完本文，基本功能应该也可以顺利用起来了。 另外，由于我之前没有用过Fortran，这次为了赶文档看书又看得很粗浅，大多数东西看过之后都没来得及仔细想，只是按着作者的意思去理解。所以这份笔记还处于纸上谈兵的层次。如果有不妥的地方，希望大家指正。谢谢！ 文中蓝色的部分是程序代码，!后面的内容为注释。 二、概述 1、名词解释 Fortran=Formula Translator/Translation 一看就知道有什么特色了：可以把接近数学语言的文本翻译成机械语言。的确，从一开始，IBM设计它的时候就是为了方便数值计算和科学数据处理。设计强大的数组操作就是为了实现这一目标。Fortran奠定了高级语言发展的基础。现在Fortran在科研和机械方面应用很广。 2、Fortran的主要版本及差别 按其发展历史，Fortran编译器的版本其实很多。现在在广泛使用的是Fortran 77和Fortran90。Fortran 90在Fortran 77基础上添加了不少使用的功能，并且改良了77编程的版面格式，所以编程时推荐使用90。鉴于很多现成的程序只有77版本，有必要知道77的一些基本常识，至少保证能够看懂77程序。以下是77和90的一些格式上的区别。
FORTRAN学习中的一些小心得
FORTRAN 心得 第一部分：一些小心得 1 Fortran不区分大小写 2 Fortran有5种基本数据类型，integer，real, character, logical, complex 3 fortran fixed format格式中的变量赋初值一般用DATA，因为它不能用:: 4 real(kind=8) a这种格式只使用于Fortran90，Fortran77中要使用real*8或real(8) 5 FORTRAN中FREE与FIXED两种格式do循环的区别： Fortran 95使用end do来结束循环。 ： Fortran 77使用DO循环要麻烦一点，它不使用END DO来结束循环，而是使用行号来结束循环，程序代码要在DO的后面写清楚这个循环到哪一行程序代码结束。 Fortran 77中，经常会使用CONTINUE这个命令来结束循环。因为CONTINUE这个命令没有实际的用途，刚好可以拿来做封装使用。 6 循环的流程控制： 循环中的cycle命令相当于c++里的continue命令，用于结束一次循环 循环中的exit命令好比c里面的break，用于结束循环 7 不使用do循环，单纯用GOTO语句也能设计循环程序，但不推荐使用GOTO语句 7 fortran有等价声明：即用equivalence(a,b),这样使得a,b使用同一块内存，这样可以节省内存，有时可精简代码。 、 8 fortran77中只能用单引号。（还有疑问，因为fixed format能用双引号） 9 逻辑运算符 == /= > >= < <= !Fortran90用法 .EQ. .NE. .GT. GE. .LT. .LE. !Fortran77用法 9 PAUSE,CONTINUE，STOP pause 暂停程序执行，按enter可继续执行 continue 貌似没什么用处，可用作封装程序的标志 % STOP 命令用来结束程序，要谨慎使用 10 数组元素之间要用逗号分隔，而不能像matlab一样既可以用逗号也可以用空格，fortran 的数组元素之间不能用空格。 11 数组的声明： Fortran 77中数组的声明，必须使用DIMENSION命令 Integer a; !先声明a是整型 Dimension a(10) !再声明a是大小为10的数组 Fortran 95中可以用简单的方法： `
Simple算法_fortran语言编写
Cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc Cccc This computer program was copied from the graduate student course program Cccc of the University of Minnesota. Part of it was re-formulated to meet the Cccc personal computer environment. Some inappropriate expressions were also Cccc corrected. The program is used only for teaching purpose. No part of it Cccc may be published. You may use it as a frame to re-develop your own code Cccc for research purpose. XJTU Instructor, 1995.11 **************************************************************************** *----------------------------MAIN PROGRAM----------------------------------- **************************************************************************** LOGICAL LSTOP COMMON/CNTL/LSTOP **************************************************************************** OPEN(08,FILE='teresul') CALL SETUP0 CALL GRID CALL SETUP1 CALL START 10 CALL DENSE CALL BOUND CALL OUTPUT IF(.NOT.LSTOP) GO TO 15 CLOSE(08) STOP 15 CALL SETUP2 GO TO 10 END *--------------------------------------------------------------------------- SUBROUTINE DIFLOW **************************************************************************** COMMON/COEF/FLOW,DIFF,ACOF **************************************************************************** ACOF=DIFF IF(FLOW .EQ.0.0)RETURN TEMP=DIFF-ABS(FLOW)*0.1 ACOF=0. IF(TEMP .LE. 0. ) RETURN TEMP=TEMP/DIFF ACOF=DIFF*TEMP**5 RETURN END *-------------------------------------------------------------------------- SUBROUTINE SOLVE ****************************************************************************
Fortran基本用法小结
【以下文字转载自D_Atmosphere 讨论区】 【原文由superjyq 所发表】 我的Fortran基本用法小结 高级语言和算法组heavensky 目录： 一、说明 二、概述 三、数据类型及基本输入输出 四、流程控制 五、循环 六、数组 七、函数 八、文件 一、说明 本文多数内容是我读彭国伦《Fortran 95 程序设计》的笔记。只读到第九章，主要是3~9章，都是些最基本的用法（原书共16章）。这里主要摘录了我看书过程中总结的一些Fortran和C不同的地方，主要是语法方面。希望这份笔记能够给学过C但没有接触过Fortran的同学带去一些帮助。要想弄得更清楚些，推荐看一下原书，觉得作者真的写得很好，很清楚；如果有C语言的基础，看完前九章应该很快的，花一两天就行了。觉得如果耐心看完本文，基本功能应该也可以顺利用起来了。 另外，由于我之前没有用过Fortran，这次为了赶文档看书又看得很粗浅，大多数东西看过之后都没来得及仔细想，只是按着作者的意思去理解。所以这份笔记还处于纸上谈兵的层次。如果有不妥的地方，希望大家指正。谢谢！ 文中蓝色的部分是程序代码，!后面的内容为注释。 二、概述 1、名词解释 Fortran=Formula Translator/Translation 一看就知道有什么特色了：可以把接近数学语言的文本翻译成机械语言。的确，从一开始，IBM设计它的时候就是为了方便数值计算和科学数据处理。设计强大的数组操作就是为了实现这一目标。Fortran奠定了高级语言发展的基础。现在Fortran在科研和机械方面应用很广。 2、Fortran的主要版本及差别 按其发展历史，Fortran编译器的版本其实很多。现在在广泛使用的是Fortran 77和Fortran90。Fortran 90在Fortran 77基础上添加了不少使用的功能，并且改良了77编程的版面格式，所
FORTRAN语言自学基础
《FORTRAN语言》自学提纲 第一章1 FORTRAN基础 1. 一个FORTRAN程序由一个主程序或一个主程序与若干个子程序组成。但一个完整的FORTRAN程序只能有一个主程序，主程序的第一个语句是PROGRAM语句，用以说明主程序的名称。这个语句也可以省略，省略时默认为主程序的名称为MAIN。2．FORTRAN的子程序主要有三种： ⑴函数子程序，其第一个语句为FUNCTION； ⑵子例行子程序，其第一个语句为SUBROUTINE； ⑶数据块子程序，其第一个语句为BLOCK DA TA。 主程序与各个子程序可以独立编译，最后再链接成一个可执行程序。在编写并输入一个FORTRAN程序时，既可以将主程序与各个子程序存放在一个文件中，也可以将它们分别存放在不同的文件中。但必须注意，主程序与各个子程序都是独立的程序单位，每个程序单位的最后一行必须用END语句作为结束。 在主程序中，虽然END语句还具有使程序停止运行的作用，但由于一个程序单位只能在最后一行有END语句，因此，在程序的其它位置处需要停止运行时，只能用STOP语句，不能用END语句。 同样的道理，在子程序中，虽然END语句还具有使程序流程返回到调用程序的作用，但在子程序的其它位置（不是最后一行）需要返回到调用程序时，只能用RETURN语句，不能用END语句。 3．FOPTRAN源程序的书写格式有严格的规定。 ⑴一行中第一列为“C”或“*”时，该行被认为是注释行。注释行可以写在四个区中的一个区，且注释行可以出现在程序单位的任何位置。但注释行不能有续行，需要时可以将连续若干行都定义为注释行。 ⑵FORTRAN语句部分不能占用标号区及续行标志区，只能从第七列开始。当语句太长时，可以使用续行。在继续行的标号区内必须为空白（即继续行不允许有标号），标号只能出现在起始行上。 ⑶起始行与继续行或各继续行之间的空格不起作用，因此，对于一般的语句，可以不必到72列才转为继续行，继续行也不必一定要从第7列接着写，但是，包括在引号内的字符串中的空格是有效的，因此，对于字符串要使用继续行时应特别注意，最好写到一行的72列时再转为继续行，且要从继续行的第7列接着写。 ⑷标号为无符号整数，不能出现正负号。 4．变量定义的I-N规则 与别的程序设计语言不同，FORTRAN语言中的实型变量和整型变量可以按隐含规则确定。这个隐含规则就是I-N规则。 I-N规则在一定程度上为用户提供了方便，对于常用的一些变量（如循环控制变量等）就不需要专门的类型语句进行说明，只要用合适的变量名就可以满足对变量类型的需要。但这也容易使用户疏忽了对变量类型的说明，以I-N开头的变量名实际是实型变量，但忘了用REAL 语句说明，或者以非I-N开头的变量名实际是整型变量，也忘了用INTEGER语句说明。 另外，还要提醒大家注意：由于FORTRAN语言中实型与整型变量遵循I-N规则，因此，在有关FORTRAN的练习或考核中，有时会省略对变量类型的说明，在这种情况下，应根据I-N规则来判断变量的类型。 总之，FORTRAN中的所有变量都是需要说明其类型的，而不能理解为整型与实型变量不需要进行说明。