Ne der Taschenrechner ist als "Beilage" zur Include, obwohl der Code nicht zur Include passt ![]()
Werde das print ausbauen. Werde mich aber jetzt über ein anderes Projekt kümmern.
-VG-
Ne der Taschenrechner ist als "Beilage" zur Include, obwohl der Code nicht zur Include passt ![]()
Werde das print ausbauen. Werde mich aber jetzt über ein anderes Projekt kümmern.
-VG-
Hallo,
zurzeitiger Code:
declare ?_mErr&
Proc ?_Addieren //Addiert Floatwerte a! und b! miteinander. Funktion ist also: Addieren(a!,b!,decimals!,runden!). Beispiel dazu wäre: Addieren(2,4,2,2). Das Ergebnis wäre dann logischerweise 6.00
parameters a!,b!,decimals%,runden%
declare ?_Addieren!
set("decimals",decimals%)
?_Addieren! = a!+b!
return ROUND(?_Addieren!,runden%)
EndProc
Proc ?_Subtrahieren//Subtrahiert Floatwerte a! und b! voneinander. Funktion ist also: Subtrahieren(a!,b!,decimals!,runden!). Beispiel dazu wäre Subtrahieren(2,4,2,2). Das Ergebnis wäre -2.00.
parameters a!,b!,decimals%,runden%
declare ?_Subtrahieren!
set("decimals",decimals%)
?_Subtrahieren! = a!-b!
return ROUND(?_Subtrahieren!,runden%)
EndProc
Proc ?_Dividieren//Dividiert zwei Floatwerte a! und b! miteinander. Funktion ist also: Dividieren(a!,b!,decimals!,runden!). Beispiel dazu wäre Divideren(4,2,2,2). Das Ergebnis wäre 2.00. Keine Divison durch 0 zugelassen!
parameters a!,b!,decimals%,runden%
clear ?_mErr&
declare ?_Dividieren!
set("decimals",decimals%)
If b! = 0
?_mErr& = 1
EndIf
If ?_mErr&=1
print "Division durch 0!"
return
Else
?_Dividieren! = a!/b!
Return ROUND(?_Dividieren!,runden%)
EndIf
EndProc
Proc ?_Multiplizieren//Multipliziert zwei Floatwerte a! und b! miteinander. Funktion ist also: Multiplizieren(a!,b!,decimals!,runden!). Beispiel dazu wäre Multiplizieren(4,2,2,2). Das Ergebnis wäre 8.00. Alles is zugelassen
parameters a!,b!,decimals%,runden%
declare ?_Multiplizieren!
set("decimals",decimals%)
?_Multiplizieren! = a!*b!
return ROUND(?_Multiplizieren!,runden%)
EndProc
Proc ?_Wurzel//Zieht die Wurzel aus a!. Funktion ist also: Wurzel(a!,decimals!,runden!). Beispiel dazu wäre Wurzel(4,2,2). Das Ergebnis wäre 2.00. Keine negativen Wurzeln zugelassen!
parameters a!,decimals%,runden%
clear ?_mErr&
declare ?_Wurzel!
set("decimals",decimals%)
If a!<0
?_mErr&=2
EndIf
If ?_mErr& = 2
print "Negative Wurzel!"
return
Else
?_Wurzel! = sqrt(a!)
Return Round(?_Wurzel!,runden%)
EndIf
EndProc
Proc ?_ADreieck
parameters a!,b!
clear ?_mErr&
declare ?_ADreieck!
set("decimals",4)
If (a!<0) 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!,4)
EndIf
EndProc
Proc ?_AQuadrat
parameters a!
clear ?_mErr&
declare ?_Quadrat!
set("decimals",4)
If a!<0
?_mErr&=4
EndIf
If ?_mErr&=4
print "Unlogisches Ergebnis, da - Flächeninhalt!"
return
Else
?_Quadrat!=a!*a!
return ROUND(?_Quadrat!,4)
EndIf
EndProc
Proc ?_ARechteck
parameters a!,b!
clear ?_mErr&
declare ?_Rechteck!
set("decimals",4)
If (a!<0) or (b!<0)
?_mErr&=5
EndIf
If ?_mErr&=5
print "Unlogisches Ergebnis, da - Flächeninhalt!"
Return
Else
?_Rechteck! = a!*b!
Return ROUND(?_Rechteck!,4)
EndIf
EndProc
Proc ?_AKreis
parameters a!
clear ?_mErr&
declare ?_Kreis!
set("decimals",4)
If a!<0
?_mErr&=6
EndIf
If ?_mErr&=6
print "Unlogisches Ergebnis, da - Flächeninhalt!"
Return
Else
?_Kreis! = @Pi()*a!
return ROUND(?_Kreis!,4)
EndIf
EndProc
Proc ?_ATrapez
parameters a!,c!,h! 'Trapezformel: 0.5*(a+c)*höhe! (h!)
clear ?_mErr&
declare ?_Trapez!
set("decimals",4)
If (a!<0) or (c!<0) or (h!<0)
?_mErr&=7
EndIf
If ?_mErr&=7
print "Unlogisches Ergebnis, da - Flächeninhalt!"
Return
Else
?_Trapez! = 0.5*(a!+c!)*h!
return ROUND(Trapez!,4)
EndIf
EndProc
Proc ?_AParallelogramm
parameters g!,h!
clear ?_mErr&
declare ?_Parallelogramm!
set("decimals",4)
If (g!<0) or (h!<0)
?_mErr&=8
EndIf
If ?_mErr&=8
print "Unlogisches Ergebnis, da - Flächeninhalt!"
Return
Else
?_Parallelogramm! = g!*h! 'Grundfläche*Höhe
return ROUND(?_Parallelogramm!,4)
EndIf
EndProc
Proc ?_VWürfel
Parameters a!
clear ?_mErr&
declare ?_Würfel!
set("decimals",4)
If a!<0
?_mErr&=9
EndIf
If ?_mErr&=9
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_Würfel! = a!*a!*a!
return ROUND(?_Würfel!,4)
EndIf
EndProc
Proc ?_VQuader
Parameters a!,b!,c!
clear ?_mErr&
declare ?_Quader!
set("decimals",4)
If (a!<0) or (b!<0) or (c!<0)
?_mErr& = 10
EndIf
If ?_mErr& = 10
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_Quader! = a!*b!*c!
return ROUND(?_Quader!,4)
EndIf
EndProc
Proc ?_VKugel
parameters r!
clear ?_mErr&
declare ?_Kugel!
set("decimals",4)
If r!<0
?_mErr&=11
EndIf
If ?_mErr&=11
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_Kugel! = 4/3*@PI()*r!*r!*r!
return ROUND(?_Kugel!,4)
EndIf
EndProc
Proc ?_VKegel
parameters r!,h!
clear ?_mErr&
declare ?_Kegel!
set("decimals",4)
If h!<0
?_mErr&=12
EndIf
If ?_mErr&=12
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_Kegel! = 1/3*@PI()*r!*r!*h!
return ROUND(?_Kegel!,4)
EndIf
EndProc
Proc ?_Lösungsformel1
parameters a!,b!,c!
set("decimals",4)
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!,4))+" | "+Str$(ROUND(?_Lösungsformel2!,4))
EndProc
Proc ?_Höhensatz
parameters p!,q!,decimals%,runden%//Funktion: Höhensatz(p!,q!,decimals!,runden!)
clear ?_mErr&
declare ?_Höhensatz!
set("decimals",decimals%)
?_Höhensatz! = p!*q! 'p*q=h²
If ?_Höhensatz!<0
?_mErr&=13
EndIf
If ?_mErr&=13
print "negative Wurzel!"
Return
Else
return ROUND(sqrt(?_Höhensatz!),runden%)
EndIf
EndProc
Proc ?_Hypothenusensatz
parameters a!,b!,decimals%,runden%//Funktion: Hypothenusensatz(a!,b!,decimals!,runden!)
declare ?_c!
set("decimals",decimals%)
?_c!=b!*b!+a!*a!
return ROUND(sqrt(?_c!),runden%)
EndProc
Proc Kathetensatz1
parameters p!,c!,decimals%,runden%//Funktion: Kathetensatz1(p!,c!,decimals!,runden!)
clear ?_mErr&
declare ?_b!
set("decimals",decimals%)
?_b!=c!*p!
If ?_b!<0
?_mErr&=14
EndIf
If ?_mErr&=14
print "Negative Wurzel!"
return
Else
return ROUND(sqrt(?_b!),runden%)
EndIf
EndProc
Proc Kathetensatz2
parameters q!,c!,decimals%,runden%//Funktion: Kathetensatz2(q!,c!,decimals!,runden!)
clear ?_mErr&
declare ?_a!
set("decimals",decimals%)
?_a!=c!*q!
If ?_a!<0
?_mErr&=15
EndIf
If ?_mErr&=15
print "Negative Wurzel!"
return
Else
return ROUND(sqrt(?_a!),runden%)
EndIf
EndProc
Proc ?_VPrisma
parameters g!,h!
clear ?_mErr&
declare ?_v!
set("decimals",4)
If (g!<0) or (h!<0)
?_mErr&=16
EndIf
If ?_mErr&=16
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_v! = g!*h! 'Grundfläche*Höhe!
return ROUND(?_v!,4)
EndIf
EndProc
Proc ?_VZylinder
parameters r!,h!
clear ?_mErr&
declare ?_v!
set("decimals",4)
?_v! = @pi()*r!*r!*h!
If h!<0
?_mErr&=17
EndIf
If ?_mErr&=17
print "Unlogisches Ergebnis, da - Volumen"
Return
Else
return ROUND(?_v!,4)
EndIf
EndProc
Proc InfoAddieren
print "Funktion: Addieren(a!,b!,decimals!,runden!)"
print "Dabei ist a! und b! ein Floatwert und müssen daher Zahlen (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung!"
print "Wenn Sie diese Funktion verwenden, addiert es a! mit b! und Ausgabe ist das Ergebnis (auch im Float)."
print "Negative Zahlen sind natürlich zugelassen"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Proc InfoSubtrahieren
print "Funktion: Subtrahieren(a!,b!,decimals!,runden!)"
print "Dabei ist a! und b! ein Floatwert und müssen daher Zahlen (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung""
print "Wenn Sie diese Funktion verwenden, subtrahiert es a! und b! und Ausgabe ist das Ergebnis (auch im Float)."
print "Negative Zahlen sind natürlich zugelassen"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Proc InfoDividieren
print "Funktion: Dividieren(a!,b!,decimals!,runden!)"
print "Dabei ist a! und b! ein Floatwert und müssen daher Zahlen (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung""
print "Wenn Sie diese Funktion verwenden, dividiert es a! durch b! und Ausgabe ist das Ergebnis (auch im Float)."
print "Negative Zahlen sind natürlich zugelassen. Division durch 0 aber nicht!"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Proc InfoMultiplizieren
print "Funktion: Multiplizieren(a!,b!,decimals!,runden!)"
print "Dabei ist a! und b! ein Floatwert und müssen daher Zahlen (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung"
print "Wenn Sie diese Funktion verwenden, multipliziert es die beiden Floatwerte a! und b! miteinadner und Ausgabe ist das Ergebnis(auch im Float)."
print "Alles zugelassen!"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Proc InfoWurzel
print "Funktion: Wurzel(a!,decimals!,runden!)"
print "Dabei ist a! ein Floatwert und muss daher eine Zahl (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung"
print "Wenn Sie diese Funktion verwenden, zieht es die Wurzel von a! und das Ergebnis wäre logischerweise dann auch ein Floatwert."
print "Keine negativen Wurzeln zugelassen!"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Alles anzeigen
Code vom Taschenrechner (basiert auf Hilfecode):
'(1) Programm wird gestartet
'-Variablen deklarieren----------------------------------------------------
Declare Null%, Eins%, Zwei%, Drei%, Vier%
Declare Fuenf%, Sechs%, Sieben%, Acht%, Neun%
Declare Resultat%, Loeschen%, Addition%, Subtraktion%
Declare Multiplikation%, Division%
Declare Anzeige%, EndeTaste%, Ende%, Komma%
Declare OperationsMerker$, ZahlSpeicher!
'-Zahlausgabe in Anzeige definieren----------------------------------------
Decimals 2
'werden mehr Nachkommastellen benoetigt, hier hoehere Zahl angeben
'-Prozedur Anzeige setzen--------------------------------------------------
Proc AnzeigeSetzen
Parameters Zahl$
If @GetText$(Anzeige%) = "0"
SetText Anzeige%, Zahl$
Else
SetText Anzeige%, @GetText$(Anzeige%) + Zahl$
EndIf
EndProc
'(2) Fenster wird geoeffnet und die Elemente werden platziert
'-Fenster definieren-------------------------------------------------------
WindowTitle "Rechner by RGH"
WindowStyle 24
Window 100, 100 - 140, 235
cls rgb(342,125,321)
'-Tastenfeld definieren----------------------------------------------------
Null% = @Create("Button", %HWnd, "0", 10, 130, 55, 25) '0
Eins% = @Create("Button", %HWnd, "1", 10, 100, 25, 25) '1
Zwei% = @Create("Button", %HWnd, "2", 40, 100, 25, 25) '2
Drei% = @Create("Button", %HWnd, "3", 70, 100, 25, 25) '3
Vier% = @Create("Button", %HWnd, "4", 10, 70, 25, 25) '4
Fuenf% = @Create("Button", %HWnd, "5", 40, 70, 25, 25) '5
Sechs% = @Create("Button", %HWnd, "6", 70, 70, 25, 25) '6
Sieben% = @Create("Button", %HWnd, "7", 10, 40, 25, 25) '7
Acht% = @Create("Button", %HWnd, "8", 40, 40, 25, 25) '8
Neun% = @Create("Button", %HWnd, "9", 70, 40, 25, 25) '9
Addition% = @Create("Button", %HWnd, "+", 100, 130, 25, 25) '+
Subtraktion% = @Create("Button", %HWnd, "-", 100, 100, 25, 25) '-
Multiplikation% = @Create("Button", %HWnd, "*", 100, 70, 25, 25) '*
Division% = @Create("Button", %HWnd, "/", 100, 40, 25, 25) '/
Loeschen% = @Create("Button", %HWnd, "C", 10, 160, 55, 25) 'C
Resultat% = @Create("Button", %HWnd, "=", 70, 160, 55, 25) '=
Komma% = @Create("Button", %HWnd, ",", 70, 130, 25, 25) ',
'-Anzeige definieren-------------------------------------------------------
Anzeige% = @Create("Text", %HWnd, "0", 10, 10, 115, 24)
'-Taste fuer beenden-------------------------------------------------------
EndeTaste% = @Create("Button", %HWnd, "Beenden", 0, 190, 135, 20)
'-Schleife fuer Berechnung-------------------------------------------------
Clear Ende%
'(3) Schleifenstart
WhileNot Ende%
'(4) Warten auf Eingabe
WaitInput 'Hier zweimal da sowohl das Drücken als auch das
WaitInput 'Loslassen zurueckgegeben wird!
If %Key = 2 'Alt-F4 oder Schliessen
Ende% = 1
'(5) Zahleneingabe?
ElseIf @Clicked(Null%) '0 Taste gedrueckt
AnzeigeSetzen "0"
ElseIf @Clicked(Eins%) '1 Taste gedrueckt
AnzeigeSetzen "1"
ElseIf @Clicked(Zwei%) '2 Taste gedrueckt
AnzeigeSetzen "2"
ElseIf @Clicked(Drei%) '3 Taste gedrueckt
AnzeigeSetzen "3"
ElseIf @Clicked(Vier%) '4 Taste gedrueckt
AnzeigeSetzen "4"
ElseIf @Clicked(Fuenf%) '5 Taste gedrueckt
AnzeigeSetzen "5"
ElseIf @Clicked(Sechs%) '6 Taste gedrueckt
AnzeigeSetzen "6"
ElseIf @Clicked(Sieben%) '7 Taste gedrueckt
AnzeigeSetzen "7"
ElseIf @Clicked(Acht%) '8 Taste gedrueckt
AnzeigeSetzen "8"
ElseIf @Clicked(Neun%) '9 Taste gedrueckt
AnzeigeSetzen "9"
ElseIf @Clicked(Komma%) ', Taste gedrueckt
AnzeigeSetzen "."
'(6) Operationseingabe?
ElseIf @Clicked(Addition%) '+ Taste gedrueckt
OperationsMerker$ = "+"
ZahlSpeicher! = @Val(@GetText$(Anzeige%))
SetText Anzeige%, "0"
ElseIf @Clicked(Subtraktion%) '- Taste gedrueckt
OperationsMerker$ = "-"
ZahlSpeicher! = @Val(@GetText$(Anzeige%))
SetText Anzeige%, "0"
ElseIf @Clicked(Multiplikation%) '* Taste gedrueckt
OperationsMerker$ = "*"
ZahlSpeicher! = @Val(@GetText$(Anzeige%))
SetText Anzeige%, "0"
ElseIf @Clicked(Division%) '/ Taste gedrueckt
OperationsMerker$ = "/"
ZahlSpeicher! = @Val(@GetText$(Anzeige%))
SetText Anzeige%, "0"
'(7) Ergebnis?
ElseIf @Clicked(Resultat%) '= Taste gedrueckt
If OperationsMerker$ = "+" 'Addition
SetText Anzeige%, @Str$(ZahlSpeicher! + @Val(@GetText$(Anzeige%)))
ElseIf OperationsMerker$ = "-" 'Subtraktion
SetText Anzeige%, @Str$(ZahlSpeicher! - @Val(@GetText$(Anzeige%)))
ElseIf OperationsMerker$ = "*" 'Multiplikation
SetText Anzeige%, @Str$(ZahlSpeicher! * @Val(@GetText$(Anzeige%)))
ElseIf OperationsMerker$ = "/" 'Division
SetText Anzeige%, @Str$(ZahlSpeicher! / @Val(@GetText$(Anzeige%)))
EndIf
OperationsMerker$= ""
ElseIf @Clicked(Loeschen%) 'C Taste gedrueckt
OperationsMerker$ = ""
ZahlSpeicher! = 0
SetText Anzeige%, "0"
'(8) Ende?
ElseIf @Clicked(EndeTaste%) 'Beenden Taste gedrueckt
Ende% = 1
EndIf
'(9) Schleifenende
EndWhile
'-Ende---------------------------------------------------------------------
'(10) Programmende
End
Alles anzeigen
Danke!
Code sollte klar sein. Ja File-upload kann ne Adwareschleuder sein. Werde das unterlassen.
Die Frage ist doch nicht, wie wahrscheinlich sowas ist, sondern wie gefährlich ein solcher Registrycleaner ist.
Hoffentlich versteht Ihr, was ich ich meine.
Hallo,
MatheLeicht.inc:
declare ?_mErr&
Proc ?_Addieren //Addiert Floatwerte a! und b! miteinander. Funktion ist also: Addieren(a!,b!,decimals!,runden!). Beispiel dazu wäre: Addieren(2,4,2,2). Das Ergebnis wäre dann logischerweise 6.00
parameters a!,b!,decimals%,runden%
declare ?_Addieren!
set("decimals",decimals%)
?_Addieren! = a!+b!
return ROUND(?_Addieren!,runden%)
EndProc
Proc ?_Subtrahieren//Subtrahiert Floatwerte a! und b! voneinander. Funktion ist also: Subtrahieren(a!,b!,decimals!,runden!). Beispiel dazu wäre Subtrahieren(2,4,2,2). Das Ergebnis wäre -2.00.
parameters a!,b!,decimals%,runden%
declare ?_Subtrahieren!
set("decimals",decimals%)
?_Subtrahieren! = a!-b!
return ROUND(?_Subtrahieren!,runden%)
EndProc
Proc ?_Dividieren//Dividiert zwei Floatwerte a! und b! miteinander. Funktion ist also: Dividieren(a!,b!,decimals!,runden!). Beispiel dazu wäre Divideren(4,2,2,2). Das Ergebnis wäre 2.00. Keine Divison durch 0 zugelassen!
parameters a!,b!,decimals%,runden%
clear ?_mErr&
declare ?_Dividieren!
set("decimals",decimals%)
If b! = 0
?_mErr& = 1
EndIf
If ?_mErr&=1
print "Division durch 0!"
return
Else
?_Dividieren! = a!/b!
Return ROUND(?_Dividieren!,runden%)
EndIf
EndProc
Proc ?_Multiplizieren//Multipliziert zwei Floatwerte a! und b! miteinander. Funktion ist also: Multiplizieren(a!,b!,decimals!,runden!). Beispiel dazu wäre Multiplizieren(4,2,2,2). Das Ergebnis wäre 8.00. Alles is zugelassen
parameters a!,b!,decimals%,runden%
declare ?_Multiplizieren!
set("decimals",decimals%)
?_Multiplizieren! = a!*b!
return ROUND(?_Multiplizieren!,runden%)
EndProc
Proc ?_Wurzel//Zieht die Wurzel aus a!. Funktion ist also: Wurzel(a!,decimals!,runden!). Beispiel dazu wäre Wurzel(4,2,2). Das Ergebnis wäre 2.00. Keine negativen Wurzeln zugelassen!
parameters a!,decimals%,runden%
clear ?_mErr&
declare ?_Wurzel!
set("decimals",decimals%)
If a!<0
?_mErr&=2
EndIf
If ?_mErr& = 2
print "Negative Wurzel!"
return
Else
?_Wurzel! = sqrt(a!)
Return Round(?_Wurzel!,runden%)
EndIf
EndProc
Proc ?_ADreieck
parameters a!,b!
clear ?_mErr&
declare ?_ADreieck!
set("decimals",4)
If (a!<0) 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!,4)
EndIf
EndProc
Proc ?_AQuadrat
parameters a!
clear ?_mErr&
declare ?_Quadrat!
set("decimals",4)
If a!<0
?_mErr&=4
EndIf
If ?_mErr&=4
print "Unlogisches Ergebnis, da - Flächeninhalt!"
return
Else
?_Quadrat!=a!*a!
return ROUND(?_Quadrat!,4)
EndIf
EndProc
Proc ?_ARechteck
parameters a!,b!
clear ?_mErr&
declare ?_Rechteck!
set("decimals",4)
If (a!<0) or (b!<0)
?_mErr&=5
EndIf
If ?_mErr&=5
print "Unlogisches Ergebnis, da - Flächeninhalt!"
Return
Else
?_Rechteck! = a!*b!
Return ROUND(?_Rechteck!,4)
EndIf
EndProc
Proc ?_AKreis
parameters a!
clear ?_mErr&
declare ?_Kreis!
set("decimals",4)
If a!<0
?_mErr&=6
EndIf
If ?_mErr&=6
print "Unlogisches Ergebnis, da - Flächeninhalt!"
Return
Else
?_Kreis! = @Pi()*a!
return ROUND(?_Kreis!,4)
EndIf
EndProc
Proc ?_ATrapez
parameters a!,c!,h! 'Trapezformel: 0.5*(a+c)*höhe! (h!)
clear ?_mErr&
declare ?_Trapez!
set("decimals",4)
If (a!<0) or (c!<0) or (h!<0)
?_mErr&=7
EndIf
If ?_mErr&=7
print "Unlogisches Ergebnis, da - Flächeninhalt!"
Return
Else
?_Trapez! = 0.5*(a!+c!)*h!
return ROUND(Trapez!,4)
EndIf
EndProc
Proc ?_AParallelogramm
parameters g!,h!
clear ?_mErr&
declare ?_Parallelogramm!
set("decimals",4)
If (g!<0) or (h!<0)
?_mErr&=8
EndIf
If ?_mErr&=8
print "Unlogisches Ergebnis, da - Flächeninhalt!"
Return
Else
?_Parallelogramm! = g!*h! 'Grundfläche*Höhe
return ROUND(?_Parallelogramm!,4)
EndIf
EndProc
Proc ?_VWürfel
Parameters a!
clear ?_mErr&
declare ?_Würfel!
set("decimals",4)
If a!<0
?_mErr&=9
EndIf
If ?_mErr&=9
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_Würfel! = a!*a!*a!
return ROUND(?_Würfel!,4)
EndIf
EndProc
Proc ?_VQuader
Parameters a!,b!,c!
clear ?_mErr&
declare ?_Quader!
set("decimals",4)
If (a!<0) or (b!<0) or (c!<0)
?_mErr& = 10
EndIf
If ?_mErr& = 10
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_Quader! = a!*b!*c!
return ROUND(?_Quader!,4)
EndIf
EndProc
Proc ?_VKugel
parameters r!
clear ?_mErr&
declare ?_Kugel!
set("decimals",4)
If r!<0
?_mErr&=11
EndIf
If ?_mErr&=11
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_Kugel! = 4/3*@PI()*r!*r!*r!
return ROUND(?_Kugel!,4)
EndIf
EndProc
Proc ?_VKegel
parameters r!,h!
clear ?_mErr&
declare ?_Kegel!
set("decimals",4)
If h!<0
?_mErr&=12
EndIf
If ?_mErr&=12
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_Kegel! = 1/3*@PI()*r!*r!*h!
return ROUND(?_Kegel!,4)
EndIf
EndProc
Proc ?_Lösungsformel1
parameters a!,b!,c!
set("decimals",4)
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!,4))+" | "+Str$(ROUND(?_Lösungsformel2!,4))
EndProc
Proc ?_Höhensatz
parameters p!,q!,decimals%,runden%//Funktion: Höhensatz(p!,q!,decimals!,runden!)
clear ?_mErr&
declare ?_Höhensatz!
set("decimals",decimals%)
?_Höhensatz! = p!*q! 'p*q=h²
If ?_Höhensatz!<0
?_mErr&=13
EndIf
If ?_mErr&=13
print "negative Wurzel!"
Return
Else
return ROUND(sqrt(?_Höhensatz!),runden%)
EndIf
EndProc
Proc ?_Hypothenusensatz
parameters a!,b!,decimals%,runden%//Funktion: Hypothenusensatz(a!,b!,decimals!,runden!)
declare ?_c!
set("decimals",decimals%)
?_c!=b!*b!+a!*a!
return ROUND(sqrt(?_c!),runden%)
EndProc
Proc Kathetensatz1
parameters p!,c!,decimals%,runden%//Funktion: Kathetensatz1(p!,c!,decimals!,runden!)
clear ?_mErr&
declare ?_b!
set("decimals",decimals%)
?_b!=c!*p!
If ?_b!<0
?_mErr&=14
EndIf
If ?_mErr&=14
print "Negative Wurzel!"
return
Else
return ROUND(sqrt(?_b!),runden%)
EndIf
EndProc
Proc Kathetensatz2
parameters q!,c!,decimals%,runden%//Funktion: Kathetensatz2(q!,c!,decimals!,runden!)
clear ?_mErr&
declare ?_a!
set("decimals",decimals%)
?_a!=c!*q!
If ?_a!<0
?_mErr&=15
EndIf
If ?_mErr&=15
print "Negative Wurzel!"
return
Else
return ROUND(sqrt(?_a!),runden%)
EndIf
EndProc
Proc ?_VPrisma
parameters g!,h!
clear ?_mErr&
declare ?_v!
set("decimals",4)
If (g!<0) or (h!<0)
?_mErr&=16
EndIf
If ?_mErr&=16
print "Unlogisches Ergebnis, da - Volumen!"
Return
Else
?_v! = g!*h! 'Grundfläche*Höhe!
return ROUND(?_v!,4)
EndIf
EndProc
Proc ?_VZylinder
parameters r!,h!
clear ?_mErr&
declare ?_v!
set("decimals",4)
?_v! = @pi()*r!*r!*h!
If h!<0
?_mErr&=17
EndIf
If ?_mErr&=17
print "Unlogisches Ergebnis, da - Volumen"
Return
Else
return ROUND(?_v!,4)
EndIf
EndProc
Proc InfoAddieren
print "Funktion: Addieren(a!,b!,decimals!,runden!)"
print "Dabei ist a! und b! ein Floatwert und müssen daher Zahlen (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung!"
print "Wenn Sie diese Funktion verwenden, addiert es a! mit b! und Ausgabe ist das Ergebnis (auch im Float)."
print "Negative Zahlen sind natürlich zugelassen"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Proc InfoSubtrahieren
print "Funktion: Subtrahieren(a!,b!,decimals!,runden!)"
print "Dabei ist a! und b! ein Floatwert und müssen daher Zahlen (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung""
print "Wenn Sie diese Funktion verwenden, subtrahiert es a! und b! und Ausgabe ist das Ergebnis (auch im Float)."
print "Negative Zahlen sind natürlich zugelassen"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Proc InfoDividieren
print "Funktion: Dividieren(a!,b!,decimals!,runden!)"
print "Dabei ist a! und b! ein Floatwert und müssen daher Zahlen (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung""
print "Wenn Sie diese Funktion verwenden, dividiert es a! durch b! und Ausgabe ist das Ergebnis (auch im Float)."
print "Negative Zahlen sind natürlich zugelassen. Division durch 0 aber nicht!"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Proc InfoMultiplizieren
print "Funktion: Multiplizieren(a!,b!,decimals!,runden!)"
print "Dabei ist a! und b! ein Floatwert und müssen daher Zahlen (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung"
print "Wenn Sie diese Funktion verwenden, multipliziert es die beiden Floatwerte a! und b! miteinadner und Ausgabe ist das Ergebnis(auch im Float)."
print "Alles zugelassen!"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Proc InfoWurzel
print "Funktion: Wurzel(a!,decimals!,runden!)"
print "Dabei ist a! ein Floatwert und muss daher eine Zahl (im größeren Bereich als ein Integer) sein. Sonst gibt es eine Fehlermeldung"
print "Wenn Sie diese Funktion verwenden, zieht es die Wurzel von a! und das Ergebnis wäre logischerweise dann auch ein Floatwert."
print "Keine negativen Wurzeln zugelassen!"
print "Decimals! gibt die Anzahl an Nachkommastellen an und runden! gibt an, auf wie viel Stellen gerundet werden soll"
EndProc
Alles anzeigen
Updates:
- größere Namensräume
- decimals! und runden! wurde auf integer zurückgesetzt.
Servus