Mathe mit Strings (die deutsche StringMatheLib ._. )

[himitsu Online]

Jaaaaaaa, was soll ich sagen ...

» also ich weiß, es ist nicht sonderlich schnell, aber dafür seeeeeeeehr einfach aufgebaut

» es läuft mindestens ab Delphi 7 (drunter hab ich nicht getestet)
und auch für Delphi 2009 ist es geeignet

» man kann die Verwendung der Unit SysUtils abschalten (incl. der Unit Math, da diese die SysUtils verwendet, aber außer Max wird daraus eh nix verwendet)

» Zahlen mit theoretisch über 1 Milliarde Dezimalstellen sind möglich

» die Funktionen sind mit deutschsprachigen Namen versehn

» es steht unter MPL + (L)GPL

» Versionen:
StringMatheLib.pas » Demo 1 » alle Funktionen in einer Klasse verpackt
StringMatheRec.pas » Demo 2 » in einem Record ("MatheString") verpackt und mit Operatoren versehen (ab D2006/TDE)
StringMatheVar.pas » Demo 4 » in einem Variant/"MatheVariant" verpackt und mit Operatoren versehen
StringMatheFloatRec.pas » Demo 3 » wie "MatheString" in einem Record ("MatheStringF") als Festkommazahl
StringMatheParser.pas » Demo 5 » ein kliner Mathe-Parser

» was es derzeit kann ... siehe hier:

Delphi-Quellcode:

// Normalisieren     alle ungültigen und zusätzlichen Zeichen entfernen
// Formatieren       -
//
// Vergleich         -
// Vergleich         -
// istPositiv        -
// istNegativ        -
// istGerade         -
// istUngerade       -
// gibVorzeichen     -
// Dezimalstellen    -
//
// Summe             r = a + b
// Differenz         r = a - b
// Plus1             a = a + 1     oder   inc(a)
// Minus1            a = a - 1     oder   dec(a)
// Negieren          a = -a
// Absolut           if a < 0 then r = -a else r = a
//
// Produkt           r = a * b
// Quotient          r = a div b
// Modulo            r = a mod b
// QuotientModulo    r = a div b   und    m = a mod b
//
// Quadrat           r = a * a     oder   r = a ^ 2
// Quadratwurzel     r = a ^ 1/2
// Quadratwurzel     r = a ^ 1/2   und    m = a - (a ^ 1/2)
// Potenz            r = a ^ b
// Potenz10          r = 10 ^ b
//
// Quotient2         r = a div 2
// Produkt10         r = a * 10^b
// Quotient10        r = a div 10^b
// Modulo10          r = a mod 10^b
// QuotientModulo10  r = a div 10^b   und    m = a mod 10^b
//
// SummeModulo       r = (a + b) mod m
// DifferenzModulo   r = (a - b) mod m
// ProduktModulo     r = (a * b) mod m
// PotenzModulo      r = (a ^ b) mod m
//
// Zufall            r = Random(von, bis)

Type MatheString = Type AnsiString;
  TVergleich = (vUngleich, vKleiner, vKleinerGleich, vGleich, vGroesserGleich, vGroesser);

TMathe = Class
  Property  ImmerNormalisieren: Boolean Read _ImmerNormalisieren Write _ImmerNormalisieren;

  Function  Normalisieren   (a:    String): String;
  Function  Formatieren     (a:    String; TausenderPunkte, ImmerMitVorzeichen: Boolean; Mindestlaenge: Integer = 0): String;

  Function  Vergleich       (a, b: String): TValueRelationship;       Overload;
  Function  Vergleich       (a, b: String; Art: TVergleich): Boolean; Overload;
  Function  istPositiv      (a:    String): Boolean;
  Function  istNegativ      (a:    String): Boolean;
  Function  istGerade       (a:    String): Boolean;
  Function  istUngerade     (a:    String): Boolean;
  Function  gibVorzeichen   (a:    String): Char;
  Function  Dezimalstellen  (a:    String): Integer;

  Function  Summe           (a, b: String): String;
  Function  Differenz       (a, b: String): String;
  Procedure Plus1       (Var a:    String);
  Procedure Minus1      (Var a:    String);
  Procedure Negieren    (Var a:    String);
  Function  Absolut         (a:    String): String;

  Function  Produkt         (a, b: String): String;
  Function  Quotient        (a, b: String): String;
  Function  Modulo          (a, b: String): String;
  Procedure QuotientModulo  (a, b: String; Var Result, Rest: String);

  Function  Quadrat         (a:    String):  String;
  Function  Quadratwurzel   (a:    String):  String;
  Procedure Quadratwurzel   (a:    String; Var Result, Rest: String);
  Function  Potenz          (a, b: String):  String;
  Function  Potenz10        (   b: String):  String;
  Function  Potenz10        (   b: Integer): String;

  Function  Quotient2       (a:            String):  String;
  Function  Produkt10       (a,         b: String):  String;
  Function  Produkt10       (a: String; b: Integer): String;
  Function  Quotient10      (a,         b: String):  String;
  Function  Quotient10      (a: String; b: Integer): String;
  Function  Modulo10        (a,         b: String):  String;
  Function  Modulo10        (a: String; b: Integer): String;
  Procedure QuotientModulo10(a,         b: String;  Var Result, Rest: String);
  Procedure QuotientModulo10(a: String; b: Integer; Var Result, Rest: String);

  Function  SummeModulo     (a, b, m:  String): String;
  Function  DifferenzModulo (a, b, m:  String): String;
  Function  ProduktModulo   (a, b, m: String): String;
  Function  PotenzModulo    (a, b, m: String): String;

  Function  zuInteger       (a:    String):   LongInt;
  Function  vonInteger      (a:    LongInt):  String;
  Function  zuCardinal      (a:    String):   LongWord;
  Function  vonCardinal     (a:    LongWord): String;
  Function  zuInteger64     (a:    String):   Int64;
  Function  vonInteger64    (a:    Int64):    String;

  Function  Produkt_langsam       (a, b: String): String;
  Procedure QuotientModulo_langsam(a, b: String; Var Result, Rest: String);
  Function  Potenz_langsam        (a, b: String): String;
