XProfan

- Seite 3 -

Julian
Schmidt

Was im Zusammenhang von Quadratischen Funktionen noch interessant wäre, ist die Berechnung des Scheitelpunktes.
Diesen kannst du über die Quadratische Ergänzung oder über den Mittelwert der Nullstellen und anschließenden einsetzten für X ausrechnen.

XProfan X2
Win7 Professional, SP1, AMD FX(tm)-8350 Eight-Core Processor
˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗˗
Webseite [...]

Gary12345

Da sind wir gerade im Matheunterricht

Eher nicht. Ich habe einen Plan, was ich einbaue und den werde ich erstmal durchnehmen, was dann wird, weiß ich noch nicht eindeutig.

XProfan X2
MfG
Gary12345

Gary12345

Hallo,

derzeitiger Code:
Kompilieren Markieren Separieren

'Include programmiert von Gary12345

Proc Summe

    parameters a!,b!
    declare Summe!
    set("decimals",2)
    Summe! = a!+b!
    return ROUND(Summe!,2)

EndProc

Proc Info'Muss noch weiter ausgebaut werden!

    print "Summe: Addiert zwei Zahlen. Summe(a,b). Es werden a und b miteinander addiert.a+b=Ergebnis"
    print ""
    print "Minus: Subtrahiert zwei Zahlen. Minus(a,b). Es werden a und b miteinander subtrahiert.a-b=Ergebnis"
    print ""
    print "Teilen: Teilt zwei Zahlen. Fehler bei Divison durch 0. Teilen(a,b). a wird durch b geteil.a:b=Ergebnis"
    print ""
    print "Multiplizieren: Multipliziert zwei Zahlen. Multiplizieren(a,b). Es werden a und b miteinander multipliziert.a*b=Ergebnis"
    print ""

EndProc

Proc Minus

    parameters a!,b!
    declare Minus!
    set("decimals",2)
    Minus! = a!-b!
    return ROUND(Minus!,2)

EndProc

Proc Teilen

    parameters a!,b!
    declare Teilen!
    set("decimals",2)
    Teilen! = a!/b!
    return ROUND(Teilen!,2)

EndProc

Proc Multiplizieren

    parameters a!,b!
    declare multiplizieren!
    set("decimals",2)
    multiplizieren! = a!*b!
    return ROUND(Multiplizieren!,2)

EndProc

Proc Wurzel

    parameters a!
    declare Wurzel!
    set("decimals",2)
    Wurzel! = sqrt(a!)
    return Round(Wurzel!,2)

EndProc

Proc ADreieck

    parameters a!,b!
    declare ADreieck!
    set("decimals",2)
    ADreieck! = 0.5*a!*b!
    return ROUND(ADreieck!,2)

EndProc

Proc AQuadrat

    parameters a!
    declare Quadrat!
    set("decimals",2)
    Quadrat!=a!*a!
    return ROUND(Quadrat!,2)

EndProc

Proc ARechteck

    parameters a!,b!
    declare Rechteck!
    set("decimals",2)
    Rechteck! = a!*b!
    return ROUND(Rechteck!,2)

EndProc

Proc AKreis

    parameters a!
    declare Kreis!
    set("decimals",2)
    Kreis! = @Pi()*a!
    return ROUND(Kreis!,2)

EndProc

Proc ATrapez

    parameters a!,c!,h!'Trapezformel: 0.5*(a+c)*höhe! (h!)
    declare Trapez!
    set("decimals",2)
    Trapez! = 0.5*(a!+c!)*h!
    return ROUND(Trapez!,2)

EndProc

Proc AParallelogramm

    parameters g!,h!
    declare Parallelogramm!
    set("decimals",2)
    Parallelogramm! = g!*h!'Grundfläche*Höhe
    return ROUND(Parallelogramm!,2)

EndProc

Proc VWürfel

    Parameters a!
    declare Würfel!
    set("decimals",2)
    Würfel! = a!*a!*a!
    return ROUND(Würfel!,2)

EndProc

Proc VQuader

    Parameters a!,b!,c!
    declare Quader!
    set("decimals",2)
    Quader! = a!*b!*c!
    return ROUND(Quader!,2)

EndProc

Proc VKugel

    parameters r!
    declare Kugel!
    set("decimals",2)
    Kugel! = 4/3*@PI()*r!*r!*r!
    return ROUND(Kugel!,2)

