home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Science⁄Math / Scientist's Helper src / s.helper.4 / regprim.c < prev   
Encoding:
C/C++ Source or Header  |  1986-02-06  |  13.6 KB  |  578 lines  |  [TEXT/EDIT]
  1. #include "all.h"
  2. #include "regtabext.h"
  3.  
  4. errfcn( x, erf,erfc,erfci,erfci2, deriv )
  5. float x, *erf,*erfc,*erfci,*erfci2, *deriv;
  6. /* ERROR FUNCTION AND ASSOCIATED FUNCTIONS                */
  7. /*           X - ARGUMENT OF ERROR FUNCTION. POSITIVE OR NEGATIVE    */
  8.  
  9. /*                             X                    */
  10. /*           ERF = 2/SQRT(PI) S  EXP( - T**2 ) DT            */
  11. /*                             0                    */
  12.  
  13. /*           ERFC = 1.0 - ERF                        */
  14. /*           ERFCI IS  IERFC(X)                        */
  15. /*           ERFCI =  (1.0/SQRT(PI))*EXP(-X**2)-X(ERFC(X))        */
  16.  
  17. /*           ERFCI2 IS I**2ERFC(X)                    */
  18. /*                 ERFCI2 =  1/4 ((1+2*X**2)ERFC(X)- 2/SQRT(PI)*X*EXP(-X**2))    */
  19. /*                 OR  ALTERNATIVELY                        */
  20. /*                 ERFCI2 = 1/4 (ERCF(X)-2*X*ERFCI(X))                */
  21.  
  22. /*           DERIV - D/DX OF ERF(X)                        */
  23.  
  24. /* METHOD:      RATIONAL APPROXIMATION                        */
  25.  
  26. /* SOURCE:   ABRAMOWITZ AND STEGUN, P.299, HANDBOOK OF                */
  27. /*           MATHEMATICAL FUNCTIONS AND CARSLAW AND JAEGER            */
  28. /*           CONDUCTION OF HEAT IN SOLIDS  P. 482                */
  29. {
  30.     double t, xx, rat, dexpxx;
  31.     double derf, dderiv, derfc, derfci, derfci2;
  32.     double t2,t3,t4;
  33.       
  34.     double p=0.3275911, a1=0.254829592, a2=-0.284496736;
  35.     double a3=1.421413741, a4=-1.453152027, a5=1.061405429;
  36.     double sqrtpi=1.772453851, pi=3.141592654;
  37.  
  38.     xx = fabs( (double) x);
  39.     dexpxx = exp( -(xx*xx) );
  40.     if( xx<1.0e-7 ) { /*use first two terms of taylor series expansion*/
  41.         derf = (2.0 / sqrtpi) * xx * (1.0 - (xx*xx/3.0) );
  42.         if( x<0.0 ) derf=(-derf);
  43.         derfc = 1.0 - derf;
  44.         }
  45.     else { /*use rational approximation*/
  46.         t = 1.0 / ( 1.0 + p*xx );
  47.         t2 = t*t;
  48.         t3 = t2*t;
  49.         t4 = t2*t2;
  50.         rat = (a5*t4 + a4*t3 + a3*t2 + a2*t + a1);
  51.         derf = 1.0 - t*rat*dexpxx;
  52.         if (x<0.0) {
  53.             derf = (-derf);
  54.             derfc =  2.0 - t*rat*dexpxx;
  55.             }
  56.         else {
  57.             derfc =  t*rat*dexpxx;
  58.             } /*end if*/
  59.         } /*end if*/
  60.     xx = (double) x;
  61.     derfci = (1.0/sqrtpi)*dexpxx-xx*derfc;
  62.     derfci2 = 0.25 * (derfc-2.0*xx*derfci);
  63.     dderiv =  (2.0*dexpxx)/sqrtpi;
  64.  
  65.     *erf = (float) ( derf );
  66.     *erfc = (float) ( derfc );
  67.     *erfci = (float)  (derfci);
  68.     *erfci2 =  (float)  (derfci2);
  69.     *deriv = (float) ( dderiv );
  70. } 
  71.  
  72.  
  73. ToNaN(f)
  74. float *f;
  75. {
  76.     if( (errno==EDOM) || (errno==ERANGE) ) {
  77.         *f=infinity;
  78.         }
  79. }
  80. SetVar( vName, vValue )
  81. char vName[], vValue[];
  82. /*create entry in macro substitution table and set value*/
  83. /*if variable previously exists, it is overwritten */
  84. /* returns false if the list is full or if not a valid variable name */
  85. /* valid variable names must not contain spaces */
  86.  
  87. {
  88.     int i, inList;
  89.     char *index();
  90.                 
  91.     if (  (strlen(vName)==0) || ((long)index(vName, ' ')!=0L) ) { 
  92.         return(FALSE);
  93.         }
  94.     else {
  95.         inList = FALSE;
  96.         i = 0;
  97.         while (  (!inList) && (i<macVars.numVars) )  {                   
  98.             if ( strcmp(vName,macVars.inStr[i]) == 0 ) {
  99.                 inList = TRUE;
  100.                 } /*end if inList*/
  101.             i++;
  102.             } /*end while*/
  103.         if (inList) { 
  104.             strcpy( macVars.outStr[i-1], vValue );
  105.             return( TRUE );
  106.             }      
  107.         else {
  108.             if ( (macVars.numVars+1) >= maxVars ) {
  109.                 return( FALSE );
  110.                 }
  111.             else {                   
  112.                 strcpy( macVars.inStr[macVars.numVars], vName );
  113.                 strcpy( macVars.outStr[macVars.numVars], vValue );
  114.                 macVars.numVars++;
  115.                 return( TRUE );
  116.                 } /*end if enough space*/
  117.             } /*end if not inList*/
  118.         } /*end if valid name*/
  119.     }
  120.             
  121. DelVar( vName )
  122. char vName[];
  123. /* deletes macro substitution variable from table*/
  124. {
  125.  
  126.     int i, j, inList; 
  127.     
  128.     if (macVars.numVars==0) {
  129.         return( FALSE );
  130.         }
  131.     else {                   
  132.         inList  = FALSE;
  133.         i  = 0;
  134.         while ( (!inList) && (i<macVars.numVars)  ) {                   
  135.             if ( strcmp(vName,macVars.inStr[i])==0 ) {
  136.                 inList = TRUE;
  137.                 } /*end if match*/
  138.             i++;
  139.             }
  140.         i--; /*i now points to selected variable*/
  141.         if (inList) { 
  142.             if (i != (macVars.numVars-1) ) { /*if not last in list, move others*/             
  143.                 for ( j=(i+1); j<macVars.numVars; j++ ) {
  144.                     strcpy( macVars.inStr[j-1],   macVars.inStr[j]   );
  145.                     strcpy( macVars.outStr[j-1], macVars.outStr[j] );
  146.                     }
  147.                 } /*end if*/
  148.             macVars.numVars--;
  149.             return( TRUE );
  150.             } /*end if inList*/                 
  151.         else {
  152.             return( FALSE );
  153.             } /*end if not inList */
  154.         } /*end if list not empty*/
  155. }
  156.  
  157. ListVars()
  158. /* list macro substitution table */
  159. {
  160.     int i;
  161.     
  162.     for( i=0; i<macVars.numVars; i++ ) {                   
  163.         CheckAbortMenu();
  164.         WritePhrase( "\'" );
  165.         WritePhrase( macVars.inStr[i] );
  166.         WritePhrase( "\' \'" );
  167.         WritePhrase( macVars.outStr[i] );
  168.         WriteLine( "\'" );
  169.         } /* end for */
  170. }
  171.  
  172. SBreak( command, macrosOn )
  173. commandRec *command;
  174. int macrosOn;
  175. /* breaks command string into command words that are separated by blanks */
  176. /* quoted blanks not broken */
  177. /* macro substitutions performed on all command words if macrosOn true */
  178. {
  179.     int i, j, ibuf, len;
  180.     char c[2];
  181.     int quote, word, error, status;
  182.  
  183.        for(  i=0;  i<numCmdWds;  i++ ) {                   
  184.         strcpy( command->cmdWord[i], "" );  /*set command words to null*/
  185.         }
  186.  
  187.     i  = 0;
  188.     j  = 0;
  189.     quote = FALSE;
  190.     word  = FALSE;
  191.     error  = FALSE;
  192.     ibuf  =  0;
  193.     if( (len=strlen(command->cmdStr))==0) {
  194.         return(TRUE);
  195.         }
  196.  
  197.     c[1] = '\0';
  198.     while ( (ibuf<len) && (!error) ) {                   
  199.         if ( i >= cmdWordLen ) {
  200.             error  = TRUE;
  201.             }                   
  202.         else {  
  203.                      c[0] = command->cmdStr[ibuf];
  204.             if( j >= numCmdWds ) {
  205.                 error = TRUE;
  206.                 }
  207.                     else if ( ((c[0]==' ')||(c[0]=='\t')) && (!quote) ) {                   
  208.                 if (word)  {                   
  209.                     word  = FALSE;
  210.                     i  =  0;
  211.                     j++;
  212.                     }
  213.                 }
  214.                     else if ( (c[0]==' ')||(c[0]=='\t') && quote ) {                   
  215.                 word  = TRUE;
  216.                 strcat( command->cmdWord[j], c );
  217.                 i++;
  218.                 }
  219.                      else if ( (c[0]=='\'') && (!quote) ) {                   
  220.                 word  = TRUE;
  221.                 quote  = TRUE;
  222.                 }
  223.                      else if ( (c[0]=='\'') && quote )  {                   
  224.                 word = FALSE;
  225.                 quote = FALSE;
  226.                 i = 0;
  227.                 j++;
  228.                 }
  229.                      else {                   
  230.                 word  = TRUE;
  231.                 strcat( command->cmdWord[j], c ); 
  232.                 i++;
  233.                 } /*end if on characters*/;
  234.                      }  /*end if cmdWordLen*/
  235.             ibuf++;
  236.         } /*end while*/;
  237.     
  238.     status = FALSE;
  239.     if ( !error ) {
  240.         i = 0;
  241.         status = TRUE;
  242.         while ( (i<numCmdWds) && status && macrosOn )  {                   
  243.             status  = GetVar( command->cmdWord[i], command->cmdWord[i] );
  244.             i++;
  245.             } /*while numCmdWds*/;
  246.         } /*if not error*/
  247.         
  248.     return(  (!error) && status );
  249. }
  250.  
  251. GetVar( vName,  vValue)
  252. char vName[], vValue[];
  253. /* does macro-substitution on a variable reference*/
  254. /* does not change the value of VValue on no-match*/
  255. /* returns false only if no match occurs on a valid variable name*/
  256. /* where a valid variable reference*/
  257. /* a) starts with a @ */
  258. /* b) contains no spaces */
  259.  
  260. {
  261.     int i, len;
  262.     int inList;
  263.     char *index();
  264.     
  265.     if( ((long)index(vName,' ')!=0L) || ((long)index(vName,'@')!=(long)vName) ) { 
  266.         /*not a variable reference*/
  267.         return(TRUE);
  268.         }
  269.     else if ( (len=strlen(vName)) < 2 ) { /*string consisting only of @ is invalid*/
  270.         return(FALSE);
  271.         }
  272.     else if (macVars.numVars==0) {  /*is valid reference but no variables defined*/
  273.         return(FALSE);
  274.         }                   
  275.     else {  /* is a valid variable reference */
  276.         inList  = FALSE;
  277.         i  = 0;
  278.         while ( (!inList) && (i<macVars.numVars) ) {                   
  279.             if (strcmp( &(vName[1]) , macVars.inStr[i] ) == 0) {
  280.                 inList = TRUE;
  281.                 } /*end if*/
  282.                      i++; 
  283.                      }  /*end while*/
  284.         if (inList)  {
  285.                      strcpy( vValue, macVars.outStr[i-1] );
  286.              return(TRUE);
  287.                      } /*end if inList*/                 
  288.         else {                   
  289.             return(FALSE);
  290.             } /*end if not inList*/
  291.         } /* end if valid reference*/
  292. } 
  293.  
  294. done()
  295. {
  296.     if( doneFlag ) {
  297.         if( CautionAlert(quitAlertRes, NULL)==1 ) {
  298.             return(TRUE);
  299.             }
  300.         else {
  301.             return(FALSE);
  302.             }
  303.     }
  304.     else {
  305.         return(FALSE);
  306.         }
  307. }
  308.  
  309. GoodRow( row ) /* returns 0 if 1<=row<=rows,  1 if rows<row<=maxrows, 2 otherwise */
  310. int row;
  311. {
  312.     if( (row>=1) && (row<=table.header.rows) ) {
  313.         return(0);
  314.         }
  315.     else if( (row>table.header.rows) && (row<=table.header.maxRows) ) {
  316.         return(1);
  317.         }
  318.     else {
  319.         return(2);
  320.         }
  321. }
  322.  
  323. GoodCol( col ) /* returns 0 if 1<=col<=cols,  1 if cols<col<=maxcols, 2 otherwise */
  324. int col;
  325. {
  326.     if( (col>=1) && (col<=table.header.cols) ) {
  327.         return(0);
  328.         }
  329.     else if( (col>table.header.cols) && (col<=table.header.maxCols) ) {
  330.         return(1);
  331.         }
  332.     else {
  333.         return(2);
  334.         }
  335. }
  336.  
  337. ErrMsg( message )
  338. char message[];
  339. {
  340.     int i;
  341.     char s[80];
  342.     
  343.     HiliteMenu(0);
  344.     RedoEditWindow();
  345.     if( currentWindow!=coWindow ) {
  346.         SetPort(theWindow[coWindow]);
  347.         SelectWindow( theWindow[coWindow] );
  348.         currentWindow = coWindow;
  349.         whichWindow = theWindow[coWindow];
  350.         }
  351.     (*coText)->selStart = (*coText)->teLength;
  352.     (*coText)->selEnd = (*coText)->teLength;
  353.     TEInsert( "Error: ", 7L, coText );
  354.     TEInsert( message, (long)strlen(message), coText );
  355.     TEInsert( "\r", 1L, coText );
  356.     if( mem.active ) { /*turn off procedure*/
  357.         TESetSelect( (long)((*prText)->lineStarts[mem.stack[mem.stackPtr]]),
  358.                  (long)((*prText)->lineStarts[mem.stack[mem.stackPtr]+1]),
  359.                  prText );
  360.         pendingFlag=FALSE;
  361.         NoPendingInput();
  362.         for (i=mem.stackPtr; i>=0; i-- ) {
  363.             IToS( mem.stack[i]+1, s );
  364.             TEInsert("called from line ",17L,coText);
  365.             TEInsert(s, (long)strlen(s), coText );
  366.             TEInsert("\r", 1L, coText);
  367.             }
  368.         mem.active=FALSE;
  369.         mem.stackPtr=-1;
  370.         loops.numLoops=0;
  371.         }
  372.     TEInsert( "> ", 2L, coText );
  373.     IfOutScroll( coText );
  374.     SysBeep(5);
  375.     longjmp(envbuf,-1);
  376. }
  377.  
  378. WriteLine( message )
  379. char message[];
  380. {
  381.     if( currentWindow!=coWindow ) {
  382.         SetPort(theWindow[coWindow]);
  383.         SelectWindow( theWindow[coWindow] );
  384.         currentWindow = coWindow;
  385.         whichWindow = theWindow[coWindow];
  386.         }
  387.     (*coText)->selStart = (*coText)->teLength;
  388.     (*coText)->selEnd = (*coText)->teLength;
  389.     TEInsert( &message[0], (long)strlen(message), coText );
  390.     TEInsert( "\r", 1L, coText );
  391.     IfOutScroll( coText );
  392. }
  393.  
  394. WritePhrase( message )
  395. char message[];
  396. {
  397.     if( currentWindow!=coWindow ) {
  398.         SetPort(theWindow[coWindow]);
  399.         SelectWindow( theWindow[coWindow] );
  400.         currentWindow = coWindow;
  401.         whichWindow = theWindow[coWindow];
  402.         }
  403.     (*coText)->selStart = (*coText)->teLength;
  404.     (*coText)->selEnd = (*coText)->teLength;
  405.     TEInsert( &message[0], (long)strlen(message), coText );
  406.     IfOutScroll( coText );
  407. }
  408.  
  409.  
  410. CheckAbortMenu()
  411. {
  412.     Point mPoint;
  413.     if (Button() != 0) {
  414.         GetMouse( &mPoint );
  415.         LocalToGlobal( &mPoint );
  416.             if( PtInRect( pass(mPoint), &abortRect ) != 0 ) {
  417.                 SysBeep(20);
  418.                 SetPort(theWindow[coWindow]);
  419.                 SelectWindow( theWindow[coWindow] );
  420.                 currentWindow = coWindow;
  421.                 whichWindow = theWindow[coWindow];
  422.                 if( mem.active ) { /*turn off procedure*/
  423.                     mem.active=FALSE;
  424.                     mem.stackPtr=-1;
  425.                     loops.numLoops=0;
  426.                     pendingFlag=FALSE;
  427.                     NoPendingInput();
  428.                     }
  429.                 TEInsert( "Abort!\r",7L,coText);
  430.                 TEInsert( "> ", 2L, coText );
  431.                 IfOutScroll( coText );
  432.                 RedoEditWindow();
  433.                 HiliteMenu(0);
  434.                 longjmp(envbuf,-1);
  435.                 } /*end if abort menu and item*/
  436.         } /*end if mouse is down*/
  437.     HiliteMenu(0);
  438. }
  439. PendingInput()
  440. {
  441.     DisableItem( myMenu[apMenu], 0 );
  442.     DisableItem( myMenu[fiMenu], 1 );
  443.     DisableItem( myMenu[fiMenu], 4 );
  444.     DisableItem( myMenu[fiMenu], 7 );
  445.     DisableItem( myMenu[edMenu], 0 );
  446.     DisableItem( myMenu[wiMenu], 3 );
  447.     DisableItem( myMenu[wiMenu], 4 );
  448. }
  449.  
  450. NoPendingInput()
  451. {
  452.     EnableItem( myMenu[apMenu], 0 );
  453.     EnableItem( myMenu[fiMenu], 1 );
  454.     EnableItem( myMenu[fiMenu], 4 );
  455.     EnableItem( myMenu[fiMenu], 7 );
  456.     EnableItem( myMenu[edMenu], 0 );
  457.     EnableItem( myMenu[wiMenu], 3 );
  458.     EnableItem( myMenu[wiMenu], 4 );
  459. }
  460.  
  461. Graph2Vars()
  462. {
  463.     int status;
  464.     char s[cmdWordLen];
  465.     
  466.     RToS( graph.xMin, s );
  467.     status = SetVar( "xmin", s );
  468.     
  469.     RToS( graph.xMax, s );
  470.     status = status && SetVar( "xmax", s );
  471.     
  472.     RToS( graph.yMin, s );
  473.     status = status && SetVar( "ymin", s );
  474.     
  475.     RToS( graph.yMax, s );
  476.     status = status && SetVar( "ymax", s );
  477.     
  478.     if( !status ) {
  479.         ErrMsg("couldnt create graphics variables");
  480.         }
  481. }
  482.  
  483. FindLabel( s, line) /*search for particular label and return its line number*/
  484. char s[];
  485. int *line;
  486. {
  487.     commandRec tCommand;
  488.     int i, j, k, match;
  489.     
  490.     match = FALSE;
  491.     *line = 0;
  492.     for( i=0; (i<mem.numLabels && (!match)); i++) { /*search label list*/
  493.         j=(*prText)->lineStarts[mem.labels[i]];
  494.         k=((*prText)->teLength)-1;
  495.         HLock((*prText)->hText);
  496.         ExtractLine( *((*prText)->hText), j, k, tCommand.cmdStr );
  497.         HUnlock((*prText)->hText);
  498.         if( !SBreak( &tCommand, FALSE ) ) {
  499.             WriteLine("(find) bad line in procedure:");
  500.             /*ErrMsg(tCommand.cmdStr);*/
  501.             }
  502.         if (strcmp(tCommand.cmdWord[1],s)==0) {
  503.             match = TRUE;
  504.             *line  = mem.labels[i];
  505.             }
  506.         } /*end for*/
  507.     return( match );
  508. }
  509.  
  510. ListLabels() /*constructs label list from current contents of procedure memory*/
  511. {
  512.     commandRec tCommand;
  513.     int i, j, k, badLine;
  514.     
  515.     mem.numLabels = 0;
  516.     badLine=FALSE;
  517.     for( i=0; i<(*prText)->nLines; i++) {/*scan memory sequentially*/
  518.         j=(*prText)->lineStarts[i];
  519.         k=((*prText)->teLength)-1;
  520.         HLock((*prText)->hText);
  521.         ExtractLine( *((*prText)->hText), j, k, tCommand.cmdStr );
  522.         HUnlock((*prText)->hText);
  523.         if( !SBreak( &tCommand, FALSE ) ) {
  524.             TESetSelect( (long)((*prText)->lineStarts[i]), (long)((*prText)->lineStarts[i+1]),
  525.                  prText );
  526.             WriteLine("bad line in procedure:");
  527.             WriteLine(tCommand.cmdStr);
  528.             badLine=TRUE;
  529.             }
  530.         if( strcmp(tCommand.cmdWord[0],"label")==0 ) {
  531.             mem.labels[mem.numLabels] = i;
  532.             mem.numLabels++;
  533.             }
  534.         } /*end for*/
  535.     if( badLine ) {
  536.         ErrMsg("procedure aborted");
  537.         }
  538. }
  539.  
  540. ExtractLine(c, start, end, cc)
  541. char c[];
  542. int start, end;
  543. char cc[];
  544. {
  545.     int i;
  546.     for( i=0; ( (i<(end-start+1)) && (i<(cmdWordLen-1)) ); i++ ) {
  547.         cc[i] = c[i+start];
  548.         if (cc[i]=='\r') {
  549.             cc[i] = '\0';
  550.             break;
  551.             }
  552.         }
  553.     cc[i] = '\0';
  554. }
  555.  
  556. RedoEditWindow()
  557. {
  558.     GrafPtr oldPort;
  559.     int oldWindow;
  560.     
  561.     GetPort( &oldPort );
  562.     oldWindow=currentWindow;
  563.     
  564.     SetPort( theWindow[edWindow] );
  565.     InvalRect( &(theWindow[edWindow]->portRect) );
  566.     tabEd.activeName=FALSE;
  567.     tabEd.activeEntry=FALSE;
  568.     
  569.     SetPort( oldPort );
  570.     currentWindow=oldWindow;
  571.     whichWindow=theWindow[currentWindow];
  572. }
  573.  
  574.  
  575.  
  576.  
  577.  
  578.