fork download

copy

#include<stdio.h>
#include<math.h>
#define G 9.81
#define PI 3.1416
#define V  1.0
#define AL 1.0
#define AL0 1.0
#define AL00 1.0
#define ELZERO 0
#define T 0
#define TOL 0.0002
#define PSI 0.1
#define HV -7.2
#define IPR 1
#define K 0
#define KDV 3.69
#define KIT 12
#define JPR 10
#define TC 0.7
#define EM 1.2
#define DT 0.003
#define TM  1.5
#define HR 72
#define QR 0.008
#define NR 1450
#define TR 57.2
#define GDD 11.77
#define M 3
int I,J,NN,NNN,KI,II;
float B[5],R[5],F[5],N[5],N1[5],AA[5],AR[5],DH[5],ELL[5],XSIN[5],Y0[];
float C[4],X[67],RNSS[4],WWH[19],WWB[19];
float RNS[4][4],RNS1[4][4],RNS2[4][4],HHHH[4][19],BBBB[4][19];
float H[5][50],Q[5][50],HP[5][50],QP[5][50],Z[5][50];
float XX[67],WH[67],WB[67],WHH[4][19],WBB[4][19];
float DX,NL,XN,DH2,C31,KK,A1,A0,F1,DF,B1,B0,BET0,TP,NP,DDH,Q0,V000,V00,V0,TA,NM,CM,CP,F2,F2V,F2A,DAL,DV;
float BET,DDX,IBIG,ABIG,SIZE,CBIG,RATI0,RN,TI,C0,C1,C2,Y;
float EL[5]={20,42,52,0,0},XL[5]={25,26,15,0,0},NS[5]={90,260,530,950,0},A[5]={1311,1311,1311,0,0},D[5]=
 