EndProc

Proc VKegel

    parameters r!,h!
    declare Kegel!
    set("decimals",2)
    Kegel! = 1/3*@PI()*r!*r!*h!
    return ROUND(Kegel!,2)

EndProc

Proc Lösungsformel1'Wert bei -b-...

    parameters a!,b!,c!
    set("decimals",2)
    var Lösungsformel1! = -((b!/a!)/2)+sqrt(abs(((b!/a!)/2)^2-(c!/a!)))
    var Lösungsformel2! = -((b!/a!)/2)-sqrt(abs(((b!/a!)/2)^2-(c!/a!)))
    return Str$(ROUND(Lösungsformel1!,2))+" | "+Str$(ROUND(Lösungsformel2!,2))

EndProc

Proc Höhensatz

    parameters p!,q!
    declare Höhensatz!
    set("decimals",2)
    Höhensatz! = p!*q!'p*q=h²
    return ROUND(sqrt(Höhensatz!),2)

EndProc

Proc Hypothenusensatz

    parameters a!,b!
    declare c!
    set("decimals",2)
    c!=b!*b!+a!*a!
    return ROUND(sqrt(c!),2)

EndProc

Proc Kathetensatz1

    parameters p!,c!
    declare b!
    set("decimals",2)
    b!=c!*p!
    return ROUND(sqrt(b!),2)

EndProc

Proc Kathetensatz2

    parameters q!,c!
    declare a!
    set("decimals",2)
    a!=c!*q!
    return ROUND(sqrt(a!),2)

EndProc

Proc VPrisma

    parameters g!,h!
    declare v!
    set("decimals",2)
    v! = g!*h!'Grundfläche*Höhe!
    return ROUND(v!,2)

EndProc

Proc VZylinder

    parameters r!,h!
    declare v!
    set("decimals",2)
    v! = @pi()*r!*r!*h!
    return ROUND(v!,2)

EndProc

cls
var test1! = Lösungsformel1(2,3,-4)
var test2! = Höhensatz(6,7)'p*q=h²
var test3! = Hypothenusensatz(2,3)
var test4! = Kathetensatz1(4,2)
var test5! = Kathetensatz2(4,2)
var test6! = VPrisma(2,4)
var test7! = VZylinder(2,3)
print test1!
print test2!
print sqrt(42)
print test3!
print sqrt(13)
print test4!
print sqrt(8)
print test5!
print test6!
print test7!
WaitInput

OK-habe nun alle Funktionen eingebaut, die ich gerne haben möchte (scheint auch zu funktionieren).

eine globale Fehlervariable wie mErr& zu verwenden.

Was ist das? In der Hilfe finde ich nichts?

LG

XProfan X2
MfG
Gary12345

Julian
Schmidt

Einfach eine globale Variable in der du alle Flags zu Fehlern speicherst.
Ganz oben einfach per declare mErr& deklarieren.

In den Routinen dann die Fehler in diese neue Variable schreiben. Hat dem Vorteil das du ganz einfach nach den Ausführen und an jeder Stelle des Programmes überprüfen kannst, ob die letzte mathematische Operation erfolgreich war. Weil es häufig bzw. immer bei einem Fehler keinen Sinn macht versuchen weiter zu rechnen. Die Variable in jeder Routine erst auf Standart zurücksetzen!
Kompilieren Markieren Separieren

declare mErr&
print Wurzel(-1)

If mErr&=1

    print "Negative Wurzel"

Else

    print "keine Fehler"

EndIf

waitinput

Proc Wurzel

    parameters a!
    clear mErr&
    declare Wurzel!
    set("decimals",2)
    case a!<0 : mErr&=1'Flag für eine negative Wurzel
    Wurzel! = sqrt(abs(a!))
    return Round(Wurzel!,2)

EndProc

Julian
Schmidt

Mal ein paar kleine Anregungen und Tipps zu deinen Include.

1. Kannst du deine ganzen Texte aus der Info-Routine direkt in die betreffende Routine als Kommentar schreiben. Kommentare werden einfach mit ' bzw // begonnen.
2. Sollten in einem gutem Matheinclude die Funktionsnamen auch nach den richtigen mathematischen Begriffen benannt sein. Etwa statt Teilen, Dividieren. Unter Umständen sollten sogar die Parameter anderen benannt werden. In der Routine "Teilen" beispielsweise Dividend und Divisor. Dabei sollte man aber abwägen ob der Code dadurch schlechter lesbar wird und deswegen evtl. nach gängigen Abkürzungen suchen.
3. Bei Volumen von Körpern ist die Öberfläche nicht weit.

