qwertz543221 kleine String-Math-Lib

[himitsu]

Also nach der einfachen Methode sollte das Ergebnis aber zumindestens richtig sein und dem Ergebnis des DIV-Operators entsprechen.
Und Endlosschleife dürfte auch nicht ganz stimmen ... nur halt langsam, da womöglich viele Schleifendurchläufe nötig sind

z.B. 1000000 div 2 bzw. mathe.differenz('1000000', '2') benötigt so immerhin schon 500000 Durchläufe

Aber es ist einfacher wirklich erstmal aufzuräumen.
Es wird später sonst immer schwieriger, da es ja immer mehr und unübersichtlicher wird.

Der Vorteil der Klasse bzw. daran daß es in einer eigenen Unit liegt:
man kann es später auch mal in anderen Projekten wiederverwenden ... ist es direkt eingebaut, ist es nur da nutzbar, wo es eingebaut wurde.


Und ist dir schonmal aufgefallen, daß deine Funktionen nur positive ganze Zahlen mögen?


Wie schon von wem erwähnt:
Die beiden globalen Strings xa und xb haben da auch nix zu suchen, sie werden nur in der Funktion vergleich verwendet.
Ein sehr wichtiger Grund gegen soetwas sind z.B. mehrere Threads ... also wenn z.B. diese Funktion zweimal gleichzeitig in unterschiedlichen Threads verwendet wird, dann wollen beide Funktionen diese Variablen verwenden und "ärgern" sich gegenseitig.

hier mal ein Vorschlag, für eine Basisklasse:

Delphi-Quellcode:

unit StringMathLib;

interface
  uses Types, SysUtils;

  type 
    TMathe = class
      procedure normalisieren(var   a:    AnsiString);
      procedure formatieren  (var   a:    AnsiString; tausenderPunkte, immerVorzeichen: Boolean; mindestlaenge: Integer = 0);

      function  summe        (const a, b: AnsiString): AnsiString;
      function  differenz    (const a, b: AnsiString): AnsiString;
      procedure plus1        (var   a:    AnsiString);
      procedure minus1       (var   a:    AnsiString);
      procedure negieren     (var   a:    AnsiString);

      function  produkt      (const a, b: AnsiString): AnsiString;
      function  quotient     (const a, b: AnsiString): AnsiString;
      function  modul        (const a, b: AnsiString): AnsiString;
      procedure quotientModul(const a, b: AnsiString; var q, m: AnsiString);

      function  vergleich    (const a, b: AnsiString): TValueRelationship;
      function  istPositiv   (const a:    AnsiString): Boolean;
      function  istNegativ   (const a:    AnsiString): Boolean;
      function  istGerade    (const a:    AnsiString): Boolean;
      function  istUngerade  (const a:    AnsiString): Boolean;
    end;

implementation
  procedure TMathe.normalisieren(var a: AnsiString);
  var
    i: Integer;
    v: Boolean;
  begin
    a := Trim(a);
    for i := Length(a) downto 1 do
      if not (a[i] in ['0'..'9', ',', '-']) then
        Delete(a, i, 1);
    v := False;
    while (a <> '') and (a[1] = '-') do
    begin
      v := not v;
      Delete(a, 1, 1);
    end;
    for i := Length(a) downto 1 do
      if a[i] = '-' then
        Delete(a, i, 1);
    while (a <> '') and (a[1] = '0') do
      Delete(a, 1, 1);
    if a = '' then a := '0';
    if v then a := '-' + a;
  end;

  procedure TMathe.formatieren(var a: AnsiString;
    tausenderPunkte, immerVorzeichen: Boolean; mindestlaenge: Integer = 0);
  var
    i, i2: Integer;
  begin
    normalisieren(a);
    if (a <> '') and (a[1] = '-') then i2 := 2 else i2 := 1;
    i := Length(a) - 2;
    while i > i2 do begin
      Insert('.', a, i);
      Dec(i, 3);
    end;
    if i2 = 1 then
    begin
      Insert('+', a, 1);
      i2 := 2;
    end;
    while Length(a) < mindestlaenge do
      Insert('0', a, i2)
  end;

  procedure TMathe.angleichen(var a, b: AnsiString);
  begin

  end;

  function TMathe.summe(const a, b: AnsiString): AnsiString;
  begin

  end;

  function TMathe.differenz(const a, b: AnsiString): AnsiString;
  begin

  end;

  procedure TMathe.plus1(var a: AnsiString);
  begin

  end;

  procedure TMathe.minus1(var a: AnsiString);
  begin

  end;

  procedure TMathe.negieren(var a: AnsiString);
  begin
    normalisieren(a);
    if a[1] = '-' then
      Delete(a, 1, 1)
    else
      Insert('-', a, 1);
  end;

  function TMathe.produkt(const a, b: AnsiString): AnsiString;
  begin

  end;

  function TMathe.quotient(const a, b: AnsiString): AnsiString;
  var
    m: AnsiString;
  begin
    quotientModul(a, b, Result, m);
  end;

  function TMathe.modul(const a, b: AnsiString): AnsiString;
  var
    q: AnsiString;
  begin
    quotientModul(a, b, q, Result);
  end;

  procedure TMathe.quotientModul(const a, b: AnsiString; var q, m: AnsiString);
  begin

  end;

  function TMathe.vergleich(const a, b: AnsiString): TValueRelationship;
  begin

  end;

  function TMathe.istPositiv(const a: AnsiString): Boolean;
  begin
    normalisieren(a);
    Result := a[1] <> '-';
  end;

  function TMathe.istNegativ(const a: AnsiString): Boolean;
  begin
    normalisieren(a);
    Result := a[1] = '-';
  end;

  function TMathe.istGerade(const a: AnsiString): Boolean;
  begin
    normalisieren(a);
    Result := a[Length(a)] in ['0', '2', '4', '6', '8'];
  end;

  function TMathe.istUngerade(const a: AnsiString): Boolean;
  begin
    normalisieren(a);
    Result := a[Length(a)] in ['1', '3', '5', '7', '9'];
  end;

end.

und zur Verwendung: eine Instanz der Klasse anlegen und schon kann's losgehn

Delphi-Quellcode:

uses StringMathLib;

var
  mathe:   TMathe;
  a, b, c: AnsiString;

begin
  mathe := TMathe.Create;

  a := '123';
  b := '456';
  c := mathe.summe(a, b);
  if mathe.vergleich(c, '56088') = 0 then ;

  mathe.Free;
end;