Tachchen Leute,
in den letzten Wochen arbeite ich an eine komplett überarbeiteten Version meines Includes für Dezimalzahlen.
Viele Operationen konnte ich schon beschleunigen:
- Addieren - 15% schneller
- Multiplizieren - 15% schneller
- Dividieren - 50% schneller
Viele Operationen habe ich schon hinzugefügt:
- Potenzieren (nur mit ganzzahligen Exponenten)
- Radizieren (nur mit ganzzahligen Wurzelexponenten)
- Fakultät (nur ganze zahlen)
- ...
Auch speichere ich die Zahlen in einem andere Format ab, sodass allgemein Speicher gespart wird, und das Include auch für "rein ganze" Zahlen geeingnet ist.
Wichtig ist auch, das ich derzeitig den "Modus" drin habe das nach einer Operation die Zahlen dir daran beteiligt waren gelöscht werden, das soll vor Speicherüberauf schützen, aknn aber mit einem Flag unterdrückt werden falls man die Zahlen doch noch mal braucht.
Hier die Aktuelle Test-Version : Decimal.pbi
(Link aktuallisiert 9.7.2010)
Hinweis: Das ist nur eine Test-Version, Operationen wie Wurzelziehen laufen sehr instabil,
sie dient erst mal nur zum Testen und zur Bugsuche!
andere "krittische" Operationen wir Dividieren habe ich zwar inzwischen verbessert, trotzdem kann es bei Missbrauch zu Abstürzen kommen (IMA oder endlosschleifen)
Hinweis2: Diese Test-Version bitte vorerst nur mit Debugger starten, zwar sind die meisten Proceduren dann 5-10 mal langsammer aber dafür kann man es schneller beenden!
Hier mal ein paar kleine Beispiele:
Code: Alles auswählen
Debug "Fakultät von 1000"
Debug DecimalToString(FactorialDecimal(IntegerToDecimal(1000)))
Debug "1024 hoch 1024"
*Ergebnis = PowerDecimal(IntegerToDecimal(1024), IntegerToDecimal(1024))
Debug DecimalToString(*Ergebnis)
Debug "2.56^1000 durch 2.56^998"
*Zahl1 = PowerDecimal(StringToDecimal("2.56"), IntegerToDecimal(1000))
*Zahl2 = PowerDecimal(StringToDecimal("2.56"), IntegerToDecimal(998))
Debug DecimalToString(*Zahl1, #NoDecimal)
Debug DecimalToString(*Zahl2, #NoDecimal)
*Ergebnis2 = DivideDecimal(*Zahl1, *Zahl2, 10)
Debug DecimalToString(*Ergebnis2)
Debug "größten gemeinsammen Teiler von zwei großen Zahlen mit Dezimalstellen"
*Zahl1 = StringToDecimal("140032456034604564060345063546.25")
*Zahl2 = StringToDecimal("74356367865484675647864667768.75")
*Ergebnis3 = GCDDecimal(*Zahl1, *Zahl2)
Debug DecimalToString(*Ergebnis3)
Obwohl die Funktion Power zwar auch riesige Zahlen erlaubt, ist es nicht ratsam diese auch zu benutzen.
Kleine Beispielrechnung:
eine Milliarde hoch eine Milliarde
wäre eine 1 mit
9 Milliarde Nullen diese Zahl rechnet das Programm zwar schnell aus aber darf nicht mehr als String dargestellt werden ! weil
9 Milliarden Nullen ca 9 GIGABYTE ! verschligen würden.
Als Dezimal Zahl in meinem Include sind es aber nur wenige Byte, da die Zahl nur wenige echte stellen hat , dafür eine riesige Potenz, dafür gibs DebugDecimal()
Code: Alles auswählen
Debug "1000000000 hoch 1000000000"
*Ergebnis = PowerDecimal(IntegerToDecimal(1000000000), IntegerToDecimal(1000000000))
Debug DebugDecimal(*Ergebnis)
Würde man jetzt aber eine beliebige Zahl so hoch Potenzieren würde das sehr lange dauern! daher nicht ratsam!
Genausowenig sollte man sich von 1/7 "alle" Dezimalstellen ausgeben lassen, denn DivideDecimal bricht erst ab wenn die angegebene Prezision erreicht ist oder kein rest mehr da ist.
Was ich noch einbauen möchte ist, das die Division selber eine Periode erkennt:
1/7 = 0.142857
1/6 = 0.16
Machbar wäre das! indem ich abbrechen wenn ein Rest schon mal vorher Rest war.
Jedoch müsste ich dann alle Operationen (Plus, Mal) auch damit vertraut machen mit Perionen zu rechnen.
1.6 + 1.3 = 3
So genau der Wort, testet mal ein Bisschen "vorsichtig" rum und meldet mir Bugs und nennt auch Wünsche.
Sowas wie nächte Primzahl nach 10^100 ist in Arbeit
jo es ist NIX gleich weil meine Zahlen IMMER ein Komma haben, acuh bei ganzen Zahlen : 100. statt bei dir 100