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;