home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 04 / txl / 1_preis / formel.c < prev    next >
Text File  |  1991-03-06  |  18KB  |  693 lines
  1. /************************************************************************
  2. *                .......................................                *
  3. *                .                                     .                *
  4. *                .       TOOLBOX - INTERPRETER         .                *
  5. *                . TESTPROGRAMM FÜR WINDOWS-FUNKTIONEN .                *
  6. *                .             FORMEL.C                .                *
  7. *                .    M.Beising & K.Bauer & TOOLBOX    .                *
  8. *                .......................................                *
  9. *************************************************************************/
  10.  
  11. #include <windows.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <ctype.h>
  16. #include <math.h>
  17. #include "kubasic.h"
  18.  
  19. PTNODE CreateTree(char Fktzeile[],int *ErrorPos,int *ErrorNr);
  20. PTNODE faktor(char f[]);
  21. PTNODE vorzfaktor(char f[]);
  22. PTNODE potenz(char f[]);
  23. PTNODE produkt(char f[]);
  24. PTNODE summe(char f[]);
  25. PTNODE vergleich(char f[]);
  26. PTNODE verknuepf(char f[]);
  27. void DelTree(PTNODE *ptnode);
  28. void nextchar(int start,char f[]);
  29. void neuewurzel(PTNODE *wurzel,char f[]);
  30. void newnode(PTNODE *knoten);
  31. BOOL unaerefunktion(char f[],unsigned char *token);
  32. void getnumber(char f[],int *posi,char fhelp[30]);
  33. double Calc(PTNODE *ptnode);
  34. double arctanh(double x);
  35. double arccot(double x);
  36. double cot(double x);
  37. double frac(double f);
  38. float ran1(void);
  39. float ran2(void);
  40. float ran3(void);
  41. float random();
  42. void LiesDaten(void);
  43. void SaveDaten(void);
  44. extern char   *GetFileName (void);
  45.  
  46. extern int  AktPos,ErrTyp,ErrPos,ErrNr,fio;
  47. extern BOOL TreeError;
  48. extern HWND hWndglob,hWndEdit;
  49. extern char FileName[FNAMLEN];
  50. extern HANDLE hEditText;
  51. extern OFSTRUCT fileInfo;
  52. extern BOOL bText;
  53. unsigned char aktchar;
  54.  
  55. PTNODE CreateTree(char Fktzeile[],int *ErrorPos,int *ErrorNr)
  56. {
  57.   PTNODE wurzel;
  58.   AktPos=0;
  59.   nextchar(AktPos,Fktzeile);
  60.   TreeError=FALSE;
  61.   wurzel=NULL;
  62.   wurzel=verknuepf(Fktzeile);
  63.   if ((AktPos<=strlen(Fktzeile)) && (Fktzeile[AktPos-1]!=' ') && (!TreeError)) {
  64.     TreeError=TRUE;
  65.     ErrTyp=4;
  66.   }
  67.   if (!TreeError) {
  68.     *ErrorPos=-1;
  69.     *ErrorNr=-1;
  70.   } else {
  71.     DelTree(&wurzel);
  72.     *ErrorPos=AktPos;
  73.     *ErrorNr=ErrTyp;
  74.   }
  75.   return wurzel;
  76. }
  77.  
  78.  
  79. void DelTree(PTNODE *ptnode)
  80. {
  81.   if (*ptnode!=NULL) {
  82.     DelTree(&((*ptnode)->LeftAst));
  83.     DelTree(&((*ptnode)->RightAst));
  84.     if (((*ptnode)->operator=='\0')) {
  85.       LocalFree((LOCALHANDLE) (*ptnode)->operand);
  86.       LocalFree((LOCALHANDLE)*ptnode);
  87.       *ptnode=NULL;
  88.     } else {
  89.       LocalFree((LOCALHANDLE)*ptnode);
  90.       *ptnode=NULL;
  91.     }
  92.   }
  93. }
  94.  
  95. void nextchar(int start,char f[])
  96. {
  97.   if (start > strlen(f)) aktchar='\0';
  98.   else {
  99.     do
  100.       (start)++;
  101.     while (!((f[start-1]!=' ') || (start>=strlen(f))));
  102.     if (start<=strlen(f)) {
  103.       AktPos=start;
  104.       aktchar=(f[AktPos-1] != ';' ? f[AktPos-1]:f[AktPos++]);
  105.     } else AktPos++;
  106.   }
  107. }
  108.  
  109. void neuewurzel(PTNODE *wurzel,char f[])
  110. {
  111.   PTNODE helpnode;
  112.   helpnode=(NODESTRUCT NEAR *)LocalAlloc (LPTR,sizeof(NODESTRUCT));
  113.   if (helpnode != NULL)
  114.    {
  115.     helpnode->LeftAst=*wurzel;
  116.     *wurzel=helpnode;
  117.     (*wurzel)->RightAst=NULL;
  118.     (*wurzel)->operator=aktchar;
  119.     (*wurzel)->operand=NULL;
  120.     nextchar(AktPos,f);
  121.    } else SendMessage(hWndglob,WM_DESTROY,0,0L);
  122.  
  123. }
  124.  
  125. void newnode(PTNODE *knoten)
  126. {
  127.   *knoten=(NODESTRUCT NEAR *)LocalAlloc(LPTR,sizeof(NODESTRUCT));
  128.   if (*knoten != NULL)
  129.    {
  130.     (*knoten)->operator='\0';
  131.     (*knoten)->operand=NULL;
  132.     (*knoten)->RightAst=NULL;
  133.     (*knoten)->LeftAst=NULL;
  134.    } else SendMessage(hWndglob,WM_DESTROY,0,0L);
  135. }
  136.  
  137. double Calc(PTNODE *ptnode)
  138. {
  139.   double Wert;
  140.   int links,rechts;
  141.  switch ((*ptnode)->operator)
  142.    {
  143.     case '\0':
  144.       Wert=(*((*ptnode)->operand));
  145.       break;
  146.     case EQV:
  147.     case XOR:
  148.     case OR:
  149.     case AND:
  150.       rechts = (int) Calc(&((*ptnode)->RightAst));
  151.     case NOT:
  152.       links  = (int) Calc(&((*ptnode)->LeftAst));
  153.     if((*ptnode)->operator == NOT)
  154.                 Wert=(links == 0 ? 1.0: 0.0); else
  155.     if((*ptnode)->operator == AND)
  156.                 Wert=(links != 0 && rechts != 0 ? 1.0: 0.0); else
  157.     if((*ptnode)->operator == OR)
  158.                 Wert=(links != 0 || rechts != 0 ? 1.0: 0.0); else
  159.     if((*ptnode)->operator == XOR)
  160.                 Wert=((links != 0 && rechts == 0) ||
  161.                         (links == 0 && rechts != 0)) ? 1.0: 0.0; else
  162.     if((*ptnode)->operator == EQV)
  163.                 Wert=((links == 0 && rechts == 0) ||
  164.                         (links != 0 && rechts != 0)) ? 1.0: 0.0;
  165.       break;
  166.     case KLGL:
  167.       Wert=(Calc(&((*ptnode)->LeftAst))<=Calc(&((*ptnode)->RightAst)) ? 1.0: 0.0);
  168.       break;
  169.     case UNGL:
  170.       Wert=(Calc(&((*ptnode)->LeftAst))!=Calc(&((*ptnode)->RightAst)) ? 1.0: 0.0);
  171.       break;
  172.     case GRGL:
  173.       Wert=(Calc(&((*ptnode)->LeftAst))>=Calc(&((*ptnode)->RightAst)) ? 1.0: 0.0);
  174.       break;
  175.     case GL:
  176.       Wert=(Calc(&((*ptnode)->LeftAst))==Calc(&((*ptnode)->RightAst)) ? 1.0: 0.0);
  177.       break;
  178.     case KL:
  179.       Wert=(Calc(&((*ptnode)->LeftAst))<Calc(&((*ptnode)->RightAst)) ? 1.0: 0.0);
  180.       break;
  181.     case GR:
  182.       Wert=(Calc(&((*ptnode)->LeftAst))>Calc(&((*ptnode)->RightAst)) ? 1.0: 0.0);
  183.       break;
  184.     case '+':
  185.       Wert=(Calc(&((*ptnode)->LeftAst))+Calc(&((*ptnode)->RightAst)));
  186.       break;
  187.     case '-':
  188.       Wert=(Calc(&((*ptnode)->LeftAst))-Calc(&((*ptnode)->RightAst)));
  189.       break;
  190.     case '*':
  191.       Wert=(Calc(&((*ptnode)->LeftAst))*Calc(&((*ptnode)->RightAst)));
  192.       break;
  193.     case '/':
  194.       if(Calc(&((*ptnode)->RightAst)) == 0.0)
  195.           {
  196.            Wert = Calc(&((*ptnode)->RightAst));
  197.            PRINTF("# DIVIDE BY ZERO #");
  198.            break;
  199.           }
  200.        else
  201.            Wert=(Calc(&((*ptnode)->LeftAst))/Calc(&((*ptnode)->RightAst)));
  202.       break;
  203.     case '^':
  204.        Wert=(pow(Calc(&((*ptnode)->LeftAst)),Calc(&((*ptnode)->RightAst))));
  205.       break;
  206.     case Ln:
  207.       Wert=(log(Calc(&((*ptnode)->LeftAst))));
  208.       break;
  209.     case Log:
  210.       Wert=(log10(Calc(&((*ptnode)->LeftAst))));
  211.       break;
  212.     case Exponent:
  213.       Wert=(exp(Calc(&((*ptnode)->LeftAst))));
  214.       break;
  215.     case Sinus:
  216.       Wert=(sin(Calc(&((*ptnode)->LeftAst))));
  217.       break;
  218.     case Cosinus:
  219.       Wert=(cos(Calc(&((*ptnode)->LeftAst))));
  220.       break;
  221.     case Tangens:
  222.       Wert=(tan(Calc(&((*ptnode)->LeftAst))));
  223.       break;
  224.     case ArcSin:
  225.       Wert=(asin(Calc(&((*ptnode)->LeftAst))));
  226.       break;
  227.     case ArcCos:
  228.       Wert=(acos(Calc(&((*ptnode)->LeftAst))));
  229.       break;
  230.     case ArcTan:
  231.       Wert=(atan(Calc(&((*ptnode)->LeftAst))));
  232.       break;
  233.     case SinHyp:
  234.       Wert=(sinh(Calc(&((*ptnode)->LeftAst))));
  235.       break;
  236.     case CosHyp:
  237.       Wert=(cosh(Calc(&((*ptnode)->LeftAst))));
  238.       break;
  239.     case TanHyp:
  240.       Wert=(tanh(Calc(&((*ptnode)->LeftAst))));
  241.       break;
  242.     case Sqrt:
  243.       Wert=(sqrt(Calc(&((*ptnode)->LeftAst))));
  244.       break;
  245.     case Frac:
  246.       Wert=(double)((double)frac(Calc(&((*ptnode)->LeftAst))));
  247.       break;
  248.     case Absolut:
  249.       Wert=(double)((double)fabs(Calc(&((*ptnode)->LeftAst))));
  250.       break;
  251.     case Cotangens:
  252.       Wert=(cot(Calc(&((*ptnode)->LeftAst))));
  253.       break;
  254.     case ArcCot:
  255.       Wert=(arccot(Calc(&((*ptnode)->LeftAst))));
  256.       break;
  257.     case ArcTanHyp:
  258.       Wert=(arctanh(Calc(&((*ptnode)->LeftAst))));
  259.       break;
  260.     case SIGN:
  261.       Wert=(-Calc(&((*ptnode)->LeftAst)));
  262.       break;
  263.    }
  264.    return Wert;
  265. }
  266.  
  267. void getnumber(char f[],int *posi,char dbStr[])
  268. {
  269.  int   LenF;
  270.  char  *fhelp;
  271.  LenF = strlen(f);
  272.  fhelp = dbStr;
  273.  while(*posi <= LenF && f[*posi] > '/' && f[*posi] < ':')
  274.        {
  275.           *fhelp++ = f[*posi];
  276.           *posi += 1;
  277.        }
  278.  while(*posi <= LenF && f[*posi] == '.')
  279.        {
  280.           *fhelp++ = f[*posi];
  281.           *posi += 1;
  282.        }
  283.  while(*posi <= LenF && f[*posi] > '/' && f[*posi] < ':')
  284.        {
  285.           *fhelp++ = f[*posi];
  286.           *posi += 1;
  287.        }
  288.  while(*posi <= LenF && (f[*posi] == 'e' || f[*posi] == 'E'))
  289.        {
  290.           if (f[*posi] == 'e') f[*posi] = 'E';
  291.           *fhelp++ = f[*posi];
  292.           *posi += 1;
  293.           if (*posi <= LenF && (f[*posi] == '+' || f[*posi] == '-'))
  294.           {
  295.            *fhelp++ = f[*posi];
  296.            *posi += 1;
  297.           }
  298.  while(*posi <= LenF && f[*posi] > '/' && f[*posi] < ':')
  299.        {
  300.           *fhelp++ = f[*posi];
  301.           *posi += 1;
  302.        }
  303.        }
  304. }
  305.  
  306. void PosVar(char fkt[],unsigned char name[])
  307. {
  308.  int count = 0;
  309.  AktPos--;
  310.  while ((isalpha (fkt[AktPos]) || isdigit (fkt[AktPos])) && (count < NAMLEN))
  311.     name[count++] = fkt[AktPos++];
  312.     name[count] = '\0';
  313. }
  314.  
  315. BOOL LogicAusdruck(char f[],unsigned char *token)
  316. {
  317.   *token='\0';
  318.   if (!(memicmp("AND",&f[AktPos-1],3)))        *token=AND;
  319.   else if(!(memicmp("XOR",&f[AktPos-1],3)))    *token=XOR;
  320.   else if(!(memicmp("OR",&f[AktPos-1],2)))     *token=OR;
  321.   else if(!(memicmp("EQV",&f[AktPos-1],3)))    *token=EQV;
  322.   return (*token ? TRUE : FALSE);
  323. }
  324.  
  325. BOOL unaerefunktion(char f[],unsigned char *token)
  326. {
  327.   *token='\0';
  328.   if (!(memicmp("ln",&f[AktPos-1],2)))          *token=Ln;
  329.   else if(!(memicmp("sinh",&f[AktPos-1],4)))    *token=SinHyp;
  330.   else if(!(memicmp("cosh",&f[AktPos-1],4)))    *token=CosHyp;
  331.   else if(!(memicmp("tanh",&f[AktPos-1],4)))    *token=TanHyp;
  332.   else if(!(memicmp("sqrt",&f[AktPos-1],4)))    *token=Sqrt;
  333.   else if(!(memicmp("frac",&f[AktPos-1],4)))    *token=Frac;
  334.   else if(!(memicmp("log",&f[AktPos-1],3)))     *token=Log;
  335.   else if(!(memicmp("exp",&f[AktPos-1],3)))     *token=Exponent;
  336.   else if(!(memicmp("sin",&f[AktPos-1],3)))     *token=Sinus;
  337.   else if(!(memicmp("cos",&f[AktPos-1],3)))     *token=Cosinus;
  338.   else if(!(memicmp("tan",&f[AktPos-1],3)))     *token=Tangens;
  339.   else if(!(memicmp("abs",&f[AktPos-1],3)))     *token=Absolut;
  340.   else if(!(memicmp("cot",&f[AktPos-1],3)))     *token=Cotangens;
  341.   else if(!(memicmp("NOT",&f[AktPos-1],3)))     *token=NOT;
  342.   else if(!(memicmp("arctanh",&f[AktPos-1],7))) *token=ArcTanHyp;
  343.   else if(!(memicmp("arcsin",&f[AktPos-1],6)))  *token=ArcSin;
  344.   else if(!(memicmp("arccos",&f[AktPos-1],6)))  *token=ArcCos;
  345.   else if(!(memicmp("arctan",&f[AktPos-1],6)))  *token=ArcTan;
  346.   else if(!(memicmp("arccot",&f[AktPos-1],6)))  *token=ArcCot;
  347.  
  348.    switch (*token)
  349.           {
  350.            case ArcTanHyp:
  351.                 AktPos++;
  352.            case ArcSin:
  353.            case ArcCos:
  354.            case ArcTan:
  355.            case ArcCot:
  356.                 AktPos++;
  357.                 AktPos++;
  358.            case SinHyp:
  359.            case CosHyp:
  360.            case TanHyp:
  361.            case Sqrt:
  362.            case Frac:
  363.                 AktPos++;
  364.            case Log:
  365.            case Exponent:
  366.            case Sinus:
  367.            case Cosinus:
  368.            case Tangens:
  369.            case Absolut:
  370.            case Cotangens:
  371.            case NOT:
  372.                 AktPos++;
  373.            case Ln:
  374.                 AktPos++;
  375.                 nextchar(AktPos,f);
  376.       break;
  377.   }
  378.   return (*token ? TRUE : FALSE);
  379. }
  380.  
  381. PTNODE faktor(char f[])
  382. {
  383. PTNODE knoten;
  384. VAR *Variable;
  385.   int   valid,posi;
  386. unsigned char token;
  387.   char DoubleStr[30];
  388.   knoten=NULL;
  389.    if (aktchar=='(') {
  390.        nextchar(AktPos,f);
  391.        knoten=verknuepf(f);
  392.    if ((aktchar!=')') && (!TreeError))
  393.       {
  394.        TreeError=TRUE;
  395.        ErrTyp=0;
  396.       }
  397.      if (!TreeError) nextchar(AktPos,f);
  398.     }
  399.     else if (unaerefunktion(f,&token))
  400.    {
  401.      if (aktchar!='(')
  402.      {
  403.        TreeError=TRUE;
  404.        ErrTyp=1;
  405.      } else
  406.       {
  407.        newnode(&knoten);
  408.        knoten->operator=token;
  409.        nextchar(AktPos,f);
  410.        knoten->LeftAst=verknuepf(f);
  411.       }
  412.     if ((aktchar!=')') && (!TreeError))
  413.       {
  414.        TreeError=TRUE;
  415.        ErrTyp=0;
  416.       }
  417.     if (!TreeError) nextchar(AktPos,f);
  418.   } else if(isalpha(aktchar) && !LogicAusdruck(f,&token)) {
  419.           newnode(&knoten);
  420.        knoten->operand=(double NEAR *)LocalAlloc (LPTR,sizeof(double));
  421.      if (knoten->operand== NULL)
  422.            {
  423.              TreeError=TRUE;
  424.               ErrTyp=6;
  425.            } else
  426.             {
  427.              PosVar(f,DoubleStr);
  428.              if(!(strcmp("e",DoubleStr))) *(knoten->operand)= e;
  429.               else
  430.               if(!(strcmp("pi",DoubleStr))) *(knoten->operand)= pi;
  431.                else
  432.                  if(!(strcmp("rnd",DoubleStr))) *(knoten->operand)= random();
  433.                 else if ((Variable = IsVariable (DoubleStr)) != NULL)
  434.                     {
  435.                       if(Variable->VarType == FLONUM)
  436.                         *(knoten->operand)= Variable->VarWert.variable.Flotype;
  437.                        else  {
  438.                                  TreeError=TRUE;
  439.                                  ErrTyp=7;
  440.                                 }
  441.                     }
  442.                      else  {
  443.                               TreeError=TRUE;
  444.                               ErrTyp=5;
  445.                            }
  446.             }
  447.            if (!TreeError) nextchar(AktPos,f);
  448.   } else if ((aktchar>='0') && (aktchar<='9') || (aktchar=='.')) {
  449.     newnode(&knoten);
  450.     knoten->operand=(double NEAR *)LocalAlloc (LPTR,sizeof(double));
  451.      if (knoten->operand== NULL)
  452.            {
  453.              TreeError=TRUE;
  454.              ErrTyp=6;
  455.            }
  456.        else
  457.            {
  458.              posi=AktPos-1;
  459.              memset(DoubleStr,'\0',29);
  460.              getnumber(f,&posi,DoubleStr);
  461.              *(knoten->operand) = atof(DoubleStr);
  462.              AktPos=posi;
  463.              nextchar(AktPos,f);
  464.            }
  465.   } else {
  466.     TreeError=TRUE;
  467.     if ((aktchar==' ') || (AktPos==strlen(f)+1))
  468.       ErrTyp=3;
  469.     else ErrTyp=4;
  470.   }
  471.   return knoten;
  472. }
  473.  
  474.  
  475. PTNODE vorzfaktor(char f[])
  476. {
  477.   PTNODE wurzel;
  478.   wurzel=NULL;
  479.   if ((aktchar=='-')) {
  480.     newnode(&wurzel);
  481.     wurzel->operator=SIGN;
  482.     nextchar(AktPos,f);
  483.     wurzel->LeftAst=faktor(f);
  484.   } else if (aktchar=='+') {
  485.     nextchar(AktPos,f);
  486.     wurzel=faktor(f);
  487.   } else {
  488.     wurzel=faktor(f);
  489.   }
  490.   return wurzel;
  491. }
  492.  
  493. PTNODE potenz(char f[])
  494. {
  495.   PTNODE wurzel;
  496.   wurzel=NULL;
  497.   wurzel=vorzfaktor(f);
  498.   while ((aktchar=='^') && (!TreeError)) {
  499.     neuewurzel(&wurzel,f);
  500.     wurzel->RightAst=vorzfaktor(f);
  501.   }
  502.   return wurzel;
  503. }
  504.  
  505. PTNODE produkt(char f[])
  506. {
  507.   PTNODE wurzel;
  508.   wurzel=NULL;
  509.   wurzel=potenz(f);
  510.   while ((aktchar=='*' || aktchar=='/') && !TreeError) {
  511.     neuewurzel(&wurzel,f);
  512.     wurzel->RightAst=potenz(f);
  513.   }
  514.   return wurzel;
  515. }
  516. PTNODE summe(char f[])
  517. {
  518.   PTNODE wurzel;
  519.   wurzel=NULL;
  520.   wurzel=produkt(f);
  521.   while ((aktchar=='+' || aktchar=='-') && !TreeError) {
  522.     neuewurzel(&wurzel,f);
  523.     wurzel->RightAst=produkt(f);
  524.   }
  525.   return wurzel;
  526. }
  527. PTNODE vergleich(char f[])
  528. {
  529.   PTNODE wurzel;
  530.   wurzel=NULL;
  531.   wurzel=summe(f);
  532.  
  533. while ((aktchar==KL || aktchar==GR || aktchar==GL) && !TreeError)
  534.   {
  535.     if(aktchar==KL && f[AktPos] == GL) aktchar=KLGL;
  536.       else
  537.        if(aktchar==KL && f[AktPos] == GR) aktchar=UNGL;
  538.           else
  539.            if(aktchar==GR && f[AktPos] == GL) aktchar=GRGL;
  540.  
  541.           if(aktchar==KLGL || aktchar==UNGL || aktchar==GRGL) AktPos++;
  542.  
  543.     neuewurzel(&wurzel,f);
  544.     wurzel->RightAst=summe(f);
  545.   }
  546.   return wurzel;
  547. }
  548.  
  549. PTNODE verknuepf(char f[])
  550. {
  551.   PTNODE wurzel;
  552.   unsigned char token;
  553.   wurzel=NULL;
  554.   wurzel=vergleich(f);
  555.  
  556. while (LogicAusdruck(f,&token) && !TreeError)
  557.   {
  558.      aktchar=token;
  559.       AktPos++;
  560.      if(aktchar!=OR) AktPos++;
  561.     neuewurzel(&wurzel,f);
  562.     wurzel->RightAst=vergleich(f);
  563.   }
  564.   return wurzel;
  565. }
  566.  
  567. double cot(double x)
  568. {
  569.   double r_cot;
  570.  
  571.   if (frac(x/PI_HALBE)!=0) r_cot = 1 / tan(x);
  572.   return r_cot;
  573. }
  574.  
  575. double arccot(double x)
  576. {
  577.   double r_arccot;
  578.  
  579.   r_arccot=PI_HALBE-atan(x);
  580.   return r_arccot;
  581. }
  582.  
  583. double fsqr(double x)
  584. {
  585.   return x*x;
  586. }
  587.  
  588. double frac(double x)
  589. {
  590.   double d;
  591.   return modf(x,&d);
  592. }
  593.  
  594. double arctanh(double x)
  595. {
  596.   double r_arctanh;
  597.  
  598.   if (fabs(x)<1.0) r_arctanh=0.5*log((1.0+x)/(1.0-x));
  599.   return r_arctanh;
  600. }
  601.  
  602. float ran1(void)
  603. {
  604.  static long int a = 100001;
  605.  a = (a*125) % 2796203;
  606.  return((float) a/2796203);
  607.  
  608. }
  609. float ran2(void)
  610. {
  611.  static long int a = 1;
  612.  a = (a*32719+3) % 32749;
  613.  return((float) a/32749);
  614.  
  615. }
  616. float ran3(void)
  617. {
  618.  static long int a = 203;
  619.  a = (a*10001+3) % 1717;
  620.  return((float) a/1717);
  621. }
  622.  
  623. float random()
  624. {
  625. float f;
  626.  
  627.  f=ran3();
  628.  if(f>.5) return ran1();
  629.    else return ran2();
  630. }
  631.  
  632. void LiesDaten(void)
  633. {
  634. BYTE *Text;
  635. long cnt;
  636. char *FName;
  637.  
  638.  if ((FName = GetFileName()) != NULL)
  639.     fio = OpenFile((LPSTR)FName,(LPOFSTRUCT)&fileInfo,OF_READ);
  640.      else return;
  641.  
  642.    if(fio == -1)
  643.       {
  644.       PRINTF("# ERROR OPEN #");
  645.       return;
  646.       }
  647.  
  648.      if((cnt = filelength(fio)) == -1)
  649.       {
  650.       PRINTF("# ERROR READ #");
  651.       return;
  652.       }
  653.        if(cnt > 20000) return;
  654.   if ((hEditText = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,(unsigned) cnt + 3 )) == NULL)
  655.       {
  656.       PRINTF("# ERROR ALLOCATE #");
  657.       return;
  658.       }
  659.  if (read (fio,Text = LocalLock(hEditText),(unsigned) cnt) != (unsigned) cnt)
  660.    {
  661.     LocalUnlock(hEditText);
  662.     PRINTF("# ERROR LOCK #");
  663.     return;
  664.    }
  665.      bText=TRUE;
  666.   LocalUnlock(hEditText);
  667.   SendMessage(hWndEdit,EM_SETHANDLE,(WORD) hEditText,0L);
  668.  if(close(fio)==-1) return;
  669. }
  670.  
  671. void SaveDaten()
  672. {
  673. int cnt;
  674. char *FName;
  675. if ((FName = GetFileName()) != NULL)
  676.   fio = OpenFile( (LPSTR) FName,(LPOFSTRUCT) &fileInfo, OF_CREATE | OF_WRITE);
  677.    else return;
  678.   if (fio == -1)
  679.      return;
  680.  
  681.   if (((cnt =(unsigned) SendMessage(hWndEdit,WM_GETTEXTLENGTH,0,0l)) > 0) &&
  682.       ((hEditText = (HANDLE) SendMessage(hWndEdit,EM_GETHANDLE,0,0l)) != NULL))
  683.     {
  684.       if (write (fio, LocalLock(hEditText), cnt) != cnt)
  685.            {
  686.             LocalUnlock(hEditText);
  687.             return;
  688.            }
  689.       LocalUnlock(hEditText);
  690.     }
  691.   if (close(fio) == -1 ) return;
  692. }
  693.