4. Definitiosreihenfolge von Arrays in Dev-Cpp

Definitiosreihenfolge von Arrays in Dev-Cpp

  • N

    Hollo, vielleicht kan mir ja jemand weiterhelfen.

    Compiler Cev-Cpp 4.9.9.2

    Ich arbeite momentan an einem Programm in dem Matrizenoperationen durchgefürt werden. Jedoch treten dabei Fehler auf.

    Einige Zellen werden überschreiben, obwohl kein Zugriff im laufe des Programms auf sie gemacht wird. Die betroffenen Zellen sind außerdem abhänging von der Definitionsreihenfolge der Arrays.

    Danke an die die sich die mühe machen und nen Blick riskieren.

    Ich hänge den Code mal an:

    [cpp]

    int EFunktion(int Start, int Stop,float *Spannung,float *ESpannung,float *Alpha,float *Beta,float *Tau)
    {
    float K[2];

    int n;

    int Wiederholung;

    float Det;

    float F[2000];

    float Y[2000]; //Spannung

    float Delta[2000];

    float HTHI[2][2];
    // Die Reihenfolge der Definitonen hat einfluß auf die Stelle an der der Fehler auftritt.

    float H[2][2000];

    float HTHIT[2000][2];

    float HTH[2][2];

    float HT[2000][2];

    {
    /***************** Vorinitialisierung *****************************/

    Start=400;
    *Alpha=5.0f;
    *Beta=5.0f;
    *Tau=600.0f;
    n=Stop-Start;
    Wiederholung=0;

    for(int i=0; i<2000; i++)
    {
    Y[i]=0.0f;
    F[i]=0.0f;
    Delta[i]=0.0f;

    for(int j=0; j<3; j++)
    {
    H[j][i]=0.0f;
    HT[i][j]=0.0f;
    HTHIT[i][j]=0.0f;
    }
    }

    /***************** Laden von Y*************************************/

    for(int i=Start; i<Stop; i++)
    {
    Y[i]=Spannung[i];

    }

    /***************** Erstellung von F *******************************/

    do
    {
    for(int i=0; i<Stop; i++)
    {
    F[i]= *Alpha + *Beta * exp((-1.0f * i)/ *Tau);
    }

    /***************** Berechnung von Delta ***************************/

    for(int i=Start; i<Stop; i++)
    {
    Delta[i]=Y[i]-F[i];
    }

    /***************** Berechnung von H *******************************/

    for(int i=Start; i<Stop; i++)
    {
    H[0][i]=1;
    H[1][i]=exp((-1.0*(i))/ *Tau);
    H[2][i]=((i * *Beta * exp((-i)/ *Tau))/(*Tau * *Tau));
    }

    /***************** Berechnung von K *******************************/

    /******************Multiplikation****************/
    puts("HTH");
    for (int i=0; i<3;i++)
    {

    for (int j=0; j<3;j++)
    {
    HTH[i][j]=0.0f;
    for(int k=Start; k<Stop;k++)
    {
    HTH[i][j]+=H[i][k]*H[j][k]; //Kein Fehler

    }
    printf("%f\t",HTH[i][j]);
    }
    printf("\n");
    }
    getchar();

    /******************Inversion*********************/

    Det= 0 ;
    Det+= HTH[0][0] * HTH[1][1] * HTH[2][2] ;
    Det+= HTH[0][1] * HTH[1][2] * HTH[2][0] ;
    Det+= HTH[0][2] * HTH[1][0] * HTH[2][1] ;
    Det-= HTH[0][2] * HTH[1][1] * HTH[2][0] ;
    Det-= HTH[0][0] * HTH[1][2] * HTH[2][1] ;
    Det-= HTH[0][1] * HTH[1][0] * HTH[2][2] ;

    printf("\n Det: %f\n",Det);

    HTHI[0][0]= (( HTH[1][1] * HTH[2][2] )-(HTH[1][2] * HTH[2][1] ));
    HTHI[0][1]=-(( HTH[0][1] * HTH[2][2] )-(HTH[0][2] * HTH[2][1] ));
    HTHI[0][2]= (( HTH[0][1] * HTH[1][2] )-(HTH[0][2] * HTH[1][1] ));

    HTHI[1][0]=-(( HTH[0][1] * HTH[2][2] )-(HTH[2][1] * HTH[2][0] ));
    HTHI[1][1]= (( HTH[0][0] * HTH[2][2] )-(HTH[0][2] * HTH[2][0] ));
    HTHI[1][2]=-(( HTH[0][0] * HTH[1][2] )-(HTH[0][2] * HTH[1][0] ));

    HTHI[2][0]= (( HTH[0][1] * HTH[2][1] )-(HTH[1][1] * HTH[2][0] ));
    HTHI[2][1]=-(( HTH[0][0] * HTH[2][1] )-(HTH[0][1] * HTH[2][0] ));
    HTHI[2][2]= (( HTH[0][0] * HTH[1][1] )-(HTH[0][1] * HTH[1][0] ));

    puts("HTH");
    for(int i=0;i<3;i++)
    {
    for(int j=0;j<3;j++)
    {
    HTHI[i][j]*=1.0f/Det;
    printf("%f\t",HTH[i][j]); //Fehler

    }
    printf("\n");
    }
    getchar();

    /******************Inverse * Transformierte****/

    for (int i=0; i<3;i++)
    {
    for (int j=0; j<3;j++)
    {
    for(int k=0; k<3;k++)
    {
    HTHIT[i][j]+=HTHI[i][k]*HT[k][j];
    }
    }
    }

    /****************** * Delta*************************/

    for (int i=0; i<3;i++)
    {
    for (int j=0; j<1;j++)
    {
    for(int k=Start; k<Stop;k++)
    {
    K[i]+=HTHIT[k][i] * Delta[k];
    }
    }
    }

    /***************** Einsetzen von K in Alpha,Beta,Tau **************/

    *Alpha=K[0];
    *Beta=K[1];
    *Tau=K[2];

    /***************** Abbruchbedingung erfüllt? **********************/
    Wiederholung++;
    }
    while(Wiederholung<20);

    /********************Füllen der ESpannung*********************************/

    for(int i=0; i<2000; i++)
    {
    ESpannung[i]= *Alpha + *Beta * exp( -i / *Tau);
    }

    }
    return 0;
    }

    0
  • M

    HTH und HTHI haben nur zwei mal zwei Elemente. Die erlaubten Indizes sind damit 0 und 1. Du benutzt 2 als Index. Das gilt auch für die anderen Arrays.

    0
  • N

    Danke danke danke 🙂

    Bin ich ein Horst

    0
Anmelden zum Antworten