End;

» wer die Parameter a und b vor Funktionsaufruf selber normalisiert (also z.B. mindestens einmal nach Eingabe der Werte), der kann .ImmerNormalisieren auf False setzen und es wird dann nicht ständig, beim Starten von Funktionen, durchgeführt ... es wird so also einen Hauch flotter.



Einen Tipp noch zum Schluß: versucht besser nicht eine "größere" Potenz zu berechnen!
(B also nicht zu groß wählen)

Code:

[s]Function TMathe.Potenz(a, b: MatheString): MatheString;
  Begin
    Result := Potenz_langsam(a, b);
  End;[/s]

[edit2] wurde geändert

ChangeLog

[edit]
eine Auto-Refresh-CheckBox in den [berechnen]-Button gelegt

[16.06.2009 v1.0]
mit neuer Lizenz versehen (siehe oben)

[30.06.2009 11°° v1.1]
- einige Optimierungen
- Produkt10, Quotient10, Modulo10 und Co. hinzugefügt
- und der MatheParser kam auch dazu[

[30.06.2009 12°° v1.1]
- der Reinfolgefehler aus Beitrag #55 (Potenzen ala x^y^z) wurde behoben

[30.06.2009 12°° v1.1]
- der Reinfolgefehler aus Beitrag #55 (Potenzen ala x^y^z) wurde behoben

[30.06.2009 14°° v1.1]
- weitere Fehler behoben ... siehe #57+#58
- der Fehler bei den Klammern ist hoffentlich behoben #60

[30.06.2009 15:40 v1.1]
- Fehler im Parser #61

[30.06.2009 16:30 v1.2]
- der Mathe-Parser-Demo um einige Features erweitert (wie den Zwischenspeicher)
- Verwaltung der Konstanten, Funktionen und Operatoren erstellt (im Mathe-Parser)

[01.07.2009 00:30 v1.3]
- ein bissl aufgeräumt
- TMathe.Quadratwurzel, TMathe.PotenzModulo und abhängiges stark beschleunigt
- TMathe.Quotient2 eingeführt r := a div 2 (Grund für vorherigen Punkt)
- Demo6 erstellt = "Fließkomma"-Parser (alles mit # rechnet noch mit "falscher" Nachkommabehandlung)

[01.07.2009 10°° v1.3]
- Anfänge eines UnitTests eingefügt
- XPMan wieder entfernt (#67)
- Fehler behoben (#67 inkompatible Typen)
- TMathe.Produkt nach xZise #67 geändert

[01.07.2009 14²° v1.4]
- einige Dateien von UTF-8 nach Ansi konvertiert
- wegen #72 Version erhöht und alles neu kompiliert bzw. hochgeladen
- weitere Konstanten in die Parser eingefügt

[01.07.2009 14³° v1.4]
- Fehler bei internen Verwaltungsoperatoren behoben ... z.B. Komma wurde nicht erkannt

[01.07.2009 19°° v1.4]
- Verzögerungsfehler in Division entfernt, welcher die Rechenoptimierung abschaltete (#76)
- Vergleichsfunktion optimiert (#76)
- Potenz10, Produkt10 und Quotient10 in StringMatheParserFloat.pas berichtig und freigegeben (Nachkommastellenproblem #76)

[01.07.2009 20°° v1.5]
- Rechenfehler aus #67 behoben

[03.07.2009 12°° v1.5]
- Dezimalstellenfunktion mit Fehlerprüfung versehen und die Anzeiger der Stellen in den Demos etwas umgestellt (siehe #79..#81)

[03.07.2009 21³° v1.6]
- .Normalisieren und .Formatieren überarbeitet (#84)
- etwas aufgeräumt und die "InFile"-Hilfe erweitert
- doch wieder auf 7zip umgestiegen (ist 60% kleiner)

[gammatester]

Hier das nächste Parser-Feature: 3*-2 liefert -6, das ist zwar ungewöhnlich aber OK. Aber 3*--2 liefert 3*--2! Ist zwar auch nicht falsch aber ...

[gammatester]

Diesmal was zur den Konstanten pi10, pi100 und e10. Da
Pi*10^100 = 31415926535897932384626433832795028841971693993751 05820974944592307816406
2862089986280348253421170679.821480865132823066470 93844609550582231725359408128481...
ist, sollten doch die letzten Stellen bei pi10 ...26536 und bei pi100 ...70680 lauten. Analalog e10='27182818285'.

[edit=Luckie]Beitrag formatiert. Mfg, Luckie[/edit]

[himitsu]

zu PI und e ... nein, denn ich hab vorgestern gelernt, daß derartige Zahlen nicht gerundet werden.

Wiki hat gesagt:

Anm.: Der angegebene Wert ist nicht π auf 100 Nachkommastellen gerundet, sondern es handelt sich um die ersten 100 Stellen der Dezimalentwicklung, d.h., die 100. Nachkommastelle ist eine 9. Gerundet wären die letzten zwei Ziffern 80, nicht 79 (die 101. Stelle lautet auf 8). In der Zahlentheorie wird prinzipiell nicht gerundet, das ist nur bei konkreten physikalischen Messungen und ähnlichen Gebieten der angewandten Mathematik von belang.

3*--2 war ein Fehler in der "istZahl"-Prüfung, welcher die Zahl in den ersten zwei Durchgängen (2 und -2) durchließ, wobei auch --2 entstanden ist, aber bei der Übergabe an die Funktion es als Falsch ansah und somit nicht verarbeitete

[himitsu]

Hab die Veraltung der Konstanten, Funktionen und Operatoren etwas verbessert (bzw. erstmal Funktionen dafür erstellt)

* nun gibt es 2 Zwischenspeicher (Mem1 und Mem2 ... zum Speichern Button drücken und aufrufen via Konstante)
* und die Konstante "Last", welche das letzte "erfolgreiche" Ergebnis enthält
* die Rechendauer und Zahlengröße steht unterm Berechnenbutton
* im Edit wurde [Enter] zum Berechnen definiert

"1" ins Edit eintragen (man braucht halt erstmal ein "Last", um es zu verwenden)
[enter]
nun "Quadrat(Last)+1" ins Edit eintragen
[enter]
[enter]
[enter]
...

und nun nur noch zusehn, wie sich der Rechner bald zu tote rechnet

also mit Hilfe von Demo1 und Demo5 kann man sich nun vermutlich ganz leicht einen netten Ganzzahl-Taschenrechner zusammenbasteln


[add]
und ich hatte inzwischen mal die "langsamen" Funktions-Versionen rausgebaut,
dafür gibt es es jetzt bei einigen Funktionen anfangs eine auskommentierte Version

Delphi-Quellcode:

Function TMathe.Name(...
  //Begin
  //  ... langsamer/einfacherer Code
  //End;
  Begin
    ... etwas optierter Code
  End;

[himitsu]

- ein bissl aufgeräumt
- TMathe.Quadratwurzel, TMathe.PotenzModulo und Abhängiges stark beschleunigt
- schnellen TMathe.Quotient2 eingeführt r := a div 2 (Grund für vorherigen Punkt)
- Demo6 erstellt = "Fließkomma"-Parser (alles mit # rechnet noch mit "falscher" Nachkommabehandlung)

Download in #1

[xZise]

Moin!

Ich habe mir dein Code mal angeguckt. An sich ganz ordentlich (wobei ich es selber hasse, wenn "Sonderzeichen" benutzt werden (außer Konstanten) ). Aber es ist dein Code also kein Ding.

Aber eine Sache zu Produkt! Im Moment sieht das so aus:

Delphi-Quellcode:

While b <> '' do Begin
  For i := 1 to ZeichenZuZahl[b[Length(b)]] do Result := Summe(Result, a);
  a := a + '0';             // a := Produkt(a, '10');
  Delete(b, Length(b), 1);  // b := Quotient(b, '10');
End;

Könnte man da nicht eine For-Schleife verwenden?

Delphi-Quellcode:

for j := Length(b) downto 1 do
begin
  for i := 1 to ZeichenZuZahl[b[j]] do Result := Summe(Result, a);
  a := a + '0';
end;

So fällt der Delete-Befehl weg. Und man ruft nur noch einmal "Length()" auf, statt wie jetzt 2*<Anzahl Stellen>. Außerdem ist imho eine For-Schleife immer schneller als eine entsprechende While-Schleife.

MfG
xZise

[gammatester]

Leider sind in der neuesten Ausgabe einige Verschlimmbesserungen drin:

1. Nicht mehr D6-kompatibel (xpman ...)

2. Auch D7 und höher gehen (bei mir) nicht:
M7\DCC32 -b Demo6.dpr
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
StringMatheLib.pas(1104)
StringMatheParserFloat.pas(660) Error: Incompatible types
StringMatheParserFloat.pas(919)
Demo6U.pas(5) Fatal: Could not compile used unit 'StringMatheParserFloat.pas'


Habe gestern abend noch einige Features (der alten Vers) gefunden.

Wenn x ein positive Zahl ist:

Code:

PotenzModulo(x,0,0)   -> 1  statt Fehler
PotenzModulo(x,0,1)   -> 1  statt 0
PotenzModulo(x,0,-1)  -> 1  statt 0

Plus1(-1)             -> -0  statt 0
Negieren(0)           -> -0  statt 0
Quotient(-0,-x)       -> -0  statt 0
Produkt(-x,0)         -> -0  statt 0

Übrigens: Ich (und mein Modem) fänden es toll, wenn die immer mehr werdenden Demo-EXE-Files separiert würden zum Runterladen bzw. ein separates nur Source-Zip da wäre.

Gammatester

[himitsu]

Sonderzeichen, Sonderzeichen ... Sonderzeichen?
(hatte mal 'nen Tag lang ain ä in einem Funktionsnamen ... ist schon irgendwie cool )

jetzt nur noch a := a + '0'; durch das "neue" Produkt10(a, 1); ersetzt und es sieht fast schon professionell aus

Zitat:

Außerdem ist imho eine For-Schleife immer schneller als eine entsprechende While-Schleife.

nicht immer, aber da es hier nicht vorrangig um Geschwindigkeit, sondern "Einfachheit" geht, werd ich das jetzt nicht nachmessen und einfach so einbauen

[add]
das xpman kann man ja beruhigt entfernen
hmmm, ich wußte nicht, in wie weit die D2009-.RES incl. Manifest mit älteren Delphis harmoniert, drum hatte ich eine D7-.RES verwendet und halt das XP-Manifest einzeln ... das kann ich ja gern wieder rückgängig machen

OK, hab ja auch sowas wie Modem (bin gestern 'ne Weile nur mit GPRS reingekommen )

-0 mal sehn was da falsch läuft und eigentlich sollte das - von der Normlisierung entfernt werden

Zitat:

StringMatheLib.pas(1104)
StringMatheParserFloat.pas(660) Error: Incompatible types
StringMatheParserFloat.pas(919)

hmmmm , wie sind denn die kompletten Meldungen?
- StringMatheLib.pas(1104) gibt es nicht ... es existieren doch nur 1103 Zeilen
- die 660 ... wundert mich jetztz, daß dieses gestern noch ging einen String nach "Char" Casten und erfolgreich vergleichen
- 919 ist klar (liegt an 660)

[gammatester]

In Ord(TMatheParserFListe(Liste[i + 1].Operanden)[i3].Operand) wendest Du ord auf einen String. Kann mir eigentlich keine Delphiversion vorstellen, die das erlaubt.

[xZise]

Zitat von himitsu:

[...]jetzt nur noch a := a + '0'; durch das "neue" Produkt10(a, 1); ersetzt und es sieht fast schon professionell aus

Naja ich weiß nicht Weil P10 macht mehr als an a eine 0 dran zuhängen. Weil P10 halt universell ist. Wobei du könntest ja einige "Kernfunktionen" erstellen die privat oder protected sind, die keine Prüfungen durchführen. Also das P10 nur "n Nullen" dran hängt.

Zitat von himitsu:

Zitat:

Außerdem ist imho eine For-Schleife immer schneller als eine entsprechende While-Schleife.

nicht immer, aber da es hier nicht vorrangig um Geschwindigkeit, sondern "Einfachheit" geht, werd ich das jetzt nicht nachmessen und einfach so einbauen

Zitat von himitsu:

[...]und ich hatte inzwischen mal die "langsamen" Funktions-Versionen rausgebaut,[...]

Aber ganz von der Hand zu weisen ist das Bestreben nach schnelleren Code ja auch nicht

MfG
xZise