Gary12345

Kein Problem, wird alles gemacht.

Nur ein Problem nach dem anderen Problem

Ich versteh nicht warum "If mErr& = 1". Warum = 1? Ich will doch abfragen, ob negative Werte vorhanden sind?

Und ich müsste dann praktisch überall die Fehlervariable mit clear in allen Procs deklarieren?

LG

XProfan X2
MfG
Gary12345

Julian
Schmidt

Gary12345 (30.01.13)

Ich versteh nicht warum "If mErr& = 1". Warum = 1? Ich will doch abfragen, ob negative Werte vorhanden sind?

Der Wert 1 ist mehr oder weniger willkürlich.
Mit der Zeile
Kompilieren Markieren Separieren

case a!<0 : mErr&=1

prüfst du, ob der Wert in der Wurzel negativ ist, und wenn ja wird die Fehlervariable mErr& gleich 1 gesetzt.
Du könntest also genauso
Kompilieren Markieren Separieren

If a!<0

    mErr&=1

Endif

schreiben.
Den Wert eins habe ich als Flag für den Fehler negative Wurzel gewählt. Du könntest für andere Fehler in der Procedur noch andere Flags vergeben. Z.B. wenn der Fall Division durch Null vorkommt, für diesen mErr&=2. Keine Fehler wäre hier mErr&=0.
Jetzt kann du per IF einfach abfragen ob kein Fehler (mErr&=0), ein Fehler (mErr&<>0), bzw. welcher Fehler aufgetreten ist (mErr&=1 oder mErr&=2)

Gary12345 (30.01.13)

Und ich müsste dann praktisch überall die Fehlervariable mit clear in allen Procs deklarieren?

Die Variable wird mit Clear nicht deklariert, sondern zurückgesetzt. Kannst auch einfach mErr& = 0 schreiben. Ist nötig, da beim erfolgreichen Durchlaufen (ohne Fehler) ansonsten die alten Fehlerwerte stehen blieben

Kompilieren Markieren Separieren

Gary12345

Proc Teilen

    parameters a!,b!
    clear mErr&
    declare Teilen!
    set("decimals",2)
    Teilen! = a!/b!
    return ROUND(Teilen!,2)

    If b! = 0

        mErr& = 1

    EndIf

    If mErr&=1

        print "Division durch 0!"

    EndIf

EndProc

Dann sollte dies aber gehen? Aber es kommt davor immer noch die Fehlermelung. Mit Clear habe ich die Variable ja zurückgesetzt...

Danke!

XProfan X2
MfG
Gary12345

Julian
Schmidt

Da hast du die falschen Reihenfolge. Du musst erst den Fehler mit If-Abfragen und falls ein Fehler auftritt aus der Funktion springen z.B. mit return. Die Fehlermeldung kommt immer bei einen Math-Error und dann stützt das Programm ab.
Probier beim nächsten mal einfach mit Einzelschritt-Modus auf die Lösung zu kommen. Führst du einfach per Traceon am Anfang der Routine\Programmes aus und schließt du wieder per Traceoff

Kompilieren Markieren Separieren

Gary12345

Proc Teilen

    parameters a!,b!
    clear mErr&
    declare Teilen!
    set("decimals",2)

    If b! = 0

        mErr& = 1

    EndIf

    If mErr&=1

        print "Division durch 0!"
        return

    EndIf

    Teilen! = a!/b!
    ROUND(Teilen!,2)

EndProc

Also so stimmt das dann?

XProfan X2
MfG
Gary12345

Gary12345

Nein so kommt zwar das richtige Ergebnis raus, aber so ist es eleganter:
Kompilieren Markieren Separieren

Proc ADreieck

    parameters a!,b!
    declare ADreieck!
    set("decimals",2)

    If a! or b!>0

        mErr&=3

    EndIf

    If mErr&=3

        print "Unlogisches Ergebnis, da - Flächeninhalt!"
        return

    Else

        ADreieck! = 0.5*a!*b!
        return ROUND(ADreieck!,2)

    EndIf

EndProc

Hab ich recht?

MfG
Gary12345