Eulersche Zahl mithilfe von Schleife

Soso, ITET

Die Funktion würde ich nicht fakultaet() nennen, da sie auch e berechnet und ausgibt. Und eine for-Schleife wäre hier praktisch. Ausserdem verwendest du den Parameter n gar nie.

PS: Ignorier Sone am besten, der hat nur eine grosse Klappe. Mods, könnt ihr solche Beiträge von Zeit zu Zeit löschen? Als Anfänger ist das obermühsam, wenn ständig so ein Klugscheisser Verwirrung stiftet (Wem soll man so glauben?). Weder numeric_limits noch pow hat irgendwas mit dem Thema zu tun, und erst recht nicht deren Kombination.

SeppJ

Der Wisser schrieb:

Mods, könnt ihr solche Beiträge von Zeit zu Zeit löschen?

Da haste Recht. Wenn ich ihn korrigiere, kann ich ihn auch gleich löschen.

Sone

SeppJ schrieb:

Der Wisser schrieb:

Mods, könnt ihr solche Beiträge von Zeit zu Zeit löschen?

Da haste Recht. Wenn ich ihn korrigiere, kann ich ihn auch gleich löschen.

Ich wollte eben nur anmerken, dass es einfachere Methoden wie die Zinseszinsrechnung gibt, dass der TE also diese Version mit Schleife gar nicht benutzen muss um die eulersche Zahl zu berechnen.

(Wer weiß, vielleicht sagt sein Prof ihm das)

Klar, war dumm dass ich da gleich mit sowas kam, war eben für out.

SeppJ

Dumm war: Wie berechnest du reelle Potenzen ohne e zu kennen?

Das ist als würdest du dich über einen Pi-Algorithmus lustig machen, dass man doch viel einfacher 4*acos(1) berechnen könnte.

Du solltest auch mal überprüfen, ob du bei 15! mit einem int noch hinkommst.

Sone

SeppJ schrieb:

Dumm war: Wie berechnest du reelle Potenzen ohne e zu kennen?

Was meinste mit "reele Potenz"? Potenz mit reelem Exponenten?

unsigned precision = 10000; //bpsw. 10000
    long double res = 1,
                factor = 1 + 1 / static_cast<long double>(precision);
    while(--precision)
        res *= factor;

Da ist dann aber wieder die Schleife

btw, zu PI: Na gut, so bräge ist aber echt keiner.

SeppJ

Sone schrieb:

SeppJ schrieb:

Dumm war: Wie berechnest du reelle Potenzen ohne e zu kennen?

Was meinste mit "reele Potenz"? Potenz mit reelem Exponenten?

Genau.

Da ist dann aber wieder die Schleife

Wenigstens erkennst du es

Sone

Zum Glück gibt es in <cmath> eine Überladung von pow ohne reelle Potenz.
Und genau diese würde in meinem Beispiel benutzt, also war an meiner Überlegung gar nichts dumm.

#include <iostream> //Input, output
#include <iomanip> //Setting higher floating point precision (i.e more decimal points)

int main()
{
//Accuracy of the calculation
int acc = 30;
//Variable for e
double eu = 0;
//Last result
int last_res = 1;

//Loop: 1/i!, simulated by multiplying the last result for less runtime cost
for (int i = 1; i < acc; ++i)
{
eu += 1.0 / last_res;
last_res *= i;
}

//Output, 15 digits precision
std::cout << std::setprecision(15) << eu << '\n';
}

Meine Version.

Kellerautomat

#include <iostream>
#include <type_traits>

template <unsigned N>
struct unsigned_
        : std::integral_constant<unsigned, N>
{};

template <unsigned N>
struct fac
        : unsigned_<fac<N - 1>::value * N>
{};

template <>
struct fac<0>
        : unsigned_<1>
{};

template <unsigned N>
struct e
{
        static double const value = 1. / fac<N>::value + e<N - 1>::value;
};

template <>
struct e<0>
{
        static double const value = 1.;
};

int main()
{
        std::cout.precision(15);
        std::cout << e<20>::value;
}

http://ideone.com/nGO8Q

camper

template <unsigned N>
struct e
{
        static constexpr double value = 1. / fac<N>::value + e<N - 1>::value;
};

template <>
struct e<0>
{
        static constexpr double value = 1.;
};

Wenn es legal sein soll.

Kellerautomat

'legal'? Seit wann sind denn double-Konstanten nicht erlaubt?

Kann jemand mal den Sone sperren, soviel Inkompetenz trifft man selten in einem Thread. Aber irgendeinen Trottel mit großer Klappe gibt es meist in einem Fachforum. Ich hoffe der macht nie eine Ausbildung zum Fachinformatiker, aber dafür reicht glaube ich sein Horizont nicht ganz aus.

camper

Kellerautomat schrieb:

'legal'? Seit wann sind denn double-Konstanten nicht erlaubt?

Selbstverständlich sind double-Konstanten erlaubt.

Die Initialisierung von nicht-volatile const static-Membern in der Klassendefinition ist aber nur zulässig, wenn es sich um einen integralen oder Aufzählungstypen handelt (wie in C++03), es sei denn, die Variable wird mit constexpr deklariert.

n3337 9.4.2/3 schrieb:

If a non-volatile const static data member is of integral or enumeration type, its declaration in the class
definition can specify a brace-or-equal-initializer in which every initializer-clause that is an assignment-
expression is a constant expression (5.19). A static data member of literal type can be declared in the
class definition with the constexpr specifier; if so, its declaration shall specify a brace-or-equal-initializer
in which every initializer-clause that is an assignment-expression is a constant expression. [ Note: In both
these cases, the member may appear in constant expressions. — end note ] The member shall still be defined
in a namespace scope if it is odr-used (3.2) in the program and the namespace scope definition shall not
contain an initializer.

Das Text ist an dieser Stelle erst relativ spät geändert worden, was erklärt, weshalb Compiler gegenwärtig Initialisierung bei einfachem const oft erlauben.