Maschinengenauigkeit und Summe



  • 1)Die Maschinengenauigkeit ε als die kleinste positive Gleitkommazahl ε ermitteln, so dass rd(1 + ε) > 1. Verwenden Sie dieses Verfahren um je ein C/C++ Programm zu schreiben, dass die Maschinengenauigkeit epsilon des float-, double- bzw. long double-Gleitkommasystems ermittelt.

    2)Schreiben Sie ein C/C++ Programm welches für gegebenes n ∈ N den Wert der
    Summe
    s[n] = [n]Sigma[/k=1] 1/k^2

    ausgibt. Überlegen Sie sich wie groß n gewählt werden muss damit alle Summanden für k > n kleiner als 10^(-6) sind.

    kann mir vielleicht jemand Ansätze geben wie ich das machen kann oder kann jemand zusammen mit mir die aufgaben machen. bin total überfordert :/// 😞



  • Die Ansätze wurden im Unterricht sicher genannt. Schau in deinen Unterlagen nach.



  • jaa schon aber damit komme ich nicht weiter ;//



  • Marcell99 schrieb:

    jaa schon aber damit komme ich nicht weiter ;//

    Warum? Etwas mehr Eigeninitiative wirst du schon zeigen müssen.

    Ok, ein Hinweis zu 1: der Compiler weiß das, du musst ihn nur nett fragen.



  • ich zeig dir mal was ich hab

    #include <iostream>
    using namespace std;

    int main(int argc, const char * argv[]) {
    float a;
    double eps;
    while (1.0 + eps> 1.0) {
    eps *=0.5;
    }

    cout<<"ergebnis"<<eps<<endl;

    long double b;
    a=1;
    b=2;
    eps=3;

    }



  • Du musst eps initialisieren. Ansonsten sieht das nicht so schlecht aus. Allerdings ist nach der Schleife dein eps nicht ganz richtig. Denk nochmal über die Definition von eps nach.

    Ich würde den Code auch gleich verallgemeinern, damit du nicht nur eps(1) ermitteln kannst, sondern auch eps einer beliebigen Zahl.

    PS: [code="cpp"]-Tags verwenden 🙂



  • float a;
    double eps =0.5;
    while (true) {
    if (1.0 + eps> 1.0) {
    break;
    }
    eps *=0.5;
    }

    cout<<"ergebnis "<<eps<<endl;

    long double b;
    a=1;
    b=2;
    eps=3;

    meinst du das mit verallgemeinern??

    was meinst du mit code=cpp??



  • Mit verallgemeinern meine ich, dass du nicht hart die 1.0 als Kriterium angibst, sondern eine Varibale a. Dann kannst du a auf einen beliebigen Wert setzen (z.B. 4) und somit eps(4) ausrechnen. Und dann baust du noch eine Funktion daraus und rufst die Funktion in main() auf. Dann wird es langsam sauber 🙂

    Marcell99 schrieb:

    was meinst du mit code=cpp??

    Unter den Smilies findest du alle möglichen Tags, unter anderem "C++". Wenn man die benutzt wird Code überhaupt erst lesbar (und es wird den Leuten helfen dir zu helfen). Beispiel:

    int foo (float x) {
        return (int)x;
    }
    


  • int main(int argc, const char * argv[]) {

    float a=4.0;
    while (true) {
    if (1.0+a>1.0) {
    break;
    }
    a *=4;
    }

    cout<<"ergebnis"<<a<<endl;

    double eps =0.5;
    while (true) {
    if (1.0 + eps> 1.0) {
    break;
    }
    eps *=0.5;
    }

    cout<<"ergebnis "<<eps<<endl;

    long double b=7.844;
    while (true) {
    if (1.0+b>1.0) {
    break;
    }
    }
    cout<<"ergebnis"<<b<<endl;

    oder ist das besser ?? oder hab ich das jetzt total falsch gemacht



  • AHSO OK ICH VERSUCHS MAL



  • using namespace std;

    int main(int argc, const char * argv[]) {

    double eps=0.5;
    double e;

    while ((1+eps)>1)
    {
    e = eps;
    eps /=2;
    }

    printf("%g\n", eps);



  • Hallo, ein kleiner Tipp:
    Wenn du es in C lösen willst nimm float.h, ansonsten in C++ cfloat.

    Edit: ansonsten in C++ std::numeric_limits<float>::epsilon() aus <limits>.

    Dann schau mal hier (etwas runterscrollen):

    http://www2.informatik.uni-halle.de/lehre/c/c623.html

    ...damit hättest Du dann den ersten Teil...

    Schönes WE noch...

    PS: Google-Suche war übrigens: C C++ kleinste Zahl größer 0 ... oder so...



  • int main(int argc, const char * argv[]) {

    float Zahla=1.0F;
    float Zahlb;
    while ((1+Zahla) >1) {
    Zahlb=Zahla;
    Zahlb =1.0;
    }

    printf("%f\n",Zahla);

    double epsilon = 0.01;
    double epsilonValid;
    while ((1 + epsilon) > 1)
    {
    epsilonValid = epsilon;
    epsilon /= 2;
    }
    printf("%g\n", epsilon);

    long double c=0.0234L;
    long double d;
    while ((1+c)>1) {
    d=c;
    c/=2;
    }

    printf("%Lf\n",c);

    return 0;
    }

    so richtig jetzt ??



  • Die letzte Schleife sieht doch gut aus (wenn du danach d statt c ausgegeben hättest...),
    hab aber keine Lust mir das genauer anzugucken weil du keine Code-Tags benutzt (Einfach Text markieren und unten auf C++ klicken...

    Hier zum Vergleichen (nur float) und zum ärgern wie es einfacher ging:

    // Hier *drei* Beispiele für float. Du sollst aber jeweils
    // eins für float, double und long double schreiben
    
    #include <iostream>
    #include <iomanip>
    #include <limits>
    #include <cfloat>       // in C <float.h>
    
    // C++11 nötig wg. ::max_digits10
    // g++ -ansi -std=c++11 -Wpedantic -Wall kleinste_zahl_gr_null.cpp -o kleinste_zahl_gr_null
    
    int main() {
            // Ausgabe auf fixed und mehr stellen...
            std::cout << std::fixed
                    << std::setprecision(std::numeric_limits<float>::max_digits10);
    
            // Version 1: Altes C-Zeugs aus <cfloat>. Wenn C statt C++ <float.h> einbinden:
            std::cout << FLT_EPSILON
                    << "\tEpsilon (FLT_EPSILON aus cfloat / float.h)\n";
    
            // Version 2: Die saubere (?hoffe ich?) C++-Version
            std::cout << std::numeric_limits<float>::epsilon() 
                    << "\tEpsilon (std::numeric_limits<float>::epsilon aus limits)\n";
    
            // Version 3 von Hand...
            float a=.5f, b; // a=.1f reicht auch...
    
            while ( 1.0f + a > 1.0f) {
                    b = a;
                    a /= 2;
            }
    
            std::cout << b << "\tEpsilon (selfmade)\n";
    
            return 0; // besser exit(0);
    }
    

    Ausgabe bei mir:

    0.000000119     Epsilon (FLT_EPSILON aus cfloat / float.h)
    0.000000119     Epsilon (std::numeric_limits<float>::epsilon aus limits)
    0.000000119     Epsilon (selfmade)
    

    Rest für dich... Schönes WE nochmal...


Log in to reply