{0.106,0.106,0.106,0,0};
    int main( )
{   DX=PI/44;
    for(I=0;I<34;I++)
   { J=34+I;XX[I]=(I-1)*DX;XX[J]=(J-1)*DX; }
 
 
 
    for(J=0;J<M;J++) 
 {    AA[J]=A[J];
      NL=XL[J]/((1+PSI)*A[J]*DT);
      N[J]=XL[J]/((1-PSI)*A[J]*DT);
       if(NL==N[J])
     N1[J]=N[J]+1;
    XN=XL[J]/(A[J]*DT);
    N[J]=XN;
    if((XN-N[J])>0.5)
       N[J]=N[J]+1;
     if(N[J]==0)
       printf("程序终止");
      N[J]=(int)(XN+0.5);
      A[J]=XL[J]/(N[J]*DT);
      N1[J]=N[J]+1;
      ELL[J]=EL[J]-ELZERO;
      NN=N1[J];
      for(I=0;I<NN;I++)
    {  if(J>1)
     { Z[J][I]=(I-1)*ELL[J]/XL[J]; XSIN[J]=ELL[J]/XL[J]; }
else { Z[J][I]=(I-1)*(ELL[J]-ELL[J-1])/N[J]+ELL[J-1];
              XSIN[J]=(ELL[J]-ELL[J-1])/XL[J];           }
        AR[J]=0.25*PI*D[J]*D[J];
        B[J]=A[J]/(G*AR[J]);
        R[J]=F[J]*XL[J]/(2*G*AR[J]*AR[J]*D[J]*N[J]);                 
        C=C+N[J]*R[J]*QR*QR;                             }
 
 
      DH2=KDV*QR*QR/(2*G*AR[1]);
      C31=GDD*NR*PI/(60*G*TR*DT);
      C=C+DH2;
      X=PI+atan(V);
      I=(int)(X/DX+1);
      KK=0;
      A1=(WH[I+1]-WH[I])/DX;
      A0=WH[I+1]-A1*I*DX;
      for(KI=1;KI<KIT;KI++)
    { F1=-ELL[M]-C*V*V+HR*(1+V*V)*(A0+A1*X);
      DF=-2*C*V+HR*(2*V*(A0+A1*X)+A1);
      V=V-F1/DF;
      X=PI+atan(V);
      II=(int)(X/DX+1);
     if(II==I)
    {  B1=(WB[I+1]-WB[I])/DX;
       B0=WB[I+1]-B1*I*DX;
       BET0=(1+V*V)*(B0+B1*X);
       TP=BET0*TR;
       NP=NR;                        }                             
      else { KK=KK+1;                }                                       
                                     }
 
 
 
 
    DDH=0;
    Q0=V*QR;
    V000=V;
    V00=V;
    V0=V;
    for(J=0;J<M;J++)
   { DH[J]=R[J]*Q0*Q0;
     DHH=DHH+DH[J]*N[J];
     H[0][0]=ELL[2]+DHH;}
 
    for(J=0;J<M;J++)
   { NN=N1[J];
     NNN=N1[J-1];
     for(I=0;I<NN;I++) 
   { Q[J][I]=Q0;
     if(J>1)
     H[J][I]=H[J-1][NNN];
else H[J][I]=H[J][I]-I*DH[J];      }               
                                   }
 
 
 
 
    TA=1;
    NM=N[M];
    BET=BET0;
    if(T>(TM+2*DT))
    printf("程序终止");
else{  T=T+DT;
       K=K+1;
       for(J=0;J<M;J++)
    {  NN=N[J];
       NNN=N[J-1];
       for(I=1;I<NN;I++)                            
    {  CM=H[J][I+1]-Q[J][I+1]*(B[J]-R[J]*fabs(Q[J][I+1]));
       CP=H[J][I-1]-Q[J][I-1]*(B[J]-R[J]*fabs(Q[J][I-1])); 
       HP[J][I]=(CM+CP)/2;
       QP[J][I]=(CP-HP[J][I])/B[J];}
 
       CM=H[J][2]-Q[J][2]*(B[J]-R[J]*fabs(Q[J][2]));
       CP=H[J][NNN]+Q[J-1][NNN]*(B[J-1]-R[J-1]*fabs(Q[J-1][NNN]));
       QP[J][1]=(CP-CM)/(B[J]+B[J-1]);
       HP[J][1]=CM+B[J]*QP[J][1];
       HP[J-1][NNN]=HP[J][1];                     
       QP[J-1][NNN]=QP[J][1];        }
                                     }
 
       CP=H[2][0]+Q[2][0]*(B[2]-R[2]*fabs(Q[2][0]);
       HP[2][1]=ELL[2];
       QP[2][1]=(CP-HP[2][1])/B[2];
 
 
       if(T>=TC)
     { TA=0;V=0;}
 else  TA=pow((1-T/Tc),Em);
 
       if(T<TC)
    {  V=V000-3*V00+3*V0;
       AL=AL000-3*AL00+3*AL0;
       K1=0;
       X=PI+antn(V/AL);
       if(X>(1.5*PI))
        X=1.5*PI;
       if(X<0)
        X=0;         }
 
       I=(int)(X/DX+1);
       CM=H[1][2]-Q[1][2]*(B[1]-R[1]*fabs(Q[1][2]));
       A1=(WH[I+1]-WH[I])/DX;
       A0=WH[I+1]-A1*I*DX;
       B1=(WH[I+1]-WH[1])/DX;
       B0=WH[I+1]-B1*I*DX;
       LAP=LAP+1;
       F2=(AL*AL+V*V)*(B0+B1*X)+BET+C31*(AL-AL0);
       F2A=2*AL*(B0+B1*X)-V*B1+C31;
       DAL=-F2/F2A;
       DV=0;
       F1=TA*TA*(-B[1]*QR*V+HR*(AL*AL+V*V)*(A0+A1*X))-DH2*fabs(V);
       F1V=TA*TA*(-B[1]*QR+HR*(2*V*(A0+A1*X)+AL*A1))-2*DH2*fabs(V);
       F1A=TA*TA*HR*(2*AL*(A0+A1*X)-V*A1));
       F2=(AL*AL+V*V)*(B0+B1*X)+BET+C31*(AL-AL0);
       F2V=2*V*(B0+B1*X)+AL*B1;
       F2A=2*AL*(B0+B1*X)-V*B1+C31;
       DAL=(F2/F2V-F1/F1V)/(F1A/F1V-F2A/F2V);
       DV=-F1/F1V-DAL*F1A/F1V;
       AL=AL+DAL;
       V=V+DV;
       X=PI+atan(V/AL);
       if(X>(1.5*PI))
       X=1.5*PI;
       if(X<0)
       X=0;
       if((fabs(DAL)+fabs(DV))<(TOL/2))
       II=X/DX+1;
       if(II==I)
       I=II;
       K1=K1+1;
       if(K1<10)****
       XXX=X-I*DX;
 
 
 
       QP[0][0]=V*QR;
       HP[0][0]=CM+B[0]*QP[0][0];
       V000=V00;
       V00=V0;
       V0=V;
       AL000=AL00;
       AL00=AL0;
       AL0=AL;
       BET=(AL*AL+V*V)*(B0+B1*X);
       TP=BET*TR;
       NP=AL*NR;
       PUMP=HR*(AL*AL+V*V)*(A0+A1*X);
 
       for(J=0;J<M;J++)
      {   NN=N1[J];
          for(I=0;I<NN;I++)
      {   Q[J][I]=QP[J][I];
          H[J][I]=HP[J][I];        }
                                   }
 
 
       for(I=0;I<4;I++)
      { RNSS[I]=pow(SSNN,(3-I));
       for(J=0;J<4;J++)
        RNS[I][J]=pow(NS[I],(3-J));   }
 
 
       for(K=0;K<19;K++)
      { for(I=0;I<4;I++)
      { C[I]=HHHH[I][K];
        D[I]=BBBB[I][K];  }
                          }
 
 
      for(I=0;I<4;I++)
      { for(J=0;J<4;J++)
      { RNS1[I][J]=RNS[I][J]; 
        RNS2[I][J]=RNS[I][J];   }
                                }
 
 
 
 
       WWH[K]=A[1]*RNSS[1]+A[2]*RNSS[2]+A[3]*RNSS[3]+A[4]*RNSS[4];
       WWH[K]=B[1]*RNSS[1]+B[2]*RNSS[2]+B[3]*RNSS[3]+B[4]*RNSS[4];
 
       DDX=3.1416/44;
       for(K=0;K<67;K++)
    {  
       X[K]=K*DDX;        }
 
       for(K=0;K<N;K++)
    {  BIG=fabs(A[K][K]);
       IBIG=K;           
       for(I=K;I<N;I++)
    {  SIZE=fabs(A[I][K]);
       if(SIZE>100)
       BIG=SIZE;
       IBIG=I;             }
                           }
 
       if(K==IBIG)
 
       for(J=K;J<N;J++)
     { ABIG=A[IBIG][J];
       A[IBIG][J]=A[K][J];
       A[K][J]=ABIG;
       CBIG=C[IBIG];
       C[IBIG]=C[K];                   
       C[K]=CBIG;          }
 
 
      for(I=0;I<N;I++)
    { RATIO=A[I][K]/A[K][K];
      for(J=K;J<N;L++)
    { A[I][J]=A[I][J]-RATIO*A[K][J];}                      
      C[I]=C[I]-RATIO*C[K];         }
 
 
      for(K=0;K<N;K++)
    { X[K]=C[K]/A[K][K];            }
 
      for(I=0;I<N;I++)
    { X[I]=0;                       }
 
      RN=N;
      H=(B-A)/RN;
      I=(X-A)/H+0.5;
 
     if(I>1)
      I=1;
 else  if(I>(N-2))
         TI=1;
 else  I=N-2;
     T=(X-A)/H-TI;
     C0=0.5*T*(T-1);
     C1=1-T*T;
     C2=0.5*T*(T+1);
     Y=C0*Y0[I]+C1*Y0[I+1]+C2*Y0[I+2];
                                     }

prog.c: In function 'main':
prog.c:72:12: error: invalid operands to binary + (have 'float *' and 'double')
         C=C+N[J]*R[J]*QR*QR;                             }
            ^
prog.c:77:10: error: invalid operands to binary + (have 'float *' and 'float')
       C=C+DH2;
          ^
prog.c:78:8: error: assignment to expression with array type
       X=PI+atan(V);
        ^
prog.c:79:16: error: invalid operands to binary / (have 'float *' and 'float')
       I=(int)(X/DX+1);
                ^
prog.c:84:19: error: invalid operands to binary * (have 'float *' and 'double')
     { F1=-ELL[M]-C*V*V+HR*(1+V*V)*(A0+A1*X);
                   ^
prog.c:84:41: error: invalid operands to binary * (have 'float' and 'float *')
     { F1=-ELL[M]-C*V*V+HR*(1+V*V)*(A0+A1*X);
                                         ^
prog.c:85:12: error: invalid operands to binary * (have 'int' and 'float *')
       DF=-2*C*V+HR*(2*V*(A0+A1*X)+A1);
            ^
prog.c:85:31: error: invalid operands to binary * (have 'float' and 'float *')
       DF=-2*C*V+HR*(2*V*(A0+A1*X)+A1);
                               ^
prog.c:86:8: error: lvalue required as left operand of assignment
       V=V-F1/DF;
        ^
prog.c:87:8: error: assignment to expression with array type
       X=PI+atan(V);
        ^
prog.c:88:17: error: invalid operands to binary / (have 'float *' and 'float')
       II=(int)(X/DX+1);
                 ^
prog.c:92:27: error: invalid operands to binary * (have 'float' and 'float *')
        BET0=(1+V*V)*(B0+B1*X);
                           ^
prog.c:108:6: error: 'DHH' undeclared (first use in this function)
      DHH=DHH+DH[J]*N[J];
      ^
prog.c:108:6: note: each undeclared identifier is reported only once for each function it appears in
prog.c:129:9: error: lvalue required as left operand of assignment
 else{  T=T+DT;
         ^
prog.c:130:9: error: lvalue required as left operand of assignment
        K=K+1;
         ^
prog.c:148:51: error: expected ')' before ';' token
        CP=H[2][0]+Q[2][0]*(B[2]-R[2]*fabs(Q[2][0]);
                                                   ^
prog.c:181:29: error: invalid operands to binary * (have 'float' and 'float *')
        F2=(AL*AL+V*V)*(B0+B1*X)+BET+C31*(AL-AL0);
                             ^
prog.c:182:22: error: invalid operands to binary * (have 'float' and 'float *')
        F2V=2*V*(B0+B1*X)+AL*B1;
                      ^
prog.c:183:23: error: invalid operands to binary * (have 'float' and 'float *')
        F2A=2*AL*(B0+B1*X)-V*B1+C31;
                       ^
prog.c:184:23: error: 'F1V' undeclared (first use in this function)
        DAL=(F2/F2V-F1/F1V)/(F1A/F1V-F2A/F2V);
                       ^
prog.c:184:29: error: 'F1A' undeclared (first use in this function)
        DAL=(F2/F2V-F1/F1V)/(F1A/F1V-F2A/F2V);
                             ^
prog.c:186:10: error: lvalue required as left operand of assignment
        AL=AL+DAL;
          ^
prog.c:187:9: error: lvalue required as left operand of assignment
        V=V+DV;
         ^
prog.c:188:9: error: assignment to expression with array type
        X=PI+atan(V/AL);
         ^
prog.c:189:12: error: invalid operands to binary > (have 'float *' and 'double')
        if(X>(1.5*PI))
            ^
prog.c:190:9: error: assignment to expression with array type
        X=1.5*PI;
         ^
prog.c:192:9: error: assignment to expression with array type
        X=0;
         ^
prog.c:194:12: error: invalid operands to binary / (have 'float *' and 'float')
        II=X/DX+1;
            ^
prog.c:197:8: error: 'K1' undeclared (first use in this function)
        K1=K1+1;
        ^
prog.c:199:8: error: 'XXX' undeclared (first use in this function)
        XXX=X-I*DX;
        ^
prog.c:199:13: error: invalid operands to binary - (have 'float *' and 'float')
        XXX=X-I*DX;
             ^
prog.c:208:8: error: 'AL000' undeclared (first use in this function)
        AL000=AL00;
        ^
prog.c:209:12: error: lvalue required as left operand of assignment
        AL00=AL0;
            ^
prog.c:210:11: error: lvalue required as left operand of assignment
        AL0=AL;
           ^
prog.c:211:30: error: invalid operands to binary * (have 'float' and 'float *')
        BET=(AL*AL+V*V)*(B0+B1*X);
                              ^
prog.c:214:8: error: 'PUMP' undeclared (first use in this function)
        PUMP=HR*(AL*AL+V*V)*(A0+A1*X);
        ^
prog.c:214:34: error: invalid operands to binary * (have 'float' and 'float *')
        PUMP=HR*(AL*AL+V*V)*(A0+A1*X);
                                  ^
prog.c:225:21: error: 'SSNN' undeclared (first use in this function)
       { RNSS[I]=pow(SSNN,(3-I));
                     ^
prog.c:230:13: error: lvalue required as left operand of assignment
        for(K=0;K<19;K++)
             ^
prog.c:230:22: error: lvalue required as increment operand
        for(K=0;K<19;K++)
                      ^
prog.c:250:13: error: lvalue required as left operand of assignment
        for(K=0;K<67;K++)
             ^
prog.c:250:22: error: lvalue required as increment operand
        for(K=0;K<67;K++)
                      ^
prog.c:254:13: error: lvalue required as left operand of assignment
        for(K=0;K<N;K++)
             ^
prog.c:254:21: error: lvalue required as increment operand
        for(K=0;K<N;K++)
                     ^
prog.c:255:8: error: 'BIG' undeclared (first use in this function)
     {  BIG=fabs(A[K][K]);
        ^
prog.c:255:21: error: subscripted value is neither array nor pointer nor vector
     {  BIG=fabs(A[K][K]);
                     ^
prog.c:257:17: warning: comparison between pointer and integer
        for(I=K;I<N;I++)
                 ^
prog.c:258:22: error: subscripted value is neither array nor pointer nor vector
     {  SIZE=fabs(A[I][K]);
                      ^
prog.c:266:17: warning: comparison between pointer and integer
        for(J=K;J<N;J++)
                 ^
prog.c:267:14: error: array subscript is not an integer
      { ABIG=A[IBIG][J];
              ^
prog.c:268:9: error: array subscript is not an integer
        A[IBIG][J]=A[K][J];
         ^
prog.c:268:23: error: subscripted value is neither array nor pointer nor vector
        A[IBIG][J]=A[K][J];
                       ^
prog.c:269:12: error: subscripted value is neither array nor pointer nor vector
        A[K][J]=ABIG;
            ^
prog.c:270:14: error: array subscript is not an integer
        CBIG=C[IBIG];
              ^
prog.c:271:9: error: array subscript is not an integer
        C[IBIG]=C[K];                   
         ^
prog.c:275:16: warning: comparison between pointer and integer
       for(I=0;I<N;I++)
                ^
prog.c:276:7: error: 'RATIO' undeclared (first use in this function)
     { RATIO=A[I][K]/A[K][K];
       ^
prog.c:276:17: error: subscripted value is neither array nor pointer nor vector
     { RATIO=A[I][K]/A[K][K];
                 ^
prog.c:276:25: error: subscripted value is neither array nor pointer nor vector
     { RATIO=A[I][K]/A[K][K];
                         ^
prog.c:277:16: warning: comparison between pointer and integer
       for(J=K;J<N;L++)
                ^
prog.c:277:19: error: 'L' undeclared (first use in this function)
       for(J=K;J<N;L++)
                   ^
prog.c:278:11: error: subscripted value is neither array nor pointer nor vector
     { A[I][J]=A[I][J]-RATIO*A[K][J];}                      
           ^
prog.c:278:19: error: subscripted value is neither array nor pointer nor vector
     { A[I][J]=A[I][J]-RATIO*A[K][J];}                      
                   ^
prog.c:278:33: error: subscripted value is neither array nor pointer nor vector
     { A[I][J]=A[I][J]-RATIO*A[K][J];}                      
                                 ^
prog.c:282:12: error: lvalue required as left operand of assignment
       for(K=0;K<N;K++)
            ^
prog.c:282:20: error: lvalue required as increment operand
       for(K=0;K<N;K++)
                    ^
prog.c:283:21: error: subscripted value is neither array nor pointer nor vector
     { X[K]=C[K]/A[K][K];            }
                     ^
prog.c:285:16: warning: comparison between pointer and integer
       for(I=0;I<N;I++)
                ^
prog.c:288:9: error: incompatible types when assigning to type 'float' from type 'float *'
       RN=N;
         ^
prog.c:289:8: error: assignment to expression with array type
       H=(B-A)/RN;
        ^
prog.c:290:14: error: invalid operands to binary / (have 'int' and 'float (*)[50]')
       I=(X-A)/H+0.5;
              ^
prog.c:294:12: warning: comparison between pointer and integer
  else  if(I>(N-2))
            ^
prog.c:296:9: warning: assignment makes integer from pointer without a cast
  else  I=N-2;
         ^
prog.c:297:13: error: invalid operands to binary / (have 'int' and 'float (*)[50]')
      T=(X-A)/H-TI;
             ^
prog.c:302:38: error: expected declaration or statement at end of input
                                      }
                                      ^
prog.c: At top level:
prog.c:30:66: warning: array 'Y0' assumed to have one element
 float B[5],R[5],F[5],N[5],N1[5],AA[5],AR[5],DH[5],ELL[5],XSIN[5],Y0[];
                                                                  ^
prog.c: In function 'main':
prog.c:302:38: warning: control reaches end of non-void function [-Wreturn-type]
                                      }
                                      ^

Standard output is empty