Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?

Eliminacja Gaussa z wyborem elementu głównego

Ostatnio zmodyfikowano 2016-03-12 20:23
Autor Wiadomość
Mamrot
Temat założony przez niniejszego użytkownika
Eliminacja Gaussa z wyborem elementu głównego
» 2016-03-12 08:07:07
Napisałem swego czasu funkcję realizującą algorytm eliminacji Gaussa, z którą nie ma problemów:

C/C++
void GAUSS( int ILE, long double ** A, long double X[], long double Y[] )
{
    long double m;
    for( int i = 0; i < ILE; i++ )
    {
        for( int j = i + 1; j < ILE; j++ )
        {
            m = A[ j ][ i ] / A[ i ][ i ];
            Y[ j ] = Y[ j ] - m * Y[ i ];
            for( int k = 0; k < ILE; k++ )
            {
                A[ j ][ k ] = A[ j ][ k ] - m * A[ i ][ k ];
            }
        }
       
    }
    ////////////////WYDRUK KONTROLNY WSPÓŁCZYNNIKÓW/////////////////////////////////////////////////
    /*cout<<endl;
        for(int i=0;i<ILE;i++)
        {
            for(int j=0;j<ILE;j++)
            {
                cout<<"A["<<i<<"]["<<j<<"]= "<<A[i][j]<<"\t";
            }
            cout<<endl;
        }
        for(int i=0;i<ILE;i++)
        {
            cout<<"Y["<<i<<"]="<<Y[i]<<endl;
        }*/
    ////////////KONIEC WYDRUKU KONTROLNEGO WSÞÓŁCZYNNIKÓW///////////////////////////////////////////////////////////////
    X[ ILE - 1 ] = Y[ ILE - 1 ] / A[ ILE - 1 ][ ILE - 1 ];
    for( int i = ILE - 2; i >= 0; i-- )
    {
        X[ i ] = Y[ i ];
        for( int j = ILE - 1; j > i; j-- )
        {
            X[ i ] = X[ i ] - A[ i ][ j ] * X[ j ];
        }
        X[ i ] = X[ i ] / A[ i ][ i ];
    }
    ////////////////WYDRUK KONTROLNY NIEWIADOMYCH/////////////////////////////////////////////////
    /*cout<<endl<<"*********************************\n";
        for(int i=0;i<ILE;i++)
        {
            cout<<"X["<<i<<"]="<<X[i]<<endl;
        }*/
    ////////////KONIEC WYDRUKU KONTROLNEGO NIEWIADOMYCH///////////////////////////////////////////////////////////////
}

Zamarzyła mi się jednak wersja z wyborem elementu głównego
C/C++
void WYBGAUSS( int ILE, long double ** A, long double X[], long double Y[] )
{
    long double B;
    long double m;
    int w;
    long double AA[ ILE ];
    long double Yi;
    for( int i = 0; i < ILE; i++ )
    {
        //dobór elementów głównych
        B = A[ i ][ i ];
        ///znalezienie największego elementu w kolumnie, poniżej aktualnego wiersza
        for( int j = i; j < ILE; j++ )
        {
            if( fabs( A[ j ][ i ] ) > fabs( B ) )
            {
                w = j;
            }
        }
        if( w == i ) { goto gauss; }
        ///zamiana wiersza oryginalnie i-tego na w-ty
        for( int j = 0; j < ILE; j++ )
        {
            AA[ j ] = A[ i ][ j ];
        }
        for( int j = 0; j < ILE; j++ )
        {
            A[ i ][ j ] = A[ w ][ j ];
        }
        for( int j = 0; j < ILE; j++ )
        {
            A[ w ][ j ] = AA[ j ];
        }
        Yi = Y[ i ];
        Y[ i ] = Y[ w ];
        Y[ w ] = Yi;
        gauss:
        //ciąg dalszy algorytmu metody eliminacji Gaussa
        for( int j = i + 1; j < ILE; j++ )
        {
            m = A[ j ][ i ] / A[ i ][ i ];
            Y[ j ] = Y[ j ] - m * Y[ i ];
            for( int k = 0; k < ILE; k++ )
            {
                A[ j ][ k ] = A[ j ][ k ] - m * A[ i ][ k ];
            }
        }
       
    }
    ////////////////WYDRUK KONTROLNY WSPÓŁCZYNNIKÓW/////////////////////////////////////////////////
    /*cout<<endl;
        for(int i=0;i<ILE;i++)
        {
            for(int j=0;j<ILE;j++)
            {
                cout<<"A["<<i<<"]["<<j<<"]= "<<A[i][j]<<"\t";
            }
            cout<<endl;
        }
        for(int i=0;i<ILE;i++)
        {
            cout<<"Y["<<i<<"]="<<Y[i]<<endl;
        }*/
    ////////////KONIEC WYDRUKU KONTROLNEGO WSÞÓŁCZYNNIKÓW///////////////////////////////////////////////////////////////
    X[ ILE - 1 ] = Y[ ILE - 1 ] / A[ ILE - 1 ][ ILE - 1 ];
    for( int i = ILE - 2; i >= 0; i-- )
    {
        X[ i ] = Y[ i ];
        for( int j = ILE - 1; j > i; j-- )
        {
            X[ i ] = X[ i ] - A[ i ][ j ] * X[ j ];
        }
        X[ i ] = X[ i ] / A[ i ][ i ];
    }
    ////////////////WYDRUK KONTROLNY NIEWIADOMYCH/////////////////////////////////////////////////
    /*cout<<endl<<"*********************************\n";
        for(int i=0;i<ILE;i++)
        {
            cout<<"X["<<i<<"]="<<X[i]<<endl;
        }*/
    ////////////KONIEC WYDRUKU KONTROLNEGO NIEWIADOMYCH///////////////////////////////////////////////////////////////
}
która to "wykrzacza się" (przypisuje "nan" do współczynników A).
P-145913
Mamrot
Temat założony przez niniejszego użytkownika
» 2016-03-12 20:23:49
Pobawiłem się jeszcze z tą funkcją i żeby było śmieszniej to na niedużych zestawach danych działa poprawnie. Kłopoty zaczynają się kiedy mam duże (ok. 1000) układy równań.
P-145940
« 1 »
  Strona 1 z 1