Zahl als Bruch speichern

[dino]

was heisst packed record und was gibts da für alternativen?

also das sieht so wie es aussieht schon vernünftiger für mcih aus

nur wäre es auch schön, wenn ich dabei auch noch

xyz1+xyz2 ermöglichen könnte

also dass ich dann ergendwie festlege, dass wenn man ihn mit nem typ Txyz multipliziert, dass dann x,y und z jeweils addiert werden solen, oder dass wenn man dazu nen integer addiert, dass der integerwert einfach zu x addiert werden soll

oder wenn man zu nem integer das addiert, dann soll zum integer x,y und z addiert werden

sowas halt...

[Khabarakh]

Das geht nur mit neueren Versionen, mit Delphi 5 wird's dann eben irgendwie so aussehen:

Delphi-Quellcode:

Summe := AddiereBrueche(Buch1, Bruch2);

Ist aber noch erträglich, oder :zwinker: ?

[dino]

ist das jetzt für den fall klasse oder für den fall type record?

[Sunlight7]

Das is was für ein Record

[dino]

achso

ja schade aber es ist wirklcih erträglcih (musste heute schon härtere schicksalsschläge hinnehmen)

[dino]

wollte nur bescheid sagen, dass ich es jetzt mit record geschafft habe

hab mir ne eigene unit dafür gemacht

wer also mal mit brüchen arbeiten möchte, der kann sich ja meine anschauen und ggf anpassen

edit:

also zähler hab cih eunfach mal a und nenner b genannt...
mal, geteilt, plus, minus mit brüchen oder integer alles mit drin

dazu noch ein kleines bisschen kürzen(für miene zwecke ausreichend)

bruchtostr und noch einiges mehr ist auch noch drin

edit2: was ich eigetnlich sagen wollte:
Danke für eure Hilfe!
durch euch hab ich nun auch das geschafft

[dino]

falls ich rückmeldung zu der unit wünsche muss ichs wohl als eigenes Thema veröffentlichen, oder?

[Sunlight7]

Schau mal da: Open Source ;)

[WS1976]

Hallo,

hier meine Lösung:

Delphi-Quellcode:

unit U_bruchrechnen;

interface
Type
  Bruchtyp=packed record
    z,n: int64; // Int64 wegen sehr großer Zahlen
  end;

  TBruch = class(TObject)
    //kleinsten gemeinsamen Teiler ermitteln
    function ggt(b0,b1:int64):int64;
    //kleinstes gemeinsames Vielfaches ermitteln
    function kgv(b0,b1:int64):int64;
    //Bruch kürzen
    function red(b0,b1:int64):Bruchtyp;
    //Bruch bo und b1 addieren
    function add(b0,b1: Bruchtyp):Bruchtyp;
    //Von Bruch b0 Bruch b1 abziehen
    function sub(b0,b1: Bruchtyp):Bruchtyp;
    //Bruch bo und b1 multiplizieren
    function mul(b0,b1: Bruchtyp):Bruchtyp;
    //Bruch bo durch Bruch b1 dividieren
    function divide(b0,b1: Bruchtyp):Bruchtyp; 
  end;

implementation

function TBruch.add(b0,b1: Bruchtyp):Bruchtyp;
var a:integer;b:bruchtyp;
  Begin
    a:=kgv(b0.n,b1.n);
    b.n:=a;
    b.z:=(a div b0.n)*b0.z+(a div b1.n)*b1.z;
    result:=red(b.z,b.n);
  End;

function TBruch.sub(b0,b1: Bruchtyp):Bruchtyp;
var a:integer;b:bruchtyp;
  Begin
    a:=kgv(b0.n,b1.n);
    b.n:=a;
    b.z:=(a div b0.n)*b0.z-(a div b1.n)*b1.z;
    result:=red(b.z,b.n);
  End;

function TBruch.mul(b0,b1: Bruchtyp):Bruchtyp;
  Begin
    result:=red(b0.z*b1.z,b0.n*b1.n);
  End;

function TBruch.divide(b0,b1: Bruchtyp):Bruchtyp; // div geht nicht, weil das ja ein geschützter begriff ist...
  Begin
    result:=red(b0.z*b1.n,b0.n*b1.z);
  End;

function TBruch.ggt(b0,b1:int64):int64;
var a,b,r:integer;
  Begin
    If b0>b1 then
       Begin
         a:=b0; b:=b1
       end
    else
       begin
         b:=b0; a:=b1;
       end;
  // Berechnung des ggt
  repeat
    r:= a mod b;
    a:=b;
    b:=r
  until (r=0);
  result:=a;
End;

function TBruch.kgv(b0,b1:int64):int64;
  Begin
    result:=b0*b1 div ggt(b0,b1);
  End;

function TBruch.red(b0,b1:int64):Bruchtyp;
var a,a0,a1:integer;
  Begin
    a0:=b0;a1:=b1;
    while ggt(a0,a1)<>1 do
      Begin
        a:=ggt(a0,a1);
        a0:=a0 div a;
        a1:=a1 div a;
      End;
    result.z:=a0;
    result.n:=a1;
  End;
end.

Grüsse
Rainer

PS: Bis auf die Grundrechenarten ist alles aus der DP zusammengesucht.

[alzaimar]

Die Methoden red, ggt und kgv sollten als private deklariert werden, weil man die nie braucht und sie daher eh nur innerhalb der Klasse verwendet werden.