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]

Ist es nicht langsam mal Zeit, in die Units eine Versionsnummer rein zuschreiben? Bei den häufigen Änderungen weiß man sonst ja gar nicht was aktuell ist und worauf man sich beziehen soll.

Außerdem sind auch dringend einige Kommentare nötig (bzw sinnwolle Bezeichner). Was zum Bleistift macht eigentlich in Positive StringMatheFloatRec.pas?????

Delphi-Quellcode:

Class Operator MatheStringX.Positive(r: MatheStringX): MatheStringX;
    Begin
      r.PruefeN;
      Result._n := r._n;
      Result._f := r._f;
    End;

oder: MatheStringX.Negative sollte doch wohl irgendwie "absolute" enthalten!? Vom Code habe ich den Eindruck, das nur was Negatives negiert wird (außer r.PruefeN, daß aber gar nix prüft, sondern aus einem Leerstring eine '0' macht). Ganz abgesehen davon, daß ich das Teil selbst mit Delphi 9 nicht übersetzen kann, geschweige denn mit D6.

[himitsu]

Zitat von gammatester:

Ist es nicht langsam mal Zeit, in die Units eine Versionsnummer rein zuschreiben?
Bei den häufigen Änderungen weiß man sonst ja gar nicht was aktuell ist und worauf man sich beziehen soll.

Kennst du die Gedanken, wie "so, es läuft und jetzt wird wohl so schnell nichts mehr dran geändert" ?

Nja, ich wollte demnächst da den Header wie aus himXML reinpacken, also zusammen mit Lizenz, Version und Co.
Nur bin ich da noch nicht ganz fertig ... kommt demnächst.

Aber immerhin wird seit 'ner Weile im Beitrag #1 ganz unten das Datum+Uhrzeit der da hochgeladenen Version angezeigt.

Aber ich schreibe vermutlich gleich meinen Lizenztext und dann kommst das alles mit rein.

[quote="gammatester"]Außerdem sind auch dringend einige Kommentare nötig (bzw sinnwolle Bezeichner). Was zum Bleistift macht eigentlich in Positive StringMatheFloatRec.pas?????

Delphi-Quellcode:

Class Operator MatheStringX.Positive(r: MatheStringX): MatheStringX;
    Begin
      r.PruefeN;
      Result._n := r._n;
      Result._f := r._f;
    End;

was Positive ist, steht in der Delphi-OH

im Grunde ist es eine "schwachsinnige" Funktion (zumindestens in Bezug auf "normale" Rechenoperationen),
denn es entspricht dem +X

PS: siehe http://www.delphipraxis.net/internal...t.php?t=151206

Negative ist -X

ja und Add ist X + Y

also in Positive wird hier praktisch nichts anderes gemacht, als den Wert unverändert zurückzugeben

Zitat von gammatester:

oder: MatheStringX.Negative sollte doch wohl irgendwie "absolute" enthalten!?

so hab ich's grad vorgefunden

Delphi-Quellcode:

Class Operator MatheString.Negative(Const r: MatheString): MatheString;
  Begin
    Result._i := r._i;
    If _Mathe.istPositiv(Result._i) Then _Mathe.Negieren(Result._i);
  End;

es wird die Zahl negativ gemacht ... und wie ich grad merk ist das völlig idiotisch,
denn es soll ja -X entsprechen ... also muß das IF-Then raus.

_i = der interne Integer
_f = der interne Float bzw. die Fließkommazahl

dachte eigentlich das könnte man sich noch denken, da es ja sonst keine internen Variablen gibt

OK und das _n ist neu und soll die Nachkommastellen enthalten (hab da grad einen Kommentag mit dazugeschrieben)

und sonst dachte ich, hällst die "unverwechselbaren" internen Variablen schön handlich kurz

PS: ja, ich weiß, viele nennen diese Art der Variablen Fname und bei mir ist es halt _name, da ich diese besser erkenne.

PrüfeN stellt nur sicher, daß _n keine uninitialisierten Werte enthält, da standardmäßig nur der String von Delphi automatisch initialisiert wird.

[himitsu]

Versionshinweis und Lizenz hinzugefügt

Version: v1.0 Stand 16.06.2009
Lizenzen: MPL + (L)GPL

neue Version mit Variants (StringMatheVar.pas) beigelegt ... man darf sich gern bei sirius dafür bedanken (oder ihn deswegen verhauen)

ja und ich hab mir mal erlaubt einen neuen Kommentar reinzumachen (beim _n in StringMatheFloatRec.pas)

[toms]

Zitat von himitsu:

Bin gespannt, ob es nun auch in D5 läuft.

Funktioniert noch nicht ganz:

[Error] StringMatheLib.pas(120): Undeclared identifier: 'TValueRelationship'

Zudem:

[Error] Demo1U.pas(43): Undeclared identifier: 'Buttons'

Delphi-Quellcode:

RadioGroup1.Buttons[1].Visible  := False;
RadioGroup1.Buttons[6].Visible  := False;
// etc..

müsste unter D5 so geschrieben werden:

Delphi-Quellcode:

    with RadioGroup1 do
    begin
       Controls[1].Visible := False;
       Controls[6].Visible := False;
       // etc.
    end;

[himitsu]

das .Controls läuft auch in aktuellen Versionen

ja und bezüglich des TValueRelationship ... da hatte klein himi die Ersatzdefinition an falscher Stelle definiert (erst nachdem sie das erste Mal verwendet würde)

[himitsu]

ich experimentiere grad mit einem MatheParser

was er so theoretisch kennt

• Klammern: ( )
  
• Operatoren: + - * / div // mod ^
  
  // = entspricht mod
  ^ = Potenz
  
• Konstanten:
  pi10 = π * 10^10
  pi100 = π * 10^100
  e10 = e * 10^10
  e100 = e * 10^100
  
• Funktionen: Summe Plus1 Differenz Minus1 Negieren Absolut
  Produkt Quotient Modulo Quadrat Quadratwurzel Potenz Potenz10
  SummeModulo DifferenzModulo ProduktModulo PotenzModulo
  Zufallszahl gibVorzeichen Dezimalstellen
  
  Parameter siehe TMathe
  gibVorzeichen = Mathe.gibVorzeichen + '1'

[edit]
Anhänge entfernt
siehe Beitrag #56: ist jetzt im Post #1 enthalten

[Dax]

Ist "Ergebis" absichtlich so geschrieben? O

[himitsu]

Zitat von Dax:

Ist "Ergebis" absichtlich so geschrieben? O

ja (ist ja fast so gut, wie das Parster, was es noch bis vor 1,5 Stunden gab)

[Dax]

Rein theoretisch könntest du dich ja des Schinkens annehmen und entsprechende Plugins für die SML basteln, meinst du nicht? *g*

[gammatester]

Bug: 2^10 = 20, 2^1000 mod 9 = 2 etc. Grund:

Delphi-Quellcode:

Function Operator_Potenz(Mathe: TMathe; Const a, b: String): String;
Begin
  Result := Mathe.Produkt(a, b);
End;