home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 449a.lha / Plotter / src / Ableitung.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-02  |  21.8 KB  |  860 lines
  1.  /********************************************************************/
  2.  /****                                                            ****/
  3.  /****                                                            ****/
  4.  /****    Program          : Ableitung.c                          ****/
  5.  /****                                                            ****/
  6.  /****    Version          :    03.70                             ****/
  7.  /****                                                            ****/
  8.  /****    Erstversion      : 09.03.1990                           ****/
  9.  /****                                                            ****/
  10.  /****    Letzte Änderung  : 03.08.1990                           ****/
  11.  /****                                                            ****/
  12.  /****    Compiliert mit   : siehe MAKEFILE                       ****/
  13.  /****                                                            ****/
  14.  /****    Gelinkt mit      : siehe MAKEFILE                       ****/
  15.  /****                                                            ****/
  16.  /********************************************************************/
  17.  /****                                                            ****/
  18.  /****                                                            ****/
  19.  /****               Copyright by Rüdiger Dreier                  ****/
  20.  /****                                                            ****/
  21.  /****                                                            ****/
  22.  /********************************************************************/
  23.  
  24.  #ifdef DEBUG
  25.  #include "Plotter.h"
  26.  #include <proto/tool.h>
  27.  #endif
  28.  #include <string.h>
  29.  #include <exec/memory.h>
  30.  #include <proto/exec.h>
  31.  
  32.  #ifndef LAENGE
  33.  #define LAENGE 500
  34.  #endif
  35.  
  36.  char * __asm Ableiten(register __a0 char *string)
  37.   {
  38.    char Ergebnis[MAXCHARS];
  39.    char *EString;
  40.    
  41.    StartBlock=Init_Mem(string);
  42.    MatheFehler=Init_Block(StartBlock);
  43.    MatheFehler|=PreCalc(StartBlock,Konstantenstart);
  44.    EString=Ableitung(StartBlock);
  45.    strcpy(Ergebnis,EString);
  46.    Free_Block(StartBlock);
  47.    FreeMem(EString,LAENGE);
  48.    
  49.    return(Ergebnis);
  50.   }
  51.  
  52.  VOID __asm Umklammern(register __a0 char *string)
  53.   {
  54.    char *HILFE;
  55.    HILFE=AllocMem(LAENGE,MEMF_CLEAR);
  56.    if(HILFE==NULL)return;
  57.    
  58.    if(check('+','-',0L,(LONG)strlen(string),string)!=-1L)
  59.     {
  60.      HILFE[0]='(';
  61.      strcat(HILFE,string);
  62.      strcat(HILFE,")");
  63.      strcpy(string,HILFE);
  64.     }
  65.    FreeMem(HILFE,LAENGE);
  66.   }
  67.  
  68.  VOID __asm Umklammern_2(register __a0 char *string)
  69.   {
  70.    char *HILFE;
  71.    
  72.    Umklammern(string);
  73.    HILFE=AllocMem(LAENGE,MEMF_CLEAR);
  74.    if(HILFE==NULL)return;
  75.    
  76.    if(check('*','/',0L,(LONG)strlen(string),string)!=-1L)
  77.     {
  78.      HILFE[0]='(';
  79.      strcat(HILFE,string);
  80.      strcat(HILFE,")");
  81.      strcpy(string,HILFE);
  82.     }
  83.    FreeMem(HILFE,LAENGE);
  84.   }
  85.  
  86.  VOID Zusammensetzen(char *string,LONG Anzahl,char *ABL,struct Block *Start)
  87.   {
  88.    char *abgeleitet;
  89.    SHORT *a;
  90.    LONG Anz;
  91.    
  92.    abgeleitet=Ableitung(Start->Right);
  93.    strcpy(string,abgeleitet);
  94.    FreeMem(abgeleitet,LAENGE);
  95.    Umklammern(string);
  96.    
  97.    a=(SHORT *)string;
  98. /*   if(strcmp(string,"0")) */
  99.    if((0x3000!=*a))
  100.     {
  101.   /*   if(strcmp(string,"1")==NULL) */
  102.      if(0x3100==*a)
  103.       {
  104.        string[0]=0;
  105.       }
  106.      else
  107.       {
  108.        strcat(string,"*");
  109.       }
  110.      strcat(string,ABL);
  111.      Anz=Start->Rechts-Start->Links-Anzahl;
  112.      mid(&string[strlen(string)],Start->String,Start->Links+Anzahl+1,Anz);
  113.     }
  114.   }
  115.  
  116.  LONG __asm Mit_X(register __a0 struct Block *block)
  117.   {
  118.    LONG i,Flag=0;
  119.    i=block->Links;
  120.    while(i<=block->Rechts)
  121.     {
  122.      if(block->String[i]=='x')Flag++;
  123.      i++;
  124.     }
  125.    return(Flag);
  126.   }
  127.  
  128.  char * __asm Ableitung(register __a0 struct Block *Start)
  129.   {
  130.    LONG Anz;
  131.    char *links,*rechts,*abgeleitet,*HILFE;
  132.    
  133.    /* Speicher reservieren */
  134.    rechts=AllocMem(LAENGE,MEMF_CLEAR);
  135.    if(!rechts)return(0);
  136.    HILFE=AllocMem(LAENGE,MEMF_CLEAR);
  137.    if(!HILFE)return(0);
  138.    
  139.    switch(Start->RechenArt)
  140.     {
  141.      case ADDI:
  142.       {
  143.        SHORT *a;
  144.        /* u+v --> u' + v' */
  145.        /* Speicher reservieren */
  146.        links=AllocMem(LAENGE,MEMF_CLEAR);
  147.        if(!links)return(0);
  148.        
  149.        /* Ableitung von links */
  150.        abgeleitet=Ableitung(Start->Left);
  151.        strcpy(links ,abgeleitet);
  152.        FreeMem(abgeleitet,LAENGE);
  153.        Umklammern(links);
  154.        
  155.        /* Ableitung von rechts */
  156.        abgeleitet=Ableitung(Start->Right);
  157.        strcpy(rechts,abgeleitet);
  158.        FreeMem(abgeleitet,LAENGE);
  159.        Umklammern(rechts);
  160.        
  161.        /* Zusammenfügen */
  162.        /* 0+ wird nicht gebraucht */
  163.        a=(SHORT *)links;
  164.        /*if(strcmp(links,"0"))*/
  165.        if(0x3000!=*a)
  166.         {
  167.          a=(SHORT *)rechts;
  168.          /*if(strcmp(rechts,"0"))*/
  169.          if(0x3000!=*a)
  170.           {
  171.            /* +0 wird auch nicht gebraucht */
  172.            strcat(links,"+");
  173.            strcat(links,rechts);
  174.           }
  175.         }
  176.        else
  177.         {
  178.          /* Nur rechts nehmen */
  179.          strcpy(links,rechts);
  180.         }
  181.        
  182.        strcpy(rechts,links);
  183.        /* Wenn links und rechts 0 sind ... */
  184.        if(rechts[0]==0)
  185.         {
  186.          SHORT *a;
  187.          a=(SHORT *)rechts;
  188.          *a=0x3000;
  189.          /* rechts[0]='0';rechts[1]=0; */
  190.         }
  191.        FreeMem(links,LAENGE);
  192.        break;
  193.       }
  194.      
  195.      case SUBT:
  196.       {
  197.        SHORT *a;
  198.        /* u-v --> u' - v' */
  199.        /* Speicher reservieren */
  200.        links=AllocMem(LAENGE,MEMF_CLEAR);
  201.        if(!links)return(0);
  202.        
  203.        abgeleitet=Ableitung(Start->Left);
  204.        strcpy(links ,abgeleitet);
  205.        FreeMem(abgeleitet,LAENGE);
  206.        Umklammern(links);
  207.        
  208.        abgeleitet=Ableitung(Start->Right);
  209.        strcpy(rechts,abgeleitet);
  210.        FreeMem(abgeleitet,LAENGE);
  211.        Umklammern(rechts);
  212.        
  213.        /*if(strcmp(links,"0"))*/
  214.        a=(SHORT *)links;
  215.        if(0x3000!=*a)
  216.         {
  217.          a=(SHORT *)rechts;
  218.          /*if(strcmp(rechts,"0"))*/
  219.          if(0x3000!=*a)
  220.           {
  221.            strcat(links,"-");
  222.            strcat(links,rechts);
  223.           }
  224.         }
  225.        else
  226.         {
  227.          SHORT *a;
  228.          a=(SHORT *)links;
  229.          *a=0x2d00;
  230.          /* links[0]='-';
  231.          links[1]=0; */
  232.          strcat(links,rechts);
  233.         }
  234.        
  235.        strcpy(rechts,links);
  236.        /*if(!strcmp(rechts,""))*/
  237.        if(0==rechts[0])
  238.         {
  239.          SHORT *a;
  240.          a=(SHORT *)rechts;
  241.          *a=0x3000;
  242.          /* rechts[0]='0';rechts[1]=0; */
  243.         }
  244.        FreeMem(links,LAENGE);
  245.        break;
  246.       }
  247.      
  248.      case MULT:
  249.       {
  250.        SHORT *a;
  251.        /* u*v --> u*v' + u'*v */
  252.        /* Speicher reservieren */
  253.        links=AllocMem(LAENGE,MEMF_CLEAR);
  254.        if(!links)return(0);
  255.        
  256.        abgeleitet=Ableitung(Start->Left);
  257.        strcpy(links ,abgeleitet);
  258.        FreeMem(abgeleitet,LAENGE);
  259.        Umklammern(links);
  260.        
  261.        abgeleitet=Ableitung(Start->Right);
  262.        strcpy(rechts,abgeleitet);
  263.        FreeMem(abgeleitet,LAENGE);
  264.        Umklammern(rechts);
  265.        
  266.        a=(SHORT *)rechts;
  267.        /*if(strcmp(rechts,"0"))*/
  268.        if(0x3000!=*a)
  269.         {
  270.          Anz=Start->Left->Rechts-Start->Left->Links+1;
  271.          mid(HILFE,Start->String,Start->Left->Links,Anz);
  272.          a=(SHORT *)rechts;
  273.          /*if(strcmp(rechts,"1"))*/
  274.          if(0x3100!=*a)
  275.           {
  276.            Umklammern(HILFE);
  277.            if(Vereinfachung(rechts,HILFE))
  278.             {
  279.              rechts[0]=0;
  280.             }
  281.            else
  282.             {
  283.              strcat(rechts,"*");
  284.             }
  285.           }
  286.          else
  287.           {
  288.            rechts[0]=0;
  289.           }
  290.          strcat(rechts,HILFE);
  291.         }
  292.        
  293.        a=(SHORT *)links;
  294.        /*if(strcmp(links,"0"))*/
  295.        if(0x3000!=*a)
  296.         {
  297.          SHORT *a,*b;
  298.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  299.          mid(HILFE,Start->String,Start->Right->Links,Anz);
  300.          a=(SHORT *)links;
  301.          /*if(strcmp(links,"1"))*/
  302.          if(0x3100!=*a)
  303.           {
  304.            Umklammern(HILFE);
  305.            if(Vereinfachung(links,HILFE))
  306.             {
  307.              links[0]=0;
  308.             }
  309.            else
  310.             {
  311.              strcat(links,"*");
  312.             }
  313.           }
  314.          else
  315.           {
  316.            links[0]=0;
  317.           }
  318.          strcat(links,HILFE);
  319.          a=(SHORT *)links;
  320.          b=(SHORT *)rechts;
  321.          /*if(strcmp(links,"0") && strcmp(rechts,"0")) */
  322.          if((0x3000!=*a) && (0x3000!=*b))
  323.           {
  324.            strcat(links,"+");
  325.            strcat(links,rechts);
  326.           }
  327.          strcpy(rechts,links);
  328.         }
  329.        FreeMem(links,LAENGE);
  330.        break;
  331.       }
  332.      
  333.      case DIVI:
  334.       {
  335.        SHORT *a;
  336.        /* u/v --> (u'*v - u*v')/v^2           */
  337.        /* Speicher reservieren */
  338.        links=AllocMem(LAENGE,MEMF_CLEAR);
  339.        if(!links)return(0);
  340.        
  341.        abgeleitet=Ableitung(Start->Left);
  342.        strcpy(links ,abgeleitet);
  343.        FreeMem(abgeleitet,LAENGE);
  344.        Umklammern(links);
  345.        
  346.        abgeleitet=Ableitung(Start->Right);
  347.        strcpy(rechts,abgeleitet);
  348.        FreeMem(abgeleitet,LAENGE);
  349.        Umklammern(rechts);
  350.        
  351.        a=(SHORT *)rechts;
  352.        /*if(strcmp(rechts,"0"))*/
  353.        if(0x3000!=*a)
  354.         {
  355.          Anz=Start->Left->Rechts-Start->Left->Links+1;
  356.          mid(HILFE,Start->String,Start->Left->Links,Anz);
  357.          /*if(strcmp(rechts,"1"))*/
  358.          if(0x3100!=*a)
  359.           {
  360.            Umklammern(HILFE);
  361.            strcat(rechts,"*");
  362.           }
  363.          else
  364.           {
  365.            rechts[0]=0;
  366.           }
  367.          strcat(rechts,HILFE);
  368.         }
  369.        
  370.        a=(SHORT *)links;
  371.        /*if(strcmp(links,"0"))*/
  372.        if(0x3000!=*a)
  373.         {
  374.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  375.          mid(HILFE,Start->String,Start->Right->Links,Anz);
  376.          /*if(strcmp(links,"1"))*/
  377.          if(0x3100!=*a)
  378.           {
  379.            Umklammern(HILFE);
  380.            strcat(links,"*");
  381.           }
  382.          else
  383.           {
  384.            links[0]=0;
  385.           }
  386.          strcat(links,HILFE);
  387.         }
  388.        
  389.        if(strcmp(links,rechts))
  390.         {
  391.          SHORT *a;
  392.          Umklammern(rechts);
  393.          a=(SHORT *)links;
  394.          /*if(strcmp(links,"0"))*/
  395.          if(0x3000!=*a)
  396.           {
  397.            a=(SHORT *)rechts;
  398.            /*if(strcmp(rechts,"0"))*/
  399.            if(0x3000!=*a)
  400.             {
  401.              strcat(links,"-");
  402.              strcat(links,rechts);
  403.             }
  404.           }
  405.          else
  406.           {
  407.            a=(SHORT *)rechts;
  408.            /*if(strcmp(rechts,"0"))*/
  409.            if(0x3000!=*a)
  410.             {
  411.              SHORT *a;
  412.              a=(SHORT *)links;
  413.              *a=0x2d00;
  414.              /* links[0]='-';
  415.              links[1]=0; */
  416.              strcat(links,rechts);
  417.             }
  418.           }
  419.          strcpy(rechts,links);
  420.         }
  421.        else
  422.         {
  423.          SHORT *a;
  424.          a=(SHORT *)rechts;
  425.          *a=0x3000;
  426.          
  427.          /* rechts[0]='0';rechts[1]=0; */
  428.         }
  429.        a=(SHORT *)rechts;
  430.        /*if(strcmp(rechts,"0"))*/
  431.        if(0x3000!=*a)
  432.         {
  433.          Umklammern(rechts);
  434.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  435.          mid(HILFE,Start->String,Start->Right->Links,Anz);
  436.          Umklammern(HILFE);
  437.          strcat(HILFE,"^2");
  438.          strcat(rechts,"/");
  439.          strcat(rechts,HILFE);
  440.         }
  441.        FreeMem(links,LAENGE);
  442.        break;
  443.       }
  444.      
  445.      case POWE:
  446.       {
  447.        /* Speicher reservieren */
  448.        links=AllocMem(LAENGE,MEMF_CLEAR);
  449.        if(!links)return(0);
  450.        Anz=0;
  451.        if(Mit_X(Start->Right))Anz=1;
  452.        if(Mit_X(Start->Left ))Anz+=2;
  453.        switch(Anz)
  454.         {
  455.          case 0:
  456.           {
  457.            /* Von X nicht abhängig */
  458.            /* rechts[0]='0';rechts[1]=0; */
  459.            SHORT *a;
  460.            a=(SHORT *)rechts;
  461.            *a=0x3000;
  462.            break;
  463.           }
  464.          case 2:
  465.           {
  466.            SHORT *a;
  467.            /* Basis von X abhängig */
  468.            /* x^a --> a*x^(a-1) */
  469.            Anz=Start->Right->Rechts-Start->Right->Links+1;
  470.            mid(HILFE,Start->String,Start->Right->Links,Anz);
  471.            Umklammern(HILFE);
  472.            abgeleitet=Ableitung(Start->Left);
  473.            strcat(links ,abgeleitet);
  474.            FreeMem(abgeleitet,LAENGE);
  475.            Umklammern(links);
  476.            a=(SHORT *)links;
  477.            /*if(strcmp(links,"1"))*/
  478.            if(0x3100!=*a)
  479.             {
  480.              strcat(links,"*");
  481.             }
  482.            else
  483.             {
  484.              links[0]=0;
  485.             }
  486.            strcat(links,HILFE);
  487.            strcat(links,"*");
  488.            Anz=Start->Left->Rechts-Start->Left->Links+1;
  489.            mid(HILFE,Start->String,Start->Left->Links,Anz);
  490.            Umklammern_2(HILFE);
  491.            strcat(links,HILFE);
  492.            strcat(links,"^(");
  493.            Anz=Start->Right->Rechts-Start->Right->Links+1;
  494.            mid(rechts,Start->String,Start->Right->Links,Anz);
  495.            strcat(rechts,"-1)");
  496.            strcat(links,rechts);
  497.            strcpy(rechts,links);
  498.            break;
  499.           }
  500.          case 1:
  501.           {
  502.            SHORT *a;
  503.            /* a^x --> a^x*ln(a) */
  504.            abgeleitet=Ableitung(Start->Right);
  505.            strcpy(rechts,abgeleitet);
  506.            FreeMem(abgeleitet,LAENGE);
  507.            Umklammern(rechts);
  508.            a=(SHORT *)rechts;
  509.            /*if(strcmp(rechts,"1"))*/
  510.            if(0x3100!=*a)
  511.             {
  512.              strcat(rechts,"*");
  513.             }
  514.            else
  515.             {
  516.              rechts[0]=0;
  517.             }
  518.            /* Die Originalfunktion wieder zusammenstellen */
  519.            Anz=Start->Left->Rechts-Start->Left->Links+1;
  520.            mid(links,Start->String,Start->Left->Links,Anz);
  521.            Umklammern_2(links);
  522.            strcat(rechts,links);
  523.            strcat(rechts,"^");
  524.            Anz=Start->Right->Rechts-Start->Right->Links+1;
  525.            mid(HILFE,Start->String,Start->Right->Links,Anz);
  526.            Umklammern_2(HILFE);
  527.            strcat(rechts,HILFE);
  528.            strcat(rechts,"*ln(");
  529.            strcat(rechts,links);
  530.            strcat(rechts,")");
  531.            break;
  532.           }
  533.          case 3:
  534.           {
  535.            struct Block *New_START;
  536.            char *NewFunc;
  537.            /* 15.07.90: Fehler beseitigt. f(x) und g(x) waren vertauscht */
  538.            /* f(x)^g(x) <=> e^(ln(f(x)^g(x)))    */
  539.            /* <=> e^g(x)*ln(f(x))                */
  540.            /* Abgeleitet =>                      */
  541.            /* (g(x)*ln(f(x)))'*e^g(x)*ln(f(x))   */
  542.            /* <=> (g(x)*ln(f(x)))'*f(x)^g(x)     */
  543.            /* Die Ableitung wird rekur. gebildet */
  544.            
  545.            Anz=Start->Right->Rechts-Start->Right->Links+1;
  546.            mid(HILFE,Start->String,Start->Right->Links,Anz);
  547.            Umklammern_2(HILFE);
  548.            strcpy(links,HILFE);
  549.            strcat(links,"*ln(");
  550.            Anz=Start->Left->Rechts-Start->Left->Links+1;
  551.            mid(HILFE,Start->String,Start->Left->Links,Anz);
  552.            strcat(links,HILFE);
  553.            strcat(links,")");
  554.            
  555.            New_START=Init_Mem(links);
  556.            
  557.            if(!New_START)return(0);
  558.            Anz=Init_Block(New_START);
  559.            
  560.            NewFunc=Ableitung(New_START);
  561.            
  562.            strcpy(rechts,NewFunc);
  563.            FreeMem(NewFunc,LAENGE);
  564.            Free_Block(New_START);
  565.            
  566.            Umklammern(rechts);
  567.            strcat(rechts,"*");
  568.            
  569.            /* Die Originalfunktion wieder zusammenstellen */
  570.            Anz=Start->Left->Rechts-Start->Left->Links+1;
  571.            mid(links,Start->String,Start->Left->Links,Anz);
  572.            Umklammern_2(links);
  573.            
  574.            strcat(rechts,links);
  575.            strcat(rechts,"^");
  576.            Anz=Start->Right->Rechts-Start->Right->Links+1;
  577.            mid(HILFE,Start->String,Start->Right->Links,Anz);
  578.            Umklammern_2(HILFE);
  579.            
  580.            strcat(rechts,HILFE);
  581.           }
  582.         }
  583.        FreeMem(links,LAENGE);
  584.        break;
  585.       }
  586.      
  587.      case SINU:
  588.       {
  589.        /* sin(x) --> cos(x) */
  590.        Zusammensetzen(rechts,3,"cos(",Start);
  591.        break;
  592.       }
  593.      
  594.      case COSI:
  595.       {
  596.        SHORT *a;
  597.        /* cos(x) --> -sin(x) */
  598.        Zusammensetzen(rechts,3,"sin(",Start);
  599.        a=(SHORT *)rechts;
  600.        /*if(strcmp(rechts,"0"))*/
  601.        if(0x3000!=*a)
  602.         {
  603.          SHORT *a;
  604.          a=(SHORT *)HILFE; /* Hilfe = '-'; */
  605.          *a=0x2d00;
  606.          
  607.          strcat(HILFE,rechts);
  608.          strcpy(rechts,HILFE);
  609.         }
  610.        break;
  611.       }
  612.      
  613.      case TANG:
  614.       {
  615.        SHORT *a;
  616.        /* tan(x) --> 1/cos^2(x) */
  617.        abgeleitet=Ableitung(Start->Right);
  618.        strcpy(rechts,abgeleitet);
  619.        FreeMem(abgeleitet,LAENGE);
  620.        Umklammern(rechts);
  621.        a=(SHORT *)rechts;
  622.        /*if(strcmp(rechts,"0"))*/
  623.        if(0x3000!=*a)
  624.         {
  625.          strcat(rechts,"/cos(");
  626.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  627.          mid(&rechts[strlen(rechts)],Start->String,Start->Right->Links,Anz);
  628.          strcat(rechts,")^2");
  629.         }
  630.        break;
  631.       }
  632.      
  633.      case ASIN:
  634.       {
  635.        SHORT *a;
  636.        /* asin --> 1/sqr(1-x^2) */
  637.        abgeleitet=Ableitung(Start->Right);
  638.        strcpy(rechts,abgeleitet);
  639.        FreeMem(abgeleitet,LAENGE);
  640.        Umklammern(rechts);
  641.        a=(SHORT *)rechts;
  642.        /*if(strcmp(rechts,"0"))*/
  643.        if(0x3000!=*a)
  644.         {
  645.          strcat(rechts,"/sqr(1-");
  646.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  647.          mid(&rechts[strlen(rechts)],Start->String,Start->Right->Links,Anz);
  648.          strcat(rechts,"^2)");
  649.         }
  650.        break;
  651.       }
  652.      
  653.      case ACOS:
  654.       {
  655.        SHORT *a;
  656.        /* acos(x) --> -1/sqr(1-x^2) */
  657.        abgeleitet=Ableitung(Start->Right);
  658.        strcpy(rechts,abgeleitet);
  659.        FreeMem(abgeleitet,LAENGE);
  660.        Umklammern(rechts);
  661.        a=(SHORT *)rechts;
  662.        /*if(strcmp(rechts,"0"))*/
  663.        if(0x3000!=*a)
  664.         {
  665.          strcat(rechts,"/sqr(1-");
  666.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  667.          mid(&rechts[strlen(rechts)],Start->String,Start->Right->Links,Anz);
  668.          strcat(rechts,"^2)");
  669.         }
  670.        if(0x3000!=*a)
  671.        /*if(strcmp(rechts,"0"))*/
  672.         {
  673.          /*strcpy(HILFE,"-");*/
  674.          SHORT *a;
  675.          a=(SHORT *)HILFE;
  676.          *a=0x2d00;
  677.          
  678.          strcat(HILFE,rechts);
  679.          strcpy(rechts,HILFE);
  680.         }
  681.        break;
  682.       }
  683.      
  684.      case ATAN:
  685.       {
  686.        SHORT *a;
  687.        /* atan(x) --> 1/(1+x^2) */
  688.        abgeleitet=Ableitung(Start->Right);
  689.        strcpy(rechts,abgeleitet);
  690.        FreeMem(abgeleitet,LAENGE);
  691.        Umklammern(rechts);
  692.        a=(SHORT *)rechts;
  693.        /*if(strcmp(rechts,"0"))*/
  694.        if(0x3000!=*a)
  695.         {
  696.          strcat(rechts,"/(1+");
  697.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  698.          mid(&rechts[strlen(rechts)],Start->String,Start->Right->Links,Anz);
  699.          strcat(rechts,"^2)");
  700.         }
  701.        break;
  702.       }
  703.      
  704.      case LOG1:
  705.       {
  706.        SHORT *a;
  707.        /* log(x) --> 1/(x*ln10) */
  708.        abgeleitet=Ableitung(Start->Right);
  709.        strcpy(rechts,abgeleitet);
  710.        FreeMem(abgeleitet,LAENGE);
  711.        Umklammern(rechts);
  712.        a=(SHORT *)rechts;
  713.        /*if(strcmp(rechts,"0"))*/
  714.        if(0x300!=*a)
  715.         {
  716.          strcat(rechts,"/(");
  717.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  718.          mid(&rechts[strlen(rechts)],Start->String,Start->Right->Links,Anz);
  719.          strcat(rechts,"*");
  720.          strcat(rechts,"ln(10))");
  721.         }
  722.        break;
  723.       }
  724.      
  725.      case LNAT:
  726.       {
  727.        SHORT *a;
  728.        /* ln(x) --> 1/x */
  729.        abgeleitet=Ableitung(Start->Right);
  730.        strcpy(rechts,abgeleitet);
  731.        FreeMem(abgeleitet,LAENGE);
  732.        Umklammern(rechts);
  733.        a=(SHORT *)rechts;
  734.        /*if(strcmp(rechts,"0"))*/
  735.        if(0x3000!=*a)
  736.         {
  737.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  738.          mid(HILFE,Start->String,Start->Right->Links,Anz);
  739.          strcat(rechts,"/");
  740.          Umklammern_2(HILFE);
  741.          
  742.          strcat(rechts,HILFE);
  743.         }
  744.        break;
  745.       }
  746.      
  747.      case ABSO:
  748.       {
  749.        /* Kann man drüber diskutieren.... */
  750.        /* abs(x) --> sgn(x) */
  751.        Zusammensetzen(rechts,3,"sgn(",Start);
  752.        break;
  753.       }
  754.      
  755.      case SQRT:
  756.       {
  757.        SHORT *a;
  758.        /* sqr(x) --> 1/2*x^-1/2 */
  759.        abgeleitet=Ableitung(Start->Right);
  760.        strcpy(rechts,abgeleitet);
  761.        FreeMem(abgeleitet,LAENGE);
  762.        Umklammern(rechts);
  763.        a=(SHORT *)rechts;
  764.        /*if(strcmp(rechts,"0"))*/
  765.        if(0x3000!=*a)
  766.         {
  767.          /*if(!strcmp(rechts,"1"))*/
  768.          if(0x3100==*a)
  769.           {
  770.            SHORT *a;
  771.            a=(SHORT *)rechts;
  772.            *a=0x3100;
  773.            
  774.            /* rechts[0]='1';rechts[1]=0; */
  775.           }
  776.          strcat(rechts,"/2*");
  777.          Anz=Start->Right->Rechts-Start->Right->Links+1;
  778.          mid(HILFE,Start->String,Start->Right->Links,Anz);
  779.          Umklammern_2(HILFE);
  780.          strcat(rechts,HILFE);
  781.          strcat(rechts,"^(-1/2)");
  782.         }
  783.        break;
  784.       }
  785.      
  786.      case FLOO:
  787.      case ZIFF:
  788.      case UKON:
  789.      case MKON:
  790.      case SIGU:
  791.       {
  792.        SHORT *a;
  793.        a=(SHORT *)rechts;
  794.        *a=0x3000;
  795.        
  796.        /* rechts[0]='0';rechts[1]=0; */
  797.        break;
  798.       }
  799.      
  800.      case X:
  801.       {
  802.        SHORT *a;
  803.        a=(SHORT *)rechts;
  804.        *a=0x3100;
  805.        
  806.        /* rechts[0]='1';rechts[1]=0; */
  807.        break;
  808.       }
  809.      default:
  810.       {
  811.        /* FEHLER, es sollten alle Fälle abgedeckt sein */
  812.       }
  813.     }
  814.    FreeMem(HILFE,LAENGE);
  815.    return(rechts);
  816.   }
  817.  
  818.  
  819.  /* Funktion, die den Term a/b*b auf a vereinfacht                        */
  820.  /* Wenn b von x abhängig ist, dann stimmt das so eigentlich nur für b<>0 */
  821.  LONG __asm Vereinfachung(register __a0 char *a,
  822.                           register __a1 char *b)
  823.   {
  824.    char *HILFE;
  825.    LONG Pos,Flag=0;
  826.    
  827.    Umklammern(a);
  828.    Umklammern(b);
  829.    
  830.    HILFE=AllocMem(LAENGE,MEMF_CLEAR);
  831.    if(!HILFE)return(0);
  832.    
  833.    if(Pos=check('/','/',0L,(LONG)strlen(a),a)!=-1L)
  834.     {
  835.      strcpy(HILFE,&a[Pos+1]);
  836.      if(!strcmp(HILFE,b))
  837.       {
  838.        left(HILFE,a,Pos);
  839.        Flag=1;
  840.       }
  841.     }
  842.    
  843.    if(Pos=check('/','/',0L,(LONG)strlen(b),b)!=-1L)
  844.     {
  845.      strcpy(HILFE,&b[Pos+1]);
  846.      if(!strcmp(HILFE,a))
  847.       {
  848.        left(HILFE,b,Pos);
  849.        Flag=1;
  850.       }
  851.     }
  852.    if(Flag)strcpy(b,HILFE);
  853.    
  854.    FreeMem(HILFE,LAENGE);
  855.    return(Flag);
  856.   }
  857.  
  858.  
  859.  
  860.