Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Schleife oder Ausgabe Problem

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
22.04.2006, 15:36 Uhr
Frido



Kann mir jemand sagen warum mir Tabelle[][] bei der Ausgabe (ganz unten) nur Müll ausgibt obwohl was drin ist. Und warum ich die Ausgabe nicht ganz ans ende machen kann den dort wird es nicht mal mehr angesprochen.


Code:
/**Bibliotheken*******************************************/
# include <stdio.h>
# include <math.h>                    // Für Betrags Berechnung
# include <string.h>

/**Definitionen für alle Funktinen***********************/
typedef struct {
    double Betrag;
    double X_Wert;
    double Y_Wert;
    int Divergenz;
}   Daten_t;

# define SCHRITTE_1 0.5
# define SCHRITTE_2 0.05

# define X_START -1.6
# define X_ENDE   0.4
# define Y_START -1.0
# define Y_ENDE   1.0

# define MAX_ITERATION 100
# define MAX_BETRAG 2

# define MAX_X_AUSGABE 40            // 40 Punkte weil intervall [-1.6 bis 0.4] ist 2 Geteilt durch 0.05    ist 40
# define MAX_Y_AUSGABE 40            // 40 Punkte weil intervall [-1.0 bis 1.0] ist 2 Geteilt durch 0.05    ist 40

/**Funktion "main***************************************/
int main(int argc, char *argv[]){
    
    int Tabelle[MAX_X_AUSGABE][MAX_Y_AUSGABE];
    int i,u = 0,q = 0,w = 0;
    double e,o,Schritt;
    double X_alt = 0,Y_alt = 0,X_s,Y_s;

    Daten_t Werte;
    Werte.Betrag = 0;
    Werte.Divergenz = 0;

    for(i = 0; i<=2; i++){                        // Schleife für die zwei Programme("Ausgaben")

        printf("\n\n");

        if(i == 0)                                // Auswahl der Schrittweite
           Schritt = SCHRITTE_1;                // Schrittweite 0.5    
        else
            Schritt = SCHRITTE_2;                // Schrttweite 0.05
            
        for(e = X_START; e <= X_ENDE; e += Schritt){        // Schleife für alle X_Werte. Läuft von -1.6 bis 0.4


            for(o = Y_START; o <= Y_ENDE; o += Schritt){    // Schleife für alle Y_Werte. Läuft von -1.0 bis 1.0

                X_s = e;
                Y_s = o;

                    do{                
                        Werte.X_Wert = pow(X_alt,2) - pow(Y_alt,2) + X_s;// Neuen x_Wert berechnen
                        Werte.Y_Wert = 2 * X_alt * Y_alt + Y_s;             // Neuen y_Wert berechnen
                        Werte.Betrag = sqrt(pow(Werte.X_Wert,2) + pow(Werte.Y_Wert,2)); // Betrag erechnen

                        if(Werte.Betrag >= MAX_BETRAG )        // Betrag darf nicht größer sein als 2
                           u++;
                        
                        X_alt = Werte.X_Wert;            
                        Y_alt = Werte.Y_Wert;
                        Werte.Divergenz++;
                        
                    }while((u == 0) && (Werte.Divergenz < MAX_ITERATION));
                    
                        if(Werte.Betrag >= MAX_BETRAG){            // Ausgabe
                            if(i == 0)
                                printf("(%lf, %lf): Die Folge ist Divergent ab Iteration %i!\n",X_s,Y_s,Werte.Divergenz);
                            else
                                Tabelle[q][w] = 1;
                        }
                        else{
                            if(i == 0)
                                printf("(%lf, %lf): Die Folge ist Konvergent\n",X_s,Y_s);
                            else
                                Tabelle[q][w] = 0;
                        }
                    Werte.Divergenz = 0;
                    u = 0;
                    X_alt = 0;
                    Y_alt = 0;
                    w++;
            }
            q++;
        }
    printf("\n");
        printf("%i\n",Tabelle[1][1]);    
        printf("\n");
        
        }

    printf("\n");
    printf("%i\n",Tabelle[1][1]);    
    printf("\n");

}


--
http://spielwelt14.monstersgame.net/?ac=vid&vid=28103555
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
22.04.2006, 16:43 Uhr
Helmut




Zitat von Frido:
Kann mir jemand sagen warum mir Tabelle[][] bei der Ausgabe (ganz unten) nur Müll ausgibt obwohl was drin ist. Und warum ich die Ausgabe nicht ganz ans ende machen kann den dort wird es nicht mal mehr angesprochen.


Code:
/**Bibliotheken*******************************************/
# include <stdio.h>
# include <math.h>                    // Für Betrags Berechnung
# include <string.h>

/**Definitionen für alle Funktinen***********************/
typedef struct {
    double Betrag;
    double X_Wert;
    double Y_Wert;
    int Divergenz;
}   Daten_t;

# define SCHRITTE_1 0.5
# define SCHRITTE_2 0.05

# define X_START -1.6
# define X_ENDE   0.4
# define Y_START -1.0
# define Y_ENDE   1.0

# define MAX_ITERATION 100
# define MAX_BETRAG 2

# define MAX_X_AUSGABE 40            // 40 Punkte weil intervall [-1.6 bis 0.4] ist 2 Geteilt durch 0.05    ist 40
# define MAX_Y_AUSGABE 40            // 40 Punkte weil intervall [-1.0 bis 1.0] ist 2 Geteilt durch 0.05    ist 40

/**Funktion "main***************************************/
int main(int argc, char *argv[]){
    
    int Tabelle[MAX_X_AUSGABE][MAX_Y_AUSGABE];
    int i,u = 0,q = 0,w = 0;
    double e,o,Schritt;
    double X_alt = 0,Y_alt = 0,X_s,Y_s;

    Daten_t Werte;
    Werte.Betrag = 0;
    Werte.Divergenz = 0;

    for(i = 0; i<=2; i++){                        // Schleife für die zwei Programme("Ausgaben")

        printf("\n\n");

        if(i == 0)                                // Auswahl der Schrittweite
           Schritt = SCHRITTE_1;                // Schrittweite 0.5    
        else
            Schritt = SCHRITTE_2;                // Schrttweite 0.05
            
        for(e = X_START; e <= X_ENDE; e += Schritt){        // Schleife für alle X_Werte. Läuft von -1.6 bis 0.4


            for(o = Y_START; o <= Y_ENDE; o += Schritt){    // Schleife für alle Y_Werte. Läuft von -1.0 bis 1.0

                X_s = e;
                Y_s = o;

                    do{                
                        Werte.X_Wert = pow(X_alt,2) - pow(Y_alt,2) + X_s;// Neuen x_Wert berechnen
                        Werte.Y_Wert = 2 * X_alt * Y_alt + Y_s;             // Neuen y_Wert berechnen
                        Werte.Betrag = sqrt(pow(Werte.X_Wert,2) + pow(Werte.Y_Wert,2)); // Betrag erechnen

                        if(Werte.Betrag >= MAX_BETRAG )        // Betrag darf nicht größer sein als 2
                           u++;
                        
                        X_alt = Werte.X_Wert;            
                        Y_alt = Werte.Y_Wert;
                        Werte.Divergenz++;
                        
                    }while((u == 0) && (Werte.Divergenz < MAX_ITERATION));
                    
                        if(Werte.Betrag >= MAX_BETRAG){            // Ausgabe
                            if(i == 0)
                                printf("(%lf, %lf): Die Folge ist Divergent ab Iteration %i!\n",X_s,Y_s,Werte.Divergenz);
                            else
                                Tabelle[q][w] = 1;
                        }
                        else{
                            if(i == 0)
                                printf("(%lf, %lf): Die Folge ist Konvergent\n",X_s,Y_s);
                            else
                                Tabelle[q][w] = 0;
                        }
                    Werte.Divergenz = 0;
                    u = 0;
                    X_alt = 0;
                    Y_alt = 0;
                    w++;
            }
            q++;
        }
    printf("\n");
        printf("%i\n",Tabelle[1][1]);    
        printf("\n");
        
        }

    printf("\n");
    printf("%i\n",Tabelle[1][1]);    
    printf("\n");

}


 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
22.04.2006, 16:58 Uhr
Helmut




Zitat von Helmut:



Es wird nichts in deine Tabelle[1][1] geschrieben.

Schreib mal oben

static int Tabelle[MAX_X_AUSGABE][MAX_Y_AUSGABE];

setze also alle Tabellenelemente auf 0;

Die Tabelle ist am Programmende immer noch leer.


 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
22.04.2006, 16:59 Uhr
Tommix



Hallo,
wenn Du mal q, w ausgeben läßt:

C++:
                      
    }while((u == 0) && (Werte.Divergenz < MAX_ITERATION));
                    
        printf ("%d, %d\n", q, w);

        if(Werte.Betrag >= MAX_BETRAG){            // Ausgabe
            if(i == 0)
                printf("(%lf, %lf): Die Folge ist Divergent ab Iteration %i!\n",X_s,Y_s,Werte.Divergenz);


siehst Du daß w weit über die Feldgrenzen läuft.

Gruß, Tommix
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
24.04.2006, 18:42 Uhr
Frido



Moin.
Ich habe (mit `Hilfe` ) die meisten Probleme beseitigt habe aber noch eins und zwar will ich die Iterationen im x Intervall von -1.6 bis 0.4 und y intervall -1.0 bis 1.0 durchführen.
Das klappt nun wenn ich die Schritte für x und y 0.5 wähle beim zweiten durchlauf soll aber die Schritte für x 0.05 und für y 0.1 sein.
Warum Läuft nun beim ersten durchlauf die x Schleife bis 0.4 aber beim 2ten Durchlauf nur bis 0.35. erst wenn ich das x Intervall auf -1.6 bis 0.45 verändere passt es.
Komisch ist nur das beim ersten Durchlauf das intervall bei 0.4 beendet wird.

Kann mir jemand sagen wo da der Wurm drin ist .


Code:
/**Bibliotheken*******************************************/
# include <stdio.h>
# include <math.h>                    // Für Betrags Berechnung
# include <string.h>

/**Definitionen für alle Funktinen***********************/

typedef struct {
    double Betrag;
    double X_Wert;
    double Y_Wert;
    int Divergenz;
}   Daten_t;

# define SCHRITTE_1    0.5
# define SCHRITTE_2_1  0.05
# define SCHRITTE_2_2  0.1

# define X_START -1.6
# define X_ENDE   0.4                // 0.45
# define Y_START -1.0
# define Y_ENDE   1.0

# define MAX_ITERATION 100
# define MAX_BETRAG 2

# define MAX_X_AUSGABE 41            // 40 Punkte weil intervall [-1.6 bis 0.4] ist 2 Geteilt durch 0.05    ist 40
# define MAX_Y_AUSGABE 21            // 40 Punkte weil intervall [-1.0 bis 1.0] ist 2 Geteilt durch 0.05    ist 40

# define s 0

/**Funktion "main***************************************/

int main(int argc, char *argv[]){
    
    int Tabelle[MAX_X_AUSGABE][MAX_Y_AUSGABE];
    int i, u = 0, q = 0, w = 0, t = 0;
    double e,o,Schritt_x,Schritt_y;
    double X_alt = 0, Y_alt = 0, X_s, Y_s;

    Daten_t Werte;
    Werte.Betrag = 0;
    Werte.Divergenz = 0;

    for(i = s; i <= 1; i++){                        // Schleife für die zwei Programme("Ausgaben")

        printf("\n\n");
        q = 0;
        w = 0;

        if(i == 0){                                // Auswahl der Schrittweite
           Schritt_x = SCHRITTE_1;                // Schrittweite 0.5
           Schritt_y = SCHRITTE_1;
        }
        else{
            Schritt_x = SCHRITTE_2_1;                // Schrttweite 0.05
            Schritt_y = SCHRITTE_2_2;
        }
            
        for(e = X_START; e <= X_ENDE; e += Schritt_x){        // Schleife für alle X_Werte. Läuft von -1.6 bis 0.4

            w = 0;

            for(o = Y_START; o <= Y_ENDE; o += Schritt_y){    // Schleife für alle Y_Werte. Läuft von -1.0 bis 1.0

                X_s = e;
                Y_s = o;

                    do{                
                        Werte.X_Wert = pow(X_alt,2) - pow(Y_alt,2) + X_s;// Neuen x_Wert berechnen
                        Werte.Y_Wert = 2 * X_alt * Y_alt + Y_s;             // Neuen y_Wert berechnen
                        Werte.Betrag = sqrt(pow(Werte.X_Wert,2) + pow(Werte.Y_Wert,2)); // Betrag erechnen

                        if(Werte.Betrag >= MAX_BETRAG )        // Betrag darf nicht größer sein als 2
                           u++;
                        
                        X_alt = Werte.X_Wert;            
                        Y_alt = Werte.Y_Wert;
                        Werte.Divergenz++;
                        
                    }while((u == 0) && (Werte.Divergenz <= MAX_ITERATION));
                    
                        if(Werte.Betrag >= MAX_BETRAG){            // Ausgabe
                            if(i == s)
                                printf("(%lf, %lf): Die Folge ist Divergent ab Iteration %i!\n",X_s,Y_s,Werte.Divergenz);
                            else
                                Tabelle[q][w] = 1;
                        }
                        else{
                            if(i == s)
                                printf("(%lf, %lf): Die Folge ist Konvergent\n",X_s,Y_s);
                            else
                                Tabelle[q][w] = 0;
                        }
                    Werte.Divergenz = 0;
                    u = 0;
                    X_alt = 0;
                    Y_alt = 0;
                    w++;
            }
            q++;
            //system("Pause");
        }
    }
/***********************************************/
    for(i = 0; i <= 40; i++){
        for(u = 0; u <= 20; u++){
            printf(" %i",Tabelle[i][u]);
            if(u == 20){
                printf("\n");
                t++;
            }
        }
    }
    printf("\n\n\t%i\n\n",t);
/***********************************************/
}


--
http://spielwelt14.monstersgame.net/?ac=vid&vid=28103555
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
24.04.2006, 18:43 Uhr
Frido



Wenn man das #define s auf 1 setzt kann man sehen das das programm bei 0.25 abbricht.
--
http://spielwelt14.monstersgame.net/?ac=vid&vid=28103555
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
25.04.2006, 17:08 Uhr
Tommix



Hallo,
0.1 ist in der binären Gleitkommadarstellung fieserweise ein periodischer Bruch. Der wird, wegen der endlichen Ziffern- bzw Bitzahl abgeschnitten. Das ist wie mit 1/3 im Dezimalsystem:
1/3+1/3+1/3 = 1, dagegen
0.333+0.333+0.333 < 1.
Mit solchen Rundungsproblemen hat man bei Gleitkommazahlen immer zu kämpfen.

Gruß, Tommix
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: