Bruchrechnung und das kürzen...

[Anigmos]

Hi,

Ich habe ein Problem ich wollte/muss eine Art Bruch-Taschenrechner programmieren der die Zahlen auch kürzt...nun habe ich ein Problem ich habe alles fertig bis auf das kürzen, die ggt funktion ist auch schon geschrieben... nur muss man sie ja auch irgendwie einbinden um so einen bruch als gemischte zahl angeben zu können. Wie mach ich das???


Hier das programm:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Zaehler1Edit: TEdit;
    Nenner1Edit: TEdit;
    OperatorEdit: TEdit;
    Zaehler2Edit: TEdit;
    Nenner2Edit: TEdit;
    RechnenButton: TButton;
    ErgebnisZaehlerEdit: TEdit;
    ErgebnisNennerEdit: TEdit;
    GanzzahlEdit: TEdit;
    EndeButton: TButton;
    procedure EndeButtonClick(Sender: TObject);
    procedure RechnenButtonClick(Sender: TObject);
    procedure ErgebnisZaehlerEditChange(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function ggT(a, b:Integer):Integer;
var
res:Integer;
begin
   repeat
          res := a mod b;
          a:=b;
          b:=res;
   until b <> 0;
end;

{*
procedure B_kuerzen(..);           <------ soll auch verwendet werden
}

procedure B_multiplizieren(var z1,z2,n1,n2,zerg,nennerg:real);
begin
zerg:= z1*z2;
nennerg:=n1*n2;
end;


procedure B_dividieren(var z1,z2,n1,n2,zerg,nennerg:real);
begin
zerg:= z1*n2;
nennerg:=n1*z2;
end;

procedure b_addieren(var z1,z2,n1,n2,zerg,nennerg:real);
begin
zerg:=(z1*n1)+(z2*n1);
nennerg:=n1*n2
end;

procedure B_subtrahieren(var z1,z2,n1,n2,zerg,nennerg:real);
begin
zerg:=(z1*n1)-(z2*n1);
nennerg:=n1*n2
end;

procedure TForm1.EndeButtonClick(Sender: TObject);
begin
close
end;

procedure TForm1.RechnenButtonClick(Sender: TObject);
var z1,z2,n1,n2,zerg,nennerg:Real;
begin

z1:=strtofloat(Zaehler1Edit.text);
z2:=strtofloat(Zaehler2Edit.text);
n1:=strtofloat(nenner1edit.text);
n2:=strtofloat(nenner2edit.text);
if operatoredit.text = '*' then B_multiplizieren(z1,z2,n1,n2,zerg,nennerg);
if operatoredit.text = '/' then B_dividieren(z1,z2,n1,n2,zerg,nennerg);
if operatoredit.text = '+' then B_addieren(z1,z2,n1,n2,zerg,nennerg);
if operatoredit.text = '-' then B_subtrahieren(z1,z2,n1,n2,zerg,nennerg);
// Ausgabe
ErgebnisZaehlerEdit.text:=Floattostr(zerg);
ErgebnisNennerEdit.text:=Floattostr(nennerg);
end;

procedure TForm1.ErgebnisZaehlerEditChange(Sender: TObject);
begin

end;

end.

[Sidorion]

Zunächst: Deine Funktion ggT leifert nix zurück (nein falsch: die liefert irgendeinen Integer, was halt grad im Speicher steht). Also entweder res durch Result ersetzen oder Result:=res ans Ende einfügen.
Zum Kürzen: ggt mit Zähler und Nenner aufrufen und danach beide durch das Ergebnis von ggt teilen.

[Anigmos]

also der ggt sollte eigentlich funktionieren hab das in nem anderen programm schon benutzt deswegen seh ich da kein problem oder doch?

Zitat:

Zum Kürzen: ggt mit Zähler und Nenner aufrufen und danach beide durch das Ergebnis von ggt teilen.

verstehe ich nicht so ganz

Delphi-Quellcode:

procedure B_kuerzen(var z1,z2,n1,n2,zerg,nennerg,ganerg:real);
begin
ganerg:= (ggt(a,b)/z1)7(ggt(a,b)/z2)   //so?
end;

[yörsch]

Hai,

Delphi-Quellcode:

function ggT(a, b:Integer):Integer; 
var 
res:Integer; 
begin 
   repeat 
          res := a mod b; 
          a:=b; 
          b:=res; 
   until b <> 0; 
end;

was für einen wert soll result (also das ergebnis haben ???)
wenn ich die Funktion sosehe dann wohl : result := res; :drunken:

[TonyR]

Zitat:

Zitat von Anigmos

Delphi-Quellcode:

procedure B_kuerzen(var z1,z2,n1,n2,zerg,nennerg,ganerg:real);
begin
ganerg:= (ggt(a,b)/z1)7(ggt(a,b)/z2)   //so?    Eigentlich nicht, NEIN
end;

Ich finde mich hier überhaupt nicht rein, tut mir leid!

Warum hast du nicht TBruch als einen Record deklariert?

Delphi-Quellcode:

TBruch = record
  Zahler, Nenner: Integer;
end;

und jetz:

Delphi-Quellcode:

procedure kurzen(Ausgangsbruch, Ergebnisbruch: Tbruch);
begin
Ergebnisbruch.zahler:=Round(Ausgangsbruch.zahler div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));
Ergebnisbruch.nenner:=Round(Ausgangsbruch.nenner div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));
end;

[Anigmos]

Zitat:

Zitat von yörsch

Hai,

Delphi-Quellcode:

function ggT(a, b:Integer):Integer; 
var 
res:Integer; 
begin 
   repeat 
          res := a mod b; 
          a:=b; 
          b:=res; 
   until b <> 0; 
end;

was für einen wert soll result (also das ergebnis haben ???)
wenn ich die Funktion sosehe dann wohl : result := res; :drunken:

res hat das ergebnis a mod b ?

Zitat:

Zitat von TonyR

Zitat:

Zitat von Anigmos

Delphi-Quellcode:

procedure B_kuerzen(var z1,z2,n1,n2,zerg,nennerg,ganerg:real);
begin
ganerg:= (ggt(a,b)/z1)7(ggt(a,b)/z2)   //so?    Eigentlich nicht, NEIN
end;

Ich finde mich hier überhaupt nicht rein, tut mir leid!

Warum hast du nicht TBruch als einen Record deklariert?

Delphi-Quellcode:

TBruch = record
  Zahler, Nenner: Integer;
end;

und jetz:

Delphi-Quellcode:

procedure kurzen(Ausgangsbruch, Ergebnisbruch: Tbruch);
begin
Ergebnisbruch.zahler:=Round(Ausgangsbruch.zahler div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));
Ergebnisbruch.nenner:=Round(Ausgangsbruch.nenner div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));
end;

Das geht leider nicht...Wir dürfen nur mit mitteln Arbeiten, die wir schon hatten... Worin ich überhaupt keinen Sinn sehe aber das ist ein anderes Thema...

[TonyR]

Aber ich hoffe du verstehst meine Vorgehensweise hier:

Delphi-Quellcode:

procedure kurzen(Ausgangsbruch, Ergebnisbruch: Tbruch);
begin

Ergebnisbruch.zahler:=Round(Ausgangsbruch.zahler div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));

Ergebnisbruch.nenner:=Round(Ausgangsbruch.nenner div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));

end;

So geht das nämlich => dürfte ja selbsterklärend sein :wink:
Und jetzt kannst du deine eigene Prozedur mit deinen 100 Variablen schreiben, oder nicht?

[Anigmos]

Zitat:

Zitat von TonyR

Aber ich hoffe du verstehst meine Vorgehensweise hier:

Delphi-Quellcode:

procedure kurzen(Ausgangsbruch, Ergebnisbruch: Tbruch);
begin

Ergebnisbruch.zahler:=Round(Ausgangsbruch.zahler div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));

Ergebnisbruch.nenner:=Round(Ausgangsbruch.nenner div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));

end;

So geht das nämlich => dürfte ja selbsterklärend sein :wink:
Und jetzt kannst du deine eigene Prozedur mit deinen 100 Variablen schreiben, oder nicht?

;) ja ist es ;) war irgendwie grade neben mir :freak: aber da kommt mir ein neues problem in denn Sinn...Wie kann ich die ganzzahl anzeigen lassen? ist das dann nicht

Delphi-Quellcode:

ganzezahl:=   ???? div ???

ICh hoffe du verstehst mein Problem :gruebel:

[TonyR]

Zitat:

Zitat von Anigmos

...ICh hoffe du verstehst mein Problem :gruebel:

Nein.
"Round" rundet Zahlen immer zu einer Ganzzahl, es gibt also eine Ganzzahl wieder. Und wenn ich das hier verwende:

Delphi-Quellcode:

Round(Ausgangsbruch.zahler div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));

wird eine Ganzahl zurückgeliefert... es kommt also zu keinem Problem.
Falls ich dich wirklich falsch verstanden habe, einfach nochmal genauer fragen :wink:

[Anigmos]

Zitat:

Zitat von TonyR

Zitat:

Zitat von Anigmos

...ICh hoffe du verstehst mein Problem :gruebel:

Nein.
"Round" rundet Zahlen immer zu einer Ganzzahl, es gibt also eine Ganzzahl wieder. Und wenn ich das hier verwende:

Delphi-Quellcode:

Round(Ausgangsbruch.zahler div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));

wird eine Ganzahl zurückgeliefert... es kommt also zu keinem Problem.
Falls ich dich wirklich falsch verstanden habe, einfach nochmal genauer fragen :wink:

Round dürfen wir nicht benutzen...fürs runden gibt es ja dieses f oderso...
Ich hab mal ein Bild angehangen wie ich es meine ( mit den Ausgabe werten)

[TonyR]

Informatik Klasse 11???
Ich hab so was auch mal gemacht (siehe Anhang).

Ich bin auch dumm ... :oops:
Man muss ja gar nicht mehr runden (rein theoretisch) => es kommt ja ne Ganzzahl raus (wegen ggt).
Aber ob der Compiler das auch weis kann ich jetzt gar nicht sagen...
Hast du noch ein Problem oder funkt das jetzt so?

PS: Zitiere bitte nicht immer ganze Posts (wegen übersichtlichkeit und Platz)

[Anigmos]

Jop info klasse 11 genau so ein programm sollten wir schreiben...
Wenn ich bei mir jetzt 15/15 * 15/15 bekomme ich ein error mit dem fehler division durch 0...Irgendwas ist noch faul ;)

[TonyR]

dann musst du mal Haltepunkte in dein Prog einfügen und wenn es dann unterbrochen wurde, musst du mit F7 jede Zeile einzeln weiterrücken und gucken an welcher stelle genau dein Prog den Error verursacht! Und wenn du dir das nicht erklären kannst warum, dann poste die Stelle, die nicht geht!

[Anigmos]

wie macht man denn die haltepunkte?

[TonyR]

bei einer Quelltextzeile links auf den grauen rand klicken, da dürfte dann so ein roter punkt erscheinen

[Anigmos]

das problem liegt beim ggt?! :gruebel:

Delphi-Quellcode:

          result:= a mod b;

und hier nochmal der Code wie er jetzt ist...

Delphi-Quellcode:

// Z1 ist der 1. Zähler
// Z2 der 2. Zähler
// n1 der erste nenner
// n2 der zweite nenner
// zerg Zählerergebnis
//nenner Nennerergebnis
//ganerg Ganzzahlenergebnis
unit mBruchrechnen;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Zaehler1Edit: TEdit;
    Nenner1Edit: TEdit;
    OperatorEdit: TEdit;
    Zaehler2Edit: TEdit;
    Nenner2Edit: TEdit;
    RechnenButton: TButton;
    ErgebnisZaehlerEdit: TEdit;
    ErgebnisNennerEdit: TEdit;
    GanzzahlEdit: TEdit;
    EndeButton: TButton;
    procedure EndeButtonClick(Sender: TObject);
    procedure RechnenButtonClick(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}
// GGT Bestimmung
function ggT(a, b:integer):integer;
begin
   repeat
          result:= a mod b;
          a:=b;
          b:=result;
   until b <> 0;
end;

//Kürzen
procedure B_kuerzen(var z1,z2,n1,n2,zerg,nennerg,ganerg:integer);
begin
zerg:=zerg div(ggt(zerg,nennerg));
nennerg:=nennerg div (ggt(zerg,nennerg));
end;
// Brüche Multiplizieren
procedure B_multiplizieren(var z1,z2,n1,n2,zerg,nennerg:integer);
begin
zerg:= z1*z2;
nennerg:=n1*n2;
end;

// Brüche Dividieren
procedure B_dividieren(var z1,z2,n1,n2,zerg,nennerg:integer);
begin
zerg:= z1*n2;
nennerg:=n1*z2;
end;
// Brüche addieren
procedure b_addieren(var z1,z2,n1,n2,zerg,nennerg:integer);
begin
zerg:=(z1*n1)+(z2*n1);
nennerg:=n1*n2
end;
// Brüche subtrahieren
procedure B_subtrahieren(var z1,z2,n1,n2,zerg,nennerg:integer);
begin
zerg:=(z1*n1)-(z2*n1);
nennerg:=n1*n2
end;

procedure TForm1.EndeButtonClick(Sender: TObject);
begin
close
end;

procedure TForm1.RechnenButtonClick(Sender: TObject);
var z1,z2,n1,n2,zerg,nennerg,ganerg:integer;
begin
//eingabe
z1:=strtoint(Zaehler1Edit.text);
z2:=strtoint(Zaehler2Edit.text);
n1:=strtoint(nenner1edit.text);
n2:=strtoint(nenner2edit.text);
// Abfrage des Operators und ausführen der jeweiligen Funktion
if operatoredit.text = '*' then B_multiplizieren(z1,z2,n1,n2,zerg,nennerg);
if operatoredit.text = '/' then B_dividieren(z1,z2,n1,n2,zerg,nennerg);
if operatoredit.text = '+' then B_addieren(z1,z2,n1,n2,zerg,nennerg);
if operatoredit.text = '-' then B_subtrahieren(z1,z2,n1,n2,zerg,nennerg);
// Kürzen
B_kuerzen(z1,z2,n1,n2,zerg,nennerg,ganerg);
// Ausgabe
GanzzahlEdit.text:=inttostr(ganerg);
ErgebnisZaehlerEdit.text:=inttostr(zerg);
ErgebnisNennerEdit.text:=inttostr(nennerg);
end;

end.

[marabu]

Hallo Anigmos,

ich fürchte du verwendest den euklidischen Algorithmus ohne ihn zu verstehen. Betrachte zumindest mal die Rechenregeln im Wikipedia-Artikel. Und wenn du hier nach [dp]Euklid*[/dp] suchst, dann erhältst du auch noch jede Menge Lesestoff.

Freundliche Grüße

[TonyR]

Hier mal als Referenz meine ggt-Funktion!

Delphi-Quellcode:

function  ggT(a,b: integer):integer;
   var x :integer;
begin
   if b <> 0 then
   repeat
     x:=a mod b;
     a:=b;
     b:=x;
   until x = 0;
     result := abs(a); //falls a, oder b negativ
end;

Edit: die habe ich verstanden, aber vorher auch nur von dsdt.info kopiert :wink:

[bitsetter]

Ich habe mal ein kleines Beispiel zum Thema Brüche kürzen angehängt, weis aber nicht, ob du sowas meintest.

[Anigmos]

So noch langem hin und her hab ich 1. den fehler bei meinem algorithmus gefunden hab anstatt b = 0 b <> 0 gehabt :wall: Tja aber nun ist noch das problem mit der Ausgabe wie kann ich diese einbinden??

[TonyR]

du hast doch deine Edits schon so angeordnet, dass die Ausgabe kein Problem mehr darstellt (ich erinnere an den Screenshot).

Willst du jetzt noch wissen, wie du die Ganzzahl rausbekommst und den Rest als Bruch darstellst, oder was? Das solltest du aber eigentlich auch mit Mathematik-Kenntnissen der (was weis ich... auf jeden Fall einer Klasse die vor der 11. kommt) selber hinkriegen :wink:

[Anigmos]

Das Problem ist, ich kann es, kann es aber nicht schreiben :gruebel: ...

[Cöster]

Und wo konkret ist jetzt dein Problem?

[Anigmos]

Wie kann ich nun die ganzzahl und den bruch ausgeben??
Ich hasse es mathe zu programmieren ich programmier alles lieber modifikationen für spiele eigene addons die mir das verwalten erleichtern ALLES nur kein mathe :wall:

[Cöster]

Zitat:

Zitat von Anigmos

Delphi-Quellcode:

GanzzahlEdit.text:=inttostr(ganerg);
ErgebnisZaehlerEdit.text:=inttostr(zerg);
ErgebnisNennerEdit.text:=inttostr(nennerg);

Hast du selbst geschrieben. Das müsste doch gehen, oder versteh ich deine Frage falsch?

[Anigmos]

Er macht irgendwas falsch... es kommt bei 13/2 * 13/2 0 ganze und 52/1 raus das stimmt nicht so ganz^^"

[Cöster]

Zitat:

Zitat von Anigmos

Er macht irgendwas falsch... es kommt bei 13/2 * 13/2 0 ganze und 52/1 raus das stimmt nicht so ganz^^"

Dann liegt das aber nicht an der Ausgabe, sondern an den Rechnungen davor. Den Fehler findest du am besten, wenn du Haltepunkte ins Programm einbaust und dann debuggst. So lässt sich die Stelle schneller finden, an der einer Variable ein falscher Wert zugewiesen wird.

[TonyR]

Also Anigmos:
Ich hatte es ja schonmal geschrieben!
Mit dieser Formel bekommst du Zähler und Nenner des gekürzten Bruches!

Delphi-Quellcode:

procedure kurzen(Ausgangsbruch, Ergebnisbruch: Tbruch);
begin

Ergebnisbruch.zahler:=Ausgangsbruch.zahler div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner);

Ergebnisbruch.nenner:=Ausgangsbruch.nenner div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner);

end;

Um das jetzt noch so aufzusplitten, dass man eine Ganzzahl erhält, fällt mir auf die schnelle nur das hier ein:

Delphi-Quellcode:

var GDE{GanzzahlDesErgebnisbruchs}, RDE: word;

DivMod(ErgebnisBruch.zahler, Ergebnisbruch.Nenner, GDE, RDE);
Ergebnisbruch.zahler:=RDE;

GanzZahlEdit.text:=IntToStr(GDE);
ZahlerEdit.text:=IntToStr(Ergebnisbruch.zahler);
NennerEdit.text:=IntToStr(Ergebnisbruch.Nenner);

So und sag jetzt nicht, dass du es nicht kapierst!!!! :evil:
Es ist denk ich mal einleuchtend! Das einzige, was du ändern musst (weil du sagtest ja mal ihr dürft nur StiNo-Variablen benutzen), ist, deine unzähligen Variablen zu benutzen (anstatt Ergebnisbruch.zahler und so)!!!!!!
Aber wie schon gesagt, dürfte es dir nun ein Leichtes sein, das was ich geschrieben habe, auf deine Sache zu übertragen.

Zitat:

...ich programmier alles lieber modifikationen für spiele eigene addons ...

*kopfschüttel*...*kopfschüttel* mach lieber was sinnvolles :wink:


Edit: Um dir die richtige ggt-Funktion nochmal zu zeigen kopiere dir die von Beitrag #18 von mir!!!!!

[Dipl Phys Ernst Winter]

TonyR"

Delphi-Quellcode:

Function Kuerzen(zaehler,nenner:integer):Tbruch;

Warum übergibst Du den zu kürzenden Bruch zerpflückt in Zähler und Nenner?
(delphi]Ergebnisbruch.zahler:=Round(Ausgangsbruch.zahler div ggt(Ausgangsbruch.zahler,Ausgangsbruch.nenner));
[/delphi]
Was soll das Round? Das Ergebnis von div ist schon ein Integer!
Frage: Wird der ungekürzte Bruch wirklich noch gebraucht? Sonst

Delphi-Quellcode:

procedure Kuerzen(var Bruch: TBruch);

Dipl Phys Ernst Winter

[Dipl Phys Ernst Winter]

Gegenüber dem Rechnen mit Gleitkommazahlen ist das Rechnen mit Brüchen frei von Rundungsfehlern.
Diese treten erst auf, wenn wir den Bruch in eine Gleitkommazahl konvertieren.

Ich habe für euch eine Unit und ein Demo zur Bruchrechnung geschrieben