Eingabe von Termen

Dieses Programm ist in der Lage, einen von der Tastatur eingegebenen mathematischen Term zu analysieren und zu berechnen. Es beherrscht die Addition, die Subtraktion, die Klammerrechnung, die Potenzrechnung, die Multiplikation, die Division und verarbeitet einfache komplexe Zahlen. Weiter kann es trigonometrische Funktionen berechnen. Dieser Parser setzt die eingegebenen Komponenten sehr schnell zum gewünschten Ergebnis zusammen.

Das Programm hat viele Anwendungsmöglichkeiten. Es kann sowohl von Schülern, Studenten und weniger versierten Anwendern, als auch von Fachleuten in den unterschiedlichsten Branchen eingesetzt werden und unterstützt die verschiedensten Rechenprobleme des Alltags. Die Bedienung des Interpreters ist dem des im Direktmodus laufenden GFA-BASIC sehr ähnlich. Es können alle Rechenoperationen, die im Startup-Menü angegeben sind, verwendet werden, z.B *,-,+ usw. Häufig vorkommende Zahlen in der Mathematik sind ebenfalls integriert, wie z.B “pi” und “e”. Die aufgeführten Sonderfunktionen “sin,cos,abs...” können wie in der linken Reihe angegeben benützt werden. Hier einige Beispiele.

Diese Terme können wie folgt eingegeben werden:

1.) OK->1+1-6 oder OK->(1+1)-6 oder OK->((1+1)-+6)
2.) OK->2/9+6 oder OK->(2/9)+6 oder OK->((2/9)+6)
3.) OK->29+4A5 oder OK->(29)+(4^5) oder OK->((2*9)+4^5)

Der Interpreter beherrscht auch ohne Klammerrechnung die Regeln der Mathematik. Natürlich kann man sie durch Setzen von Klammem umgehen.

Es werden weiterhin die Vorzeichen berücksichtigt, die im Term vorkommen z.B :

OK->--5+6 oder OK->5+-8

u.s.w siehe Beispiel oben. Einige Beispiele zu den Sonderfunktionen. Der sin(45) soll berechnet werden:

1.) OK->s(45) oder OK->s45 (Ergebnis in Grad)

Alle anderen Sonderfunktionen werden wie bei “sin” eingegeben, nur mit dem ersten kleinen Buchstaben.

2.) OK->c(80)OK->t(80) OK->w(6) usw.

Sonderfunktionen kombinieren

Das ist aber noch nicht alles, was das Programm kann! Alle Sonderfunktionen können natürlich auch beliebig miteinander kombiniert werden:

z.B: OK->a(c(45)A2+s(45)A2) usw.

Der Interpreter prüft, ob ein Term richtig eingegeben ist, indem er einen kompletten “Syntax-Check” durchführt. Auftretende Fehler werden größtenteils abgefangen.

z.B: OK->-*+ oder OK->1/0 oder OK->((((((((1+6) usw.

Es können auch Variabeln definiert werden, und zwar alle GROSSBUCHSTABEN von A-Z, das sieht dann so aus :

OK->A=5 oder OK->D=s(7)+5*9 oder OK->L=d(7) usw.

Eine weitere Attraktion weist der Parser auf: Er ist in der Lage, einfache komplexe Zahlen zu verarbeiten. Es ist möglich, eine negative Wurzel oder einen negativen Logarithmus zu berechnen.

Beispiel: es soll die 2.te Wurzel aus (-8) berechnet werden

OK->w(-8) oder OK->(-8)^(1/2) oder OK->-8^(1/2)

Es erscheint eine komplexe Lösung, die aus einer imaginären und reellen Lösung besteht. Es soll eine 8. Wurzel aus einer negativen Zahl berechnet werden.

Das sieht dann so aus: OK->(-5)^(1/8) usw.

Es können alle negativen Zahlen mit allen Elementen der natürlichen Zahlen potenziert werden: Vorsicht: den Exponenten nicht als Dezimalzahl schreiben, (-8)^(0.5) z.B. führt zum Überlauf!

OK->(-21)^(5/16) usw.

Eine Logarithmierung einer negativen Zahl ist ebenfalls möglich, das sieht dann so aus:

OK->l(-9) oder OK-> d (-9) oder OK->d-9.

Klammern sind in diesem Fall auch nicht nötig. Es erscheinen komplexe Lösungen von zl -zn, die aus imaginären und reellen Lösungen bestehen. Ich hoffe, daß einige Anwender dieses Programm verwerten können. Mit einem kleinen Tip möchte ich diese Dokumentation zu meinem Programm schließen: Der Parser-Interpreter macht sich gut in einem Tabellenkalkulations-Programm!

' ----------------------------------------------
' Parse Interpreter written by P.S. Bauer, 
' Romberstr.8 , 5000 Köln 41 
' Version 4.00 08.05.89
' (c) MAXON Computer GmbH
' ----------------------------------------------
DIM var$(60)
SETCOLOR 0,0
DO                      ! Menu Steuerung
    @text
    v=INP(2)            ! Tastaturklick
    IF v=27             ! ESC Taste
        SETCOLOR 0,1 
        END 
    ENDIF
    CLS                 ! Bild Löschen
    DO
        ADD pose,3      ! Icon Lage OK=>
        IF pose>=24     ! Letzte Zeile
            pose=3      ! 3 Addieren (Zeile+3)
            CLS         ! Bild Löschen
            IF LEN(re$)>0
                PRINT AT (1,2+pose); ! Icon setzen
                PRINT "OK >"
                PRINT AT(5,2+pose);unt$ ! Term
                PRINT re$               ! Ergebnis falls schon vorhanden
                pose=pose+3
            ENDIF
        ENDIF
        @eingabe            ! Zur Hauptschleife
        EXIT IF ASC(re$)=27 ! Esc
    LOOP
    CLR re$ ! Ergebnis Löschen
    pose=0 ! zeile =0
    CLS 
LOOP
PROCEDURE eingabe ! Hauptprozedur
    GRAPHMODE 4 
    DEFTEXT 1,0,0,13
    TEXT 5,15,"       Bitte Term Eingeben       "
    TEXT 5,31,"          mit Esc zurück         "
    GRAPHMODE 0 
    ERASE sx$()
    DIM sx$(80)         !Feld vorbereiten
    nrt:
    DEFFILL 1,2,8       ! Daten für falsche Syntax
    tabe%=0             ! Syntax Flag=0 
    sqo:
    DATA "*)","(*","(/","(^","()","**","//","ss","ww","cc","tt","^^","sw","tw","cw"
    DATA "/)","^)","/)","s)","w)","c)","t)","+)", "-)","..",".)","(.",".(",")."
    DATA "-.","./","s.",".s","w.",".c",".t","w.","c.","t.","+.","*.","/.","^.",".^"
    DATA ".-",".+",".*","./","a)","i)",".a",".i",")a",")i","ia","is","ic","it","iw"
    DATA "aa","ii","sa","ca","ta","wa","i+","i-","i*","i^","i/","a-","a+","a*","a/","a^"
    DATA "d*","d/","d)",".d","d.",")d","di","da","ds","dc","dt","dw","d^"
    DATA "l+","l*","l/","l)",".l","l.",")l","li","la","ls","lc","lt","lw"
    DATA "1^","ld","/*","/^"
    PRINT AT(1,2+pose); ! Icon positonieren
    PRINT "OK >"
    PRINT AT(5,2+pose);
    FORM INPUT 40,re$   ! Term Eingeben
    unt$=re$            ! Unt$=term
    IF INSTR(1,re$,"=")>0 ! Variablen Untersuchen 
        IF LEN(re$)>=1 AND ASC(re$)<65 OR ASC(re$)>90 
            tabe%=1
        ENDIF               ! Var zuordnen?
        lio%=INSTR(1,re$,)+1
        IF INSTR(1,re$,"=")>0 AND ASC(re$)>=65 AND ASC(re$)<=90 
            IF LEN(STR$(VAL(MID$(re$,lio%,LEN(re$)))))=LEN(MID$(re$,lio%,LEN(re$))) AND VAL(MID$(re$,lio%,LEN(re$)))>0 
                @variable
                re$=MID$(re$,lio%,LEN(re$)) ! String erneuern
            ELSE
                varflag%=1 ! Variable Flag Setzen
                varterm$=MID$(re$,0,lio%-1) ! Termvariable Bestimmen 
                re$=MID$(re$,lio%,LEN(re$)) ! Term Retten wenn Var Vorhanden
            ENDIF 
        ELSE
            tabe%=1     ! Oh oh Fehler
        ENDIF 
    ENDIF
    IF ASC(re$)<>27     ! ESC untersuchen
        IF LEN(re$)>0   ! Exp und E unterschieden
            CLR anzklam%,anzklam2%
            IF INSTR(0,re$,"E")>0
                exop$=MID$(re$,INSTR(0,re$,"E")-1,1)
            ENDIF
            FOR varwo%=1 TO LEN(re$)
                FOR wova%=ASC("A")-65 TO ASC("Z")-65 
                    obvar%=INSTR(varwo%,re$,CHR$(wova%+65)) !wo ist eine variable ?
                    IF INSTR(0,re$,"E")>0 AND ASC(exop$)>ASC("0") AND ASC(exop$)<=ASC("9") 
                        obvar%=0 
                    ENDIF
                    IF obvar%>0     ! Wert in Var einsetzen 
                        re$=MID$(re$,0,obvar%-1)+var$(wova%)+MID$(re$,obvar%+1,LEN(re$))
                    ENDIF 
                NEXT wova%
            NEXT varwo%
            CLR lop$
            pei%=INSTR(wobin%,re$,"pi") !wo ist pi ?
            IF pei%>0
                re$=MID$(re$,0,pei%-1)+STR$(PI)+MID$(re$,pei%+2,LEN(re$))
            ENDIF
            expo%=INSTR(wobin%,re$,"e") ! wo ist e
            IF expo%>0
                re$=MID$(re$,0,expo%-1)+STR$(EXP(1))+MID$(re$,expo%+1,LEN(re$))
            ENDIF
            IF INSTR(1,re$," ") >0 ! Leerstellen suchen 
                FOR spce%=1 TO LEN(re$) 
                    ase$=MID$(re$,spce%, 1)
                    IF ase$<>CHR$(32) ! selbe entfernen
                        f$=f$+ase$
                    ENDIF 
                NEXT spce% 
                re$=f$
            ENDIF
            FOR synklam%=0 TO LEN(re$)  ! Anzahl Klammern Überprüfen 
                IF MID$(re$,synklam%+1,1)="("           !(
                    ADD anzklam%,1  !( ist gefunden
                ENDIF
                IF MID$(re$,LEN(re$)-synklam%,1)=")"    !)
                    ADD anzklam2%,1 !) ist gefunden
                ENDIF 
            NEXT synklam%
            IF anzklam%<>anzklam2%  ! Klammer vergessen ?
                tabe%=1             ! Syntax Flag=1
            ENDIF
            IF LEN(re$)>0           ! Syntax prüfen
                FOR pol%=1 TO LEN(re$)
                    polx%=ASC(MID$(re$,pol%,1))     ! String aufspalten 
                    IF polx%>57 OR polx%<=36 AND polx%<>94 AND polx%<>46 AND polx%<>115 AND polx%<>99 AND polx%<>116 AND polx%<>119 AND polx%<>105 AND polx%<>97 AND polx%<>100 AND polx%<>108 AND polx%<>69 
                        tabe%=1     ! Syntaxfehler Flag=1
                    ENDIF
                    EXIT IF polx%>57 OR polx%<=36 AND polx%<>94 AND polx%<>46 AND polx%<>115 AND polx%<>99 AND polx%Oll6 AND polx%<>119 AND polx%<>105 AND polx%<>97 AND polx%<>100 AND polx%<>108 AND polx%<>69 
                NEXT pol%
                RESTORE sqo
                FOR g=0 TO 107          ! Syntaxdata Einlesen
                    READ syntax$
                    IF INSTR(1,re$,syntax$)>0 
                        IF syntax$<>"/0"
                            tabe%=1     ! Falls Fehler Syntax Flag=1 
                        ENDIF 
                    ENDIF
                    EXIT IF INSTR(1,re$,syntax$)>0 
                NEXT g
                IF tabe%=1              ! Syntax Anzeigen
                    PRINT "Syntax Fehler "
                    ADD pose,3          ! nächste Position
                    GOTO nrt            ! Neu eingeben
                ENDIF 
                @fidel
                IF INSTR(1,re$,")")>0 AND INSTR(1,re$,"(")>0 ! Klammer erkennen
                    hint%=LEN(re$) 
                    c$=re$
                    DO
                        IF INSTR(1,C$,"(")>0 AND INSTR(1,C$, ")")>0 ! Klammer auswerten 
                            suche%=LEN(c$)
                            DO          ! Klammer von Innen nach Aussen
                                SUB suche%,1
                                hint%=INSTR(suche%,c$,"(")
                                EXIT IF hint%>0 
                            LOOP
                            CLR suche%
                            tor%=INSTR(hint%+1,c$,")")  ! ) Entfernen
                            re$=MID$(c$,hint%+1,tor%) 
                            tor2%=INSTR(1,re$,")")      ! ( Entfernen
                            re$=MID$(re$,1,tor2%-1)     ! String ohne ()
                        ENDIF
                        @fidel
                        @num
                        c$=MID$(c$,0,hint%-1)+SPACE$(LEN(re$))+MID$(c$,tor%+1,LEN(c$))
                        MID$(c$,hint%,LEN(re$))=re$     ! String zusammenbauen 
                        EXIT IF INSTR(1,C$,")")=0 AND INSTR(1,C$,"(")=0
                    LOOP
                    re$=c$      !String retten
                ENDIF 
                @fidel 
                @num
                DEFFILL 1,2,8
                IF varflag%=1   ! Termflag abfrage
                    var$(ASC(varterm$)-65)=re$ ! Termvar setzen 
                    varflag%=0  ! Flag auf Null
                ENDIF
                IF nuuld%=0 AND llog%=0
                    PRINT re$   ! und ausgeben
                ENDIF
                CLR nuuld%,llog%
            ENDIF
        ENDIF
    ENDIF
    DEFFILL 1,2,8
    CLR sc$,rb$
    ERASE sx$()
RETURN
PROCEDURE num               ! Hier werden die Rechnungen ausgeführt
    tabe%=0
    DO
        EXIT IF INSTR(1,re$,"i")=0 ! Integer
        ADD w,1
        IF sx$(w)="i"       ! ist i dabei
            eg=LEN(sx$(w+1))
            isr=INSTR(1,re$,"i") ! wo ist i
            we=1+LEN(sx$(w+1))
            sx$(w-1)=STR$(INT(VAL(sx$(w+1)))) ! Ausführen
            @ordner 
            @fidel 
            CLR w 
        ENDIF 
    LOOP 
    DO
        EXIT IF INSTR(1,re$,"a")=0 ! Absolut
        ADD w,1
        IF sx$(w)="a" ! ist a dabei
            eg=LEN(sx$(w+1))
            isr=INSTR(1,re$,"a") ! wo ist i
            we=1+LEN(sx$(w+1))
            sx$(w-1)=STR$(ABS(VAL(sx$(w+1)))) ! Ausführen
            @ordner 
            @fidel 
            CLR w 
        ENDIF 
    LOOP 
    DO
        EXIT IF INSTR(1,re$,"1")=0 ! Logarithmus e
        ADD w,1 
        IF sx$(w)="l"
            eg=LEN(sx$(w+1)) 
            isr=INSTR(1,re$,"1") 
            we=1+LEN(sx$(w+1))
            IF VAL(sx$(w+1))<=0 
                nulllog%=l 
                @komplex 
            ELSE
                sx$(w-1)=STR$(LOG(VAL(sx$(w+1))))
                @ordner 
                @fidel 
            ENDIF 
            CLR w 
        ENDIF
        EXIT IF nulllog%=1 
    LOOP
    CLR nulllog%
    DO
        EXIT IF INSTR(1,re$,"d")=0 ! Logaritmus 10
        ADD w,1 
        IF sx$(w)="d"
            eg=LEN(sx$(w+1)) 
            isr=INSTR(1,re$, "d") 
            we=1+LEN(sx$(w+1))
            IF VAL(sx$(w+1))<=0 
                nulllog%=1 
                @komplex 
            ELSE
                sx$(w-1)=STR$(LOG10(VAL(sx$(w+1)))) 
                @ordner 
                @fidel 
            ENDIF 
            CLR w 
        ENDIF
        EXIT IF nulllog%=1 
    LOOP
    CLR nulllog%
    DO
        EXIT IF INSTR(1,re$,"s")=0 ! Sinus
        ADD w,1 
        IF sx$(w)="s"
            eg=LEN(sx$(w+1)) 
            isr=INSTR(1,re$,"s") 
            we=1+LEN(sx$(w+1))
            sx$(w-1)=STR$(SIN(VAL(sx$(w+1))*PI/180))
            @ordner
            @fidel
            CLR w
        ENDIF 
    LOOP
    DO
        EXIT IF INSTR(1,re$,"c")=0 ! Cosinus
        ADD w,1 
        IF sx$(w)="c"
            eg=LEN(sx$(w+1)) 
            isr=INSTR(1,re$,"c") 
            we=1+LEN(sx$(w+1))
            sx$(w-1)=STR$(COS(VAL(sx$(w+1))+PI/180)) 
            @ordner 
            @fidel 
            CLR w 
        ENDIF 
    LOOP 
    DO
        EXIT IF INSTR(1,re$,"t")=0 ! Tangens
        ADD w,1 
        IF sx$(w)="t"
            eg=LEN(sx$(w+1)) 
            isr=INSTR(1,re$,"t") 
            we=1+LEN(sx$(w+1))
            sx$(w-1)=STR$(TAN(VAL(sx$(w+1))+PI/180)) 
            @ordner 
            @fidel 
            CLR w 
        ENDIF 
    LOOP 
    DO
        EXIT IF INSTR(1,re$,"w")=0 ! Wurzelziehen
        ADD w,1 
        IF sx$(w)="w"
            eg=LEN(sx$(w+1)) 
            isr=INSTR(1,re$,"w") 
            we=1+LEN(sx$(w+1))
            IF VAL(sx$(w+1))<0 
                nullsqr%=1 
                wa%=2 
                @komplex 
            ELSE
                sx$(w-1)=STR$(SQR(VAL(sx$(w+1)))) 
                @ordner 
                @fidel 
            ENDIF 
            CLR w 
        ENDIF
        EXIT IF nullsqr%=1 
    LOOP
    CLR nullsqr%
    DO
        EXIT IF INSTR(1,re$,"1")=0 ! Potenzieren
        ADD w,1 
        IF sx$(w)="1"
            ad=LEN(sx$(w-1))
            eg=LEN(sx$(w+1))
            isr=INSTR(1,re$,"^")
            we=LEN(sx$(w-1))+1+LEN(sx$(w+1))
            minus%=0
            IF VAL(sx$(w-1))<0 AND INT(VAL(sx$(w+1)))<>VAL(sx$(w+1))
                nullsq2%=1
                wa%=anzzeig%
                @komplex
            ELSE
                IF VAL(sx$(w-1))<0 AND tor2%=0  ! negativ erkennen
                    minus%=1
                    sx$(w-1)=STR$(VAL(sx$(w-1))*-1)
                ENDIF
                sx$(w-1)=STR$(VAL(sx$(w-1))^(VAL(sx$(w+1))))
                IF minus%=1
                    sx$(w-1)=STR$(VAL(sx$(w-1))*-1)
                ENDIF 
                @ordner 
                @fidel 
            ENDIF 
            CLR w 
        ENDIF
        EXIT IF nullsq2%=1 
    LOOP
    CLR nullsq2%
    DO
        EXIT IF INSTR(1,re$,"/")=0  ! Teilen
        ADD w,1 
        IF sx$(w)="/"
            ad=LEN(sx$(w-1))
            eg=LEN(sx$(w+1))
            isr=INSTR(1,re$,"/")
            we=LEN(sx$(w-1))+1+LEN(sx$(w+1))
            IF VAL(sx$(w+1))<>0
                anzzeig%=VAL(sx$(w+1))
                sx$(w-1)=STR$(VAL(sx$(w-1))/(VAL(sx$(w+1))))
                @ordner 
                @fidel 
            ELSE
                GOSUB null 
            ENDIF 
            CLR w 
        ENDIF
        EXIT IF nulldiv%=1 
    LOOP
    CLR nulldiv%
    DO
        EXIT IF INSTR(1,re$,"*")=0 ! Multiplizieren
        ADD w,1 
        IF sx$(w)="*"
            ad=LEN(sx$(w-1))
            eg=LEN(sx$(w+1))
            isr=INSTR(1,re$,"*")
            we=LEN(sx$(w-1))+1+LEN(sx$(w+1))
            sx$(w-1)=STR$(VAL(sx$(w-1))*(VAL(sx$(w+1))))
            @ordner 
            @fidel 
            CLR w 
        ENDIF 
    LOOP 
    DO
        EXIT IF INSTR(1,re$,"-")=0  ! Subtrahieren
        EXIT IF INSTR(1,rb$,"-")=() ! Negation ?
        ADD w,1 
        IF sx$(w)="-"
            ad=LEN(sx$(w-1)) 
            eg=LEN(sx$(w+1)) 
            isr=INSTR(1,rb$,"-")
            IF VAL(sx$(w-1))<0 
                ADD isr,1 
            ENDIF
            we=LEN(sx$(w-1))+1+LEN(sx$(w+1))
            sx$(w-1)=STR$(VAL(sx$(w-1))-(VAL(sx$(w+1))))
            @ordner 
            @fidel 
            CLR w 
        ENDIF 
    LOOP 
    DO
        EXIT IF INSTR(1,re$,"+")=0 ! Addieren
        EXIT IF INSTR(1,rb$,"+")=0 ! positiv ?
        ADD w,1 
        IF sx$(w)="+"
            ad=LEN(sx$(w-1)) 
            eg=LEN(sx$(w+1)) 
            isr=INSTR(1,rb$ , "+")
            IF VAL(sx$(w-1))<0 
                ADD isr,1 
            ENDIF
            we=LEN(sx$(w-1))+1+LEN(sx$(w+1))
            sx$(w-1)=STR$(VAL(sx$(w-1))+(VAL(sx$(w+1))))
            @ordner 
            @fidel 
            CLR w 
        ENDIF 
    LOOP 
RETURN
PROCEDURE null 
    nulldiv%=1
    PRINT "Division durch Null " 
    nuuld%=1 
RETURN
PROCEDURE ordner ! String wieder zusammenbauen 
    leh=LEN(sx$(w-1))
    re$=MID$(re$,0,(isr-ad-1))+SPACE$(leh)+MID$(re$,isr+eg+1,LEN(re$))
    MID$(re$,(isr-ad),leh)=sx$(w-1)
    CLR ad 
RETURN
PROCEDURE fidel ! Zahlen und Rechenoperationen trennen
    CLR rb$
    DO
        ADD s,1
        anf$=MID$(re$,s,1)
        EXIT IF LEN(anf$)<=0 
        ADD e,1
        syn%=ASC(MID$(re$,s,1))
        IF MID$(re$,s,1)="-"     ! Negation Erkenntnisse 
            sn1%=ASC(MID$(re$,s-1,1))
            IF sn1%<=45 OR sn1%=47 OR sn1%=99 OR sn1%=116 OR sn1%=115 OR sn1%=119 OR sn1%=97 OR sn1%=105 OR sn1%=100 OR sn1%=108
                syn%=48 ! Programm Syntax ?
            ENDIF 
        ENDIF
        IF syn%>47 AND syn%<>94 AND syn%<>46 AND syn%<>115 AND syn%<>99 AND syn%<>116 AND syn%<>119 AND syn%<>97 AND syn%<>105 AND syn%<>100 AND syn%<>108 
            DO
                ADD s,1
                synt%=ASC(MID$(re$,s,1))
                IF MID$(re$,s,1)="--" ! Negativ erkennen
                    sn%=ASC(MID$(re$,s-1,1))
                    IF sn%<=45 OR sn%=47 
                        synt%=48 
                    ENDIF 
                ENDIF
                IF MID$(re$,s,2)= "E+" OR MID$(re$,s,2)="E-" ! Exponent erkennen
                    expo%=1 
                    synt%=48 
                ENDIF
                EXIT IF synt%<=45 OR synt%=47 OR synt%=94 OR synt%=115 OR synt%=99 OR synt%=116 
                EXIT IF synt%=119 OR synt%=97 OR synt%=105 OR synt%=100 OR synt%=108
                IF expo%=1 ! Exponent setzten
                    anf$=anf$+MID$(re$,s, 2)    ! mit Exponent
                    ADD s,1 
                ELSE
                    anf$=anf$+MID$(re$,s,1)     ! Ohne Exponent
                ENDIF 
                expo%=0 
            LOOP 
            SUB s,1 
        ENDIF
        sx$(e)=anf$             ! Aufspalten
        as%=INSTR(1,sx$(e),"E") 
        wisch$=sx$(e)
        IF as%>0                ! Exponent ?
            MID$(wisch$,as%+1,1)="0"
        ENDIF
        IF VAL(wisch$)>=0
            rb$=rb$+wisch$      ! Hilfstring bilden
        ELSE
            IF as%>0
                wisch$=STR$(ABS(VAL(wisch$)))
                MID$(wisch$,as%,1)="0" 
                rb$=rb$+wisch$
            ELSE
                rb$=rb$+STR$(ABS(VAL(wisch$)))  ! Hilfstring fertig
            ENDIF 
        ENDIF 
        CLR anf$
    LOOP 
    CLR s,e
RETURN              ! Aufspaltung beendet
PROCEDURE text ! Info für Benutzer
    GRAPHMODE 4 
    DEFTEXT 1,0,0,13
    TEXT 150,50,"   Parse-Interpreter written by P.Bauer "
    TEXT 150,66,"   Rombergstr.8, 5000 Köln 41. Vers: 4.00 "
    GRAPHMODE 0
    TEXT 150,110,"  Folgende Rechenoperationen sind möglich:"
    TEXT 148,140,"  Standardfunktionen :"
    TEXT 148,160,"      | + | - | / | * | ^ | pi | () |”
    TEXT 148,180,” Variablen = Alle GroPbuchstaben von A->Z"
    TEXT 148,200,"            Sonderfunktionen
    TEXT 450,360," Taste Drücken !!"
    TEXT 450,376,"   Esc =End"
    RESTORE 44 
    FOR bn%=1 TO 9 
        READ hel$
        TEXT 280,210+(bn%*17),hel$
    NEXT bn%
    44:
    DATA s()=Sin(),c()=Cos(),t()=Tan(),d(+-)=Log(),l(+-)=Ln()
    DATA w(+-)=Sqr(),i()=Int(),a()=Abs(),e=Exp(1) 
RETURN
PROCEDURE variable
    vai%=INSTR(1,re$,"=")-1     !wo ist = ?
    var$(ASC(MID$(re$,0,vai%))-65)=MID$(re$,vai%+2,LEN(re$)) ! Zuweisungs var (z.B. A=)
RETURN
PROCEDURE komplex 
    DIM z(100),h(100)
    DEFNUM 5 
    IF nulllog%=1
        PRINT "z=ln(";(ABS(VAL(sx$(w+1))));")+i*(";CHR$(227);"+2*k* ";CHR$(227);")(für k ";CHR$(238);" G)" 
        llog%=1 
    ENDIF
    IF nullsqr%=1 OR nullsq2%=1 
        nuuld%=1 
        pose=pose+wa%
        FOR kom%=1 TO wa%
            IF nullsq2%=1
                a=(ABS(VAL(sx$(w-1))))^(1/wa%)
            ELSE
                a=(ABS(VAL(sx$(w+1))))^(1/wa%)
            ENDIF
            al=180/wa%
            umr=(al+(((kom%-l)*(360/wa%)))) 
            z(kom%)=a*(COS(umr*PI/180)) 
            h(kom%)=a*(SIN(umr*PI/180))
            IF ABS((z(kom%)))<1.0E-07 
                z(kom%)=0 
            ELSE
                IF ABS((h(kom%)))<1.0E-07 
                    h(kom%)=0 
                ENDIF 
            ENDIF 
            ADD pos,1
            PRINT ;"z";kom%;"= ";z(kom%)+" +";h(kom%);"*i"
        NEXT kom%
    ENDIF 
    DEFNUM 12 
    ERASE h()
    ERASE z()
RETURN

Philip S. Bauer
Links

Copyright-Bestimmungen: siehe Über diese Seite
Classic Computer Magazines
[ Join Now | Ring Hub | Random | << Prev | Next >> ]