home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / cpmug / cpmug083.ark / SERIES%.DIF < prev    next >
Encoding:
Text File  |  1984-04-29  |  9.0 KB  |  314 lines
  1.  file SERIES%.DIF                             GAE - Feb. 1982
  2. Make a file called SERIES.DIF as follows:
  3. (1)  Start with this file (SERIES%.DIF).
  4. (2)  Insert in it (at the spot marked INSERT HERE) the two
  5.           functions FUNCTION QUERY and FUNCTION SIGN.  They
  6.           can be found at the beginning of file LIM.DIF or
  7.           file INT.DIF.
  8. (3)  Finally, delete this comment up to the line.
  9. -----------------------------------------------------------
  10.  
  11.  
  12. % File  SERIES.DIF     Infinite series.  %
  13.  
  14. % rewritten, Feb. 1982 - GAE  
  15.     DIF.ALG is required.
  16.     LOG, TRGNEG, ATRG  may be useful with this file.  %
  17.  
  18.  
  19.  
  20.          %  INSERT HERE %
  21.  
  22.  
  23.  
  24. FUNCTION FCTR1(EX1,
  25.   % Local: % PWREXPD, NUMNUM, DENDEN, DENNUM, NUMDEN, BASEXP, EXPBAS),
  26.   PWREXPD: 6,
  27.   DENNUM: NUMNUM: DENDEN: -30,
  28.   EXPBAS: BASEXP: 30,
  29.   NUMDEN: 0,
  30.   EVAL (EX1),
  31. ENDFUN $
  32.  
  33. FUNCTION LINCF(EX1, INDET),
  34.   WHEN FREE(EX1:(EVSUB(EX1,INDET,INDET+1)-EX1),INDET), EX1  EXIT,
  35. ENDFUN $
  36.  
  37. FUNCTION SIGSB2(EX1,EX2,
  38.   % Local: % EX3, EX4),
  39.   EX3: COS(EX1), EX4: SIN(EX1),
  40.   #E^(EX3*EX2)*COS(EX4*EX2),
  41. ENDFUN $
  42.  
  43. FUNCTION SIGF(EX1,EX2,EX3,
  44.   % Local: % EX4, INDET2, INDET3),
  45.   INDET2: 'INDET2, INDET3: 'INDET3,
  46.   WHEN EX3 > 0,
  47.     EX4: SIGF(INDET3,EX2,0),
  48.     LOOP
  49.       WHEN EX3 EQ EX2,  EXIT,
  50.       EX4: DIF(EX4,INDET3),
  51.       EX3: EX3+1,
  52.     ENDLOOP,
  53.     EVSUB(EX4,INDET3,EX1)  EXIT,
  54.   % EX3 EQ 0 %
  55.   EX4: 2*#PI/EX2,
  56.   WHEN MOD(EX2,2) EQ 0,
  57.     (#E^EX1+#E^-EX1+
  58.         2*SIGMA(SIGSB2(INDET2*EX4,EX1),INDET2,1,(EX2-2)/2))/EX2  EXIT,
  59.   (#E^EX1+2*SIGMA(SIGSB2(INDET2*EX4,EX1),INDET2,1,(EX2-1)/2))/EX2,
  60. ENDFUN $
  61.  
  62. FUNCTION SIGFM(EX1,EX2,EX3,
  63.   % Local: % EX4, INDET2, INDET3),
  64.   INDET2: 'INDET2, INDET3: 'INDET3,
  65.   WHEN EX3 > 0,
  66.     EX4: -SIGFM(INDET3,EX2,0),
  67.     LOOP
  68.       WHEN EX3 EQ EX2,  EXIT,
  69.       EX4: DIF(EX4,INDET3),
  70.       EX3: EX3+1,
  71.     ENDLOOP,
  72.     EVSUB(EX4,INDET3,EX1)  EXIT,
  73.   % EX3 EQ 0 %
  74.   EX4: #PI/EX2,
  75.   WHEN MOD(EX2,2) EQ 0,
  76.     SIGMA(SIGSB2((2*INDET2+1)*EX4,EX1),INDET2,0,(EX2-2)/2)/(EX2/2)  EXIT,
  77.   (#E^-EX1+2*SIGMA(SIGSB2((2*INDET2+1)*EX4,EX1),INDET2,0,(EX3-3)/2))/EX2,
  78. ENDFUN $
  79.  
  80. FUNCTION SIGSB3(EX1,EX2,EX6,
  81.   % Local: % EX3,EX4,EX5),
  82.   EX3: COS(EX2),
  83.   EX4: SIN(EX2),
  84.   EX5: COS(EX1*EX2),
  85.   EX1: 2*(COS((EX1-1)*EX2)-EX3*EX5)/EX4,
  86.   -EX5*LOG(1-2*EX3*EX6+EX6^2,#E)+EX1*ATAN((EX6-EX3)/EX4)+EX1*(#PI/2-EX2),
  87. ENDFUN $
  88.  
  89. FUNCTION SIGMA2(EX1, EX2,
  90.   % Local: % EX3, EX4, EX5, EX6),
  91.   EX4: DEN(EX1), EX5: NUM(EX1), EX6: EX2^(1/EX4),
  92.   EX3: (2/EX4)*#PI,
  93.   EX1: -LOG(1-EX6,#E),
  94.   BLOCK
  95.     WHEN EX5 EQ 0,  EXIT,
  96.     EX1: EX1+(-EX4/EX5)*EX6^EX5,
  97.   ENDBLOCK,
  98.   WHEN MOD(EX4,2) EQ 0,
  99.     EX1: EX1-(-1)^EX5*LOG(1+EX6,#E),
  100.     EX2: (EX4-2)/2,
  101.     LOOP
  102.       WHEN EX2 EQ 0,  EXIT,
  103.       EX1: EX1+SIGSB3(EX5,EX2*EX3,EX6),
  104.       EX2: EX2-1,
  105.     ENDLOOP,
  106.     EX1  EXIT,
  107.   EX2: (EX4-1)/2,
  108.   LOOP
  109.     WHEN EX2 EQ 0,  EXIT,
  110.     EX1: EX1+SIGSB3(EX5,EX2*EX3,EX6),
  111.     EX2: EX2-1,
  112.   ENDLOOP,
  113.   EX1,
  114. ENDFUN $
  115.  
  116. FUNCTION SIGMA2M(EX1,EX2,
  117.   % Local: % EX3,EX4,EX5,EX6),
  118.   EX4: DEN(EX1), EX5: NUM(EX1), EX6: EX2^(1/EX4),
  119.   EX3: #PI/EX4,
  120.   EX1: 0,
  121.   BLOCK
  122.     WHEN EX5 EQ 0,  EXIT,
  123.     EX1: (EX4/EX5)*EX6^EX5,
  124.   ENDBLOCK,
  125.   WHEN MOD(EX4,2) EQ 0,
  126.     EX2: EX4-1,
  127.     LOOP
  128.       WHEN EX2 EQ -1,  EXIT,
  129.       EX1: EX1-SIGSB3(EX5,EX2*EX3,EX6),
  130.       EX2: EX2-2,
  131.     ENDLOOP,
  132.     WHEN EX5 EQ 0, -EX1  EXIT,
  133.     EX1  EXIT,
  134.   EX1: EX1+(-1)^EX5*LOG(1+EX6,#E),
  135.   EX2: EX4-2,
  136.   LOOP
  137.     WHEN EX2 EQ -1, EXIT,
  138.     EX1: EX1-SIGSB3(EX5,EX2*EX3,EX6),
  139.     EX2: EX2-2,
  140.   ENDLOOP,
  141.   WHEN EX5 EQ 0, -EX1  EXIT,
  142.   EX1,
  143. ENDFUN $
  144.  
  145. FUNCTION SIGMA1(EX7,EX6,EX1,
  146.   % Local: % INDET3,INDET4,EX8,EX9),
  147.   % Fluid: EX2,EX3,EX5,INDET %
  148.   INDET3: 'INDET3, INDET4: 'INDET4,
  149.   WHEN POSITIVE(EX6),
  150.     WHEN EX5 EQ 1 AND EX7 EQ 1,
  151.       WHEN EX3 EQ PINF, PINF  EXIT,
  152.       EX8: EXPD(PROD(INDET-INDET3,INDET3,0,EX6-1)),
  153.       EX9: (INDET+1)*EX8,
  154.       EX9: EVSUB(EX9,INDET,EX3)-EVSUB(EX9,INDET,EX2-1),
  155.       EXPD(EX9)/(1+EX6)+SIGMA(INDET^EX6-EX8,INDET,EX2,EX3)  EXIT,
  156.     EX8: SIGMA1(INDET4,0,EX1),  
  157.     WHEN FREE(EX8, 'SIGMA),
  158.       WHEN MEMBER(EX8, '(PINF MINF CINF ?) ),  EX8  EXIT,
  159.       LOOP
  160.         EX6: EX6-1,
  161.         WHEN EX6<0,  EXIT,
  162.         EX8: INDET4*DIF(EX8,INDET4),
  163.       ENDLOOP,
  164.       INDET4: EX7,
  165.       EXPD(EX8)  EXIT,
  166.     LIST('SIGMA,EX5*INDET^EX6*EX7^INDET,INDET,EX2,EX3)  EXIT,
  167.   % EX6=0 %
  168.   WHEN FREE(EX5,INDET),
  169.     WHEN EX3 EQ PINF,
  170.       WHEN SIGN(1-EX1) EQ 1,
  171.         WHEN SIGN(1+EX1) EQ 1,
  172.           EX5*EX7^EX2/(1-EX7)  EXIT,
  173.         '?  EXIT,
  174.       PINF  EXIT,
  175.     WHEN EX7=1, EX5*(EX3-EX2+1)  EXIT,
  176.     EX5*(EX7^EX2-EX7^(EX3+1))/(1-EX7)  EXIT,
  177.   WHEN NUMBER(EX6:LINCF(1/EX5,INDET)) AND EX3=PINF,
  178.     WHEN (EX8:SIGN(1+EX1)) EQ -1, '?  EXIT,
  179.     WHEN EX8 EQ 0 AND NOT EX7=EX1, '?  EXIT,
  180.     WHEN SIGN(1-EX1) EQ 1,
  181.       EX8: EXPD(1/EX5-EX6*INDET),
  182.       EX10: EX8/EX6,
  183.       EX4: QUOTIENT(NUM(EX10),DEN(EX10)),
  184.       EX2: EX2+EX4,
  185.       EX8: EX8-EX4*EX6,
  186.       EX10: EX8/EX6,
  187.       WHEN MOD(DEN(EX10),2) EQ 0,
  188.         WHEN SIGN(EX1) EQ -1,
  189.           (-SIGMA2M(EX10,-EX7)+
  190.               SIGMAX((-EX7)^(INDET+EX10)*(-1)^INDET/(INDET+EX10),INDET,EX2,0))
  191.               *(-EX7)^-EX10*EX7^-EX4/EX6  EXIT,
  192.         (SIGMA2(EX10,EX7)+SIGMAX(EX7^(INDET+EX10)/(INDET+EX10),INDET,EX2,0))
  193.               *EX7^-(EX10+EX4)/EX6  EXIT,
  194.       (SIGMA2(EX10,EX7)+SIGMAX(EX7^(INDET+EX10)/(INDET+EX10),INDET,EX2,0))
  195.             *EX7^-(EX10+EX4)/EX6  EXIT,
  196.     WHEN SIGN(EX6) EQ 1, PINF  EXIT,
  197.     MINF  EXIT,
  198.   WHEN FIRST(EX9:1/EX5) EQ '! AND EX3=PINF,
  199.     EX9:SECOND(EX9),
  200.     WHEN POSITIVE(EX6:LINCF(EX9,INDET)) AND INTEGER(EX8:EXPD(EX9-INDET*EX6)),
  201.       EX4: QUOTIENT(EX8,EX6),
  202.       EX8: MOD(EX8,EX6),
  203.       EX2: EX2+EX4,
  204.       WHEN MOD(EX6,2) EQ 0,
  205.         WHEN SIGN(EX1) EQ 1,
  206.           EX7^(-EX8/EX6-EX4)*SIGF(EX7^(1/EX6),EX6,EX8)
  207.             -SIGMAX(EX5*EX7^INDET,INDET,-EX4,EX2-EX4-1)  EXIT,
  208.         (-EX7)^(-EX8/EX6-EX4)*(SIGFM((-EX7)^(1/EX6),EX6,EX8)
  209.             -SIGMAX(EX5*EX7^INDET,INDET,-EX4,EX2-EX4-1))  EXIT,
  210.       EX7^(-EX8/EX6-EX4)*SIGF(EX7^(1/EX6),EX6,EX8)
  211.             -SIGMAX(EX5*EX7^INDET,INDET,-EX4,EX2-EX4-1)  EXIT,
  212.     LIST('SIGMA,EX5*EX7^INDET,INDET,EX2,EX3)  EXIT,
  213.   LIST('SIGMA,EX5*EX7^INDET,INDET,EX2,EX3),
  214. ENDFUN $
  215.  
  216. FUNCTION SIGMAX(EX1, INDET, EX2, EX3),
  217.   WHEN EX2 > EX3+1, -SIGMA(EX1,INDET,EX3+1,EX2-1)  EXIT,
  218.   SIGMA(EX1,INDET,EX2,EX3),
  219. ENDFUN $
  220.  
  221. FUNCTION SIGMA (EX1, INDET, EX2, EX3,
  222.   % Local: %  EX4, EX5, EX6, EX7, EX8, EX9, EX10,
  223.       DENNUM, LEX1, SIGN),
  224.   DENNUM: 30,
  225.   WHEN EX2 = MINF,
  226.     WHEN EX3 = PINF,
  227.       SIGMA(EX1,INDET,0,PINF)+SIGMA(EVSUB(EX1,INDET,-INDET),INDET,1,PINF)  EXIT,
  228.     SIGMA(EVSUB(EX1,INDET,-INDET),INDET,-EX3,PINF)  EXIT,
  229.   WHEN INTEGER(EX2) AND INTEGER(EX3),
  230.     EX4: 0,
  231.     LOOP
  232.       WHEN EX2 > EX3, EX4 EXIT,
  233.       EX4: EX4 + EVSUB(EX1,INDET,EX2),
  234.       EX2: EX2 + 1,
  235.     ENDLOOP EXIT,
  236.   EX1: EXPD(NUM(EX1))/DEN(EX1),
  237.   WHEN APPLY(GET('SIGMA,FIRST(EX1)), ARGEX(EX1))  EXIT,
  238.   EX4: FCTR1(EX1),
  239.   BLOCK
  240.     WHEN PRODUCT(EX4), LEX1: REST(EX4)  EXIT,
  241.     LEX1: LIST(EX4),
  242.   ENDBLOCK,
  243.   EX6: 0, EX4: EX5: EX7: 1,
  244.   LOOP
  245.     WHEN ATOM(LEX1), EXIT,
  246.     EX8: POP(LEX1),
  247.     BLOCK
  248.       WHEN FREE(EX8, INDET), EX4: EX4*EX8  EXIT,
  249.       WHEN EX8=INDET, EX6:EX6+1  EXIT,
  250.       WHEN POWER(EX8),
  251.         EX9: SECOND(EX8), EX10: THIRD(EX8),
  252.         WHEN EX9=INDET AND POSITIVE(EX10),
  253.           EX6: EX6+EX10  EXIT,
  254.         WHEN FREE(EX10: EX10/INDET, INDET) AND FREE(EX9,INDET),
  255.           EX7: EX7*EX9^EX10  EXIT,
  256.         EX5: EX5*EX8  EXIT,
  257.       EX5: EX5*EX8,
  258.     ENDBLOCK,
  259.   ENDLOOP,
  260.   EX4*SIGMA1(EX7,EX6,EX7),
  261. ENDFUN $
  262.  
  263. PROPERTY SIGMA, +, FUNCTION (EX1, EX4),
  264.   % fluid: INDET, EX2, EX3 %
  265.   WHEN ZERO (EVSUB(EX1,INDET,INDET+1) + EX4),
  266.     EVSUB(EX1,INDET,EX2)+EVSUB(EX4,INDET,EX3)  EXIT,
  267.   WHEN ZERO (EVSUB(EX4,INDET,INDET+1) + EX1),
  268.     EVSUB(EX4,INDET,EX2)+EVSUB(EX1,INDET,EX3)  EXIT,
  269.   SIGMA(EX1,INDET,EX2,EX3) + SIGMA(EX4,INDET,EX2,EX3)
  270. ENDFUN $
  271.  
  272. FUNCTION PROD (EX1, INDET, EX2, EX3,
  273.   % Local: %  EX4, LOGEXPD),
  274.   WHEN INTEGER(EX2) AND INTEGER(EX3),
  275.     EX4: 1,
  276.     LOOP
  277.       WHEN EX2 > EX3, EX4 EXIT,
  278.       EX4: EX4 * EVSUB(EX1,INDET,EX2),
  279.       EX2: EX2 + 1,
  280.     ENDLOOP  EXIT,
  281.   WHEN EX1=INDET, EX3!/(EX2-1)!  EXIT,
  282.   WHEN FREE(EX1,INDET), EX1^(EX3-EX2+1)  EXIT,
  283.   WHEN APPLY(GET('PROD,FIRST(EX1)), ARGEX(EX1))  EXIT,
  284.   LIST ('PROD, EX1, INDET, EX2, EX3),
  285. ENDFUN $
  286.  
  287.  
  288. PROPERTY PROD, +, FUNCTION (EX1, EX4),
  289.   % fluid: EX2, EX3, INDET %
  290.   WHEN EX1=INDET AND FREE(EX4,INDET),
  291.     (EX3+EX4)!/(EX2+EX4-1)!  EXIT,
  292.   WHEN EX4=INDET AND FREE(EX1,INDET),
  293.     (EX3+EX1)!/(EX2+EX1-1)!  EXIT,
  294. ENDFUN $
  295.  
  296. PROPERTY PROD, *, FUNCTION (EX1, EX4),
  297.   % fluid: EX2,EX3, INDET %
  298.   WHEN EXPD(EVSUB(EX1,INDET,INDET+1)*EX4) EQ 1,
  299.     EVSUB(EX1,INDET,EX2)*EVSUB(EX4,INDET,EX3)  EXIT,
  300.   WHEN EXPD(EVSUB(EX4,INDET,INDET+1)*EX1) EQ 1,
  301.     EVSUB(EX4,INDET,EX2)*EVSUB(EX1,INDET,EX3)  EXIT,
  302.   PROD(EX1,INDET,EX2,EX3) * PROD(EX4,INDET,EX2,EX3),
  303. ENDFUN $
  304.  
  305. PROPERTY PROD, ^, FUNCTION (EX1, EX4)
  306.   % fluid: EX2, EX3, INDET %
  307.   WHEN FREE(EX4,INDET),
  308.     PROD(EX1,INDET,EX2,EX3)^EX4  EXIT,
  309.   WHEN FREE(EX1,INDET),
  310.     EX1^SIGMA(EX4,INDET,EX2,EX3)  EXIT,
  311. ENDFUN $
  312.  
  313. RDS() $
  314.