Die Zahl e, aber wie in Pascal? [Erledigt!!]

[Chegga]

Hi,

ich programmiere gerade einen Taschenrechner.
Nun will ich die Zahl e (2,7182...) nach einem Button.Click in einem Panel anzeigen lassen.

Die mathematische Formel für e ist:
e = ( 1 + 1/n)^n

Um so größer n ist, desto genauer wird e.
Wie setze ich das jetzt in Pascal um?

Delphi-Quellcode:

procedure TForm1.Button23Click(Sender: TObject);
var e: Real;
begin
  e := (1 + 1/1000)^1000;           // hier ist n z.B. 1000
  // weiterer Code...
end;

Dass das so nicht geht, ist mir völlig klar. :wink:
Vielleicht so irgendwie:

Delphi-Quellcode:

procedure TForm1.Button23Click(Sender: TObject);
var e: Real;
    Temp: String;
begin
  e := (1+1/1000);
  Str(sqr():3:1, Temp);
  // weiterer Code...
end;

Wie kann ich das sonst machen? :gruebel:

MfG Marc

[sniper_w]

Delphi-Quellcode:

const My_E = 2.7182818284590452353602874713527

:???:

[Dax]

Delphi-Quellcode:

e := Power(1 + 1 / 1000, 1000);

[Binärbaum]

Also so ginge es:

Delphi-Quellcode:

function GetEuler(n: Cardinal): Extended;
begin
  Result:= IntPower(1+1/n, n);//= (1+1/n)^n
end;

Allerdings kann es dabei ggf. zu einem Overflow kommen. Deshalb gibt es noch eine andere (allerdings langsamere) Methode:

Delphi-Quellcode:

function GetEuler(n: Cardinal): Extended;
  function Fakultaet(x: Cardinal): Int64;
  var c: Cardinal;
  begin
    Result:=2;
    for c:= 3 to x do
      Result:= Result*c;
  end;
var i: Integer;
begin
  Resuult:= 2;
  for i:= 2 to n do
    Result:= Result + 1/Fakultaet(i);
end;

Je höher dort n angegeben wird, umso genauer ist das Ergebnis.

MfG
Binärbaum

[Alexander]

Würde dir auch raten, e als Konstante zu hinterlegen, da es dir vermutlich nciht um Näherungsverfahren selber geht.

Erstmal kann es Problemem mit zu hohen Potenzen geben und zweites kannst du dir so ein wenig Rechenpower sparen :)

[Chegga]

Hi,

thanks @ all!

Ich habe Binärbaums Lösung übernommen. :thumb: (Klappt wunderbar!)

Zitat:

Zitat von sniper_w

Code:

const My_E = 2.7182818284590452353602874713527

:???:

Ein :mrgreen: reicht wohl. :mrgreen:
Genau so wollte ich es nicht haben. :wall:
(Trotzdem thx)

MfG Marc

[TeronG]

Ich kenn ja deine Anwendung nicht aber eine const währ doch viel fixer :gruebel: kannst ja im Vorfeld deinen Rechner mal über nacht laufen lassen, um dein e genau genug zu bekommen :mrgreen: (kannst ja dann wieder die zu genauen Kommastellen (niedriges n) wegkürzen :duck: )

[IngoD7]

Zitat:

Zitat von Binärbaum

Allerdings kann es dabei ggf. zu einem Overflow kommen.

Wie das denn? :gruebel:

Bei n=1 ist das Ergebnis 2.
Bei n=unendlich ist das Ergebnis e (also 2,71828..).

Ich denke doch, dass bestimmte Delphi-Zahlentypen einen Wert zwischen 2 und 2,718.. aufnehmen können. :twisted: :wink:

[Binärbaum]

Wenn es einfach nur um eine simple Rechnung geht, dann ist die Varainte, e als Konstante zu deklarieren und damit zu rechnen, am einfachsten (weil schnellste). Aber bei Näherungsverfahren für e kommt man um längere Berechnungen nun mal nicht herum.

MfG
Binärbaum

@IngoD7
Es ist mir schon klar, dass bei n=1 kein genauer Wert für e errechnet wird. Ich habe ja auch extra dazugeschrieben, dass die Werte nur genau sind, wenn n ziemlich groß ist. Und n=1 ist halt keine große Zahl. :roll:

[IngoD7]

Zitat:

Zitat von Binärbaum

@IngoD7
Es ist mir schon klar, dass bei n=1 kein genauer Wert für e errechnet wird. Ich habe ja auch extra dazugeschrieben, dass die Werte nur genau sind, wenn n ziemlich groß ist. Und n=1 ist halt keine große Zahl. :roll:

Und was hat das mit meinem Posting zu tun?
Achte bitte drauf, was gemeint war. Ich hatte deine Aussage mit dem Overflow zitiert und wollte darlegen, dass es dazu nicht kommen kann.

[Oxmyx]

[quote="IngoD7"]

Zitat:

Zitat von Binärbaum

Und was hat das mit meinem Posting zu tun?
Achte bitte drauf, was gemeint war. Ich hatte deine Aussage mit dem Overflow zitiert und wollte darlegen, dass es dazu nicht kommen kann.

Das Problem ist trotzdem die begrenzte Genauigkeit von Standarddatentypen. Wenn du dir die bekannte Formel (1+(1/n))^n anschaust, siehst du, dass 1/n für große n sehr klein wird. Und irgendwann wird aus 1/n dann eben faktisch 0, weil die Fließkommadarstellung keine kleineren Zahlen erlaubt. Und dann ist (1+1/n)^n für "n = sehr sehr hoch" eben 1, und nicht e.

[MagicAndre1981]

Zitat:

Nun will ich die Zahl e (2,7182...) nach einem Button.Click in einem Panel anzeigen lassen.

Zitat:

Zitat:

const My_E = 2.7182818284590452353602874713527

Genau so wollte ich es nicht haben. ouch!

warum wilst du eine Konstante nicht haben? Du willst doch einen Taschenrechner programmieren und kein Programm, dass die 2 Millionste Stelle von PI berechnet. :gruebel: Nimm doch die Konstante, dass ist am schnellsten.


André

[chkdsk]

Auch wenn es wahrscheinlich nur noch begrenzt sinnvoll ist, hier die Eulersche Zahl auf 200 Nachkommastellen genau:

Zitat:

2,718281828459045235360287471352662497757247093699 9595749669676277240766303 53547594571382178525166427427466391932003059921817 41359662904357290033429526059563 073813232862794349076323382988075319525101901

Oder noch genauer: http://wikisource.org/wiki/E_to_10%2C000_places


Also wenn es nicht um mathematische Herleitung geht, sondern rein darum, die Zahl zu benutzen, dann sind Konstanten wohl immer vorzuziehen.

[edit=sakura] Mal ein paar Umbrüche zugelassen :roll: Mfg, sakura[/edit]

[Binärbaum]

Es ist wohl kaum sinnvoll, e auf 200 oder mehr Stellen anzugeben, da die Floating-Point-Datentypen in Delphi nur auf ca. 10-15 Stellen genaue Werte speichern können (siehe OH zu den Datentypen Single, Real, Double, Extended).
Außerdem ging es dem Threadersteller auch um ein Näherungsverfahren und nicht darum, welches die 200. Stelle von e ist.

MfG
Binärbaum

[alcaeus]

Manchmal wundere ich mich ueber die Fantasielosigkeit der Programmierer:

Delphi-Quellcode:

var
  e: Extended;
//...
e := Exp(1);

Die Delphi-Hilfe haette euch gesagt:

function Exp(X: Real): Real;

Description

In Delphi code, Exp returns the value of e raised to the power of X, where e is the base of the natural logarithms.

Wenn also Exp den Wert von e^x gibt, dann ratet mal was wohl e^1 ist :roll:

Greetz
alcaeus

[Quake]

Wenn man n als Konstante angibt dann kann man auch gleich e als Konstante benutzen da die Formel eh immer den gleichen Wert errechnet.

[MaBuSE]

Zitat:

Zitat von alcaeus

Manchmal wundere ich mich ueber die Fantasielosigkeit der Programmierer:

Delphi-Quellcode:

var
  e: Extended;
//...
e := Exp(1);

Hier wird aber auch eine Konstante benutzt.

Die FPU des Prozessors bietet eine Konstante FLDL2E.

FLDL2E entspricht log2(e)

Exp(1) macht also "nur" ein 2^log2(e) :-)
-> also 2 ^ FLDL2E-Konstante

(Anmerkung: ^ = hoch bzw Power() )

Ich perönlich bevorzuge da eine Konstante wie schon weiter oben beschrieben.

Das ist der ASM Code von Exp()

Delphi-Quellcode:

asm
        {       e**x = 2**(x*log2(e))   }

        FLDL2E              { y := x*log2e;      }
        FMUL
        FLD     ST(0)       { i := round(y);     }
        FRNDINT
        FSUB    ST(1), ST   { f := y - i;        }
        FXCH    ST(1)       { z := 2**f          }
        F2XM1
        FLD1
        FADD
        FSCALE              { result := z * 2**i }
        FSTP    ST(1)
end;

[Chegga]

Zitat:

Zitat von MagicAndre1981

Zitat:

Nun will ich die Zahl e (2,7182...) nach einem Button.Click in einem Panel anzeigen lassen.

Zitat:

Zitat:

const My_E = 2.7182818284590452353602874713527

Genau so wollte ich es nicht haben. ouch!

warum willst du eine Konstante nicht haben?
Du willst doch einen Taschenrechner programmieren und kein Programm,
dass die 2 Millionste Stelle von PI berechnet. :gruebel:
Nimm doch die Konstante, dass ist am schnellsten.

Ich wollte einfach wissen, wie ich das in Pascal umsetze, da ich nicht
einfach nur eine Konstante nehmen wollte.
(Sonst hätte ich diesen Thread erst gar nicht eröffnen müssen. :wink: )

MfG Marc

P.S.: Danke noch mal für alle Antworten! :dp:

[IngoD7]

Zitat:

Zitat von Oxmyx

Zitat:

Zitat von IngoD7

Und was hat das mit meinem Posting zu tun?
Achte bitte drauf, was gemeint war. Ich hatte deine Aussage mit dem Overflow zitiert und wollte darlegen, dass es dazu nicht kommen kann.

Das Problem ist trotzdem die begrenzte Genauigkeit von Standarddatentypen. [...] Und dann ist (1+1/n)^n für "n = sehr sehr hoch" eben 1, und nicht e.

Dem stimme ich zu. Aber auch das hat nichts mit Overflow zu tun. Ein Overflow der Ergebnisvariable tritt schlicht nicht auf. Mehr wollte ich nicht ausgedrückt haben.

[Quake]

@Chegga : Warum möchtest du keine Konstante verwenden? :gruebel:

[schöni]

Hallo!

(e hoch X) = 1 + X/1! + (X hoch 2)/2!+ (X hoch 3)/3! + ... + (X hoch n)/n!

Die Zahl e wäre (e hoch 1)

also setzt Du für X die Zahl 1 ein und berechnest n Glieder der obigen Reihe je nach geforderter Genauigkeit.

schöni

[Binärbaum]

Zitat:

Zitat von schöni

(e hoch X) = 1 + X/1! + (X hoch 2)/2!+ (X hoch 3)/3! + ... + (X hoch n)/n!

Die Zahl e wäre (e hoch 1)

also setzt Du für X die Zahl 1 ein und berechnest n Glieder der obigen Reihe je nach geforderter Genauigkeit.

schöni

Das ist doch genau das, was die 2. Variante der Funktion GetEuler, die ich schon weiter vorn in diesem Thread gepostet habe, macht.

MfG
Binärbaum