[C++ builder] Metoda ineracji prostej, ieracji Gaussa- Seidla, nadrelaksacji

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 * Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1( TComponent * Owner )
    : TForm( Owner )
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click( TObject * Sender )
{
    int n, iter;
    try {
        n = StrToInt( Edit1->Text );
        iter = StrToInt( Edit2->Text );
    }
    catch( Exception * e )
    {
        Edit1->Text = "";
        Edit2->Text = "";
        return;
    }
    W->ColCount = n;
    W->RowCount = n;
    X0->RowCount = n;
    Z->RowCount = n;
    X->RowCount = n;
    X->ColCount = iter;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click( TObject * Sender )
{
    Application->Terminate();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click( TObject * Sender )
{
    int n, iter, i, j, k;
    double ** Ws, * X0s, * Xs, * Zs, suma;
   
    try {
        n = StrToInt( Edit1->Text );
        iter = StrToInt( Edit2->Text );
    }
    catch( Exception * e )
    {
        Edit1->Text = "";
        Edit2->Text = "";
        return;
    }
   
    Ws = new double *[ n ];
    for( i = 0; i < n; i++ )
         Ws[ i ] = new double[ n ];
   
    X0s = new double[ n ];
    Zs = new double[ n ];
    Xs = new double[ n ];
   
    for( i = 0; i < n; i++ ) {
        for( j = 0; j < n; j++ )
             Ws[ i ][ j ] = StrToFloat( W->Cells[ j ][ i ] );
       
        X0s[ i ] = StrToFloat( X0->Cells[ 0 ][ i ] );
        Zs[ i ] = StrToFloat( Z->Cells[ 0 ][ i ] );
    }
   
   
    for( k = 0; k < iter; k++ ) { //wlasciwa metoda iteracji prostej
        for( i = 0; i < n; i++ )
        {
            suma = 0;
            for( j = 0; j < n; j++ )
                 suma += Ws[ i ][ j ] * X0s[ j ];
           
            Xs[ i ] = suma + Zs[ i ];
        }
        for( i = 0; i < n; i++ ) {
            X0s[ i ] = Xs[ i ];
            X->Cells[ k ][ i ] = FloatToStr( Xs[ i ] );
        }
       
    }
}
//-----------------------------------------------------------

// Metoda Gaussa-Seidela
// www.algorytm.org
// (c) 2006 Tomasz Lubinski

#include "stdio.h"

float A[ 100 ][ 100 ];
float L[ 100 ][ 100 ];
float D[ 100 ][ 100 ];
float U[ 100 ][ 100 ];
float b[ 100 ];
float x[ 100 ];

int n, iter;
int i, j, k;

void main()
{
    // Get n
    printf( "Metoda Gaussa-Seidela\n" );
    printf( "Rozwiazywanie ukladu n-rownan z n-niewiadomymi Ax=b\n" );
    printf( "Podaj n\n" );
    scanf( "%d", & n );
    if(( n < 1 ) &&( n > 100 ) ) {
        printf( "Nieprawidlowa warosc parametru n\n" );
        return;
    }
   
    // Get values of A
    for( i = 0; i < n; i++ )
    for( j = 0; j < n; j++ ) {
        printf( "A[%d][%d] = ",( i + 1 ),( j + 1 ) );
        scanf( "%f", & A[ i ][ j ] );
        if(( i == j ) &&( A[ i ][ j ] == 0 ) ) {
            printf( "Wartosci na przekatnej musza byc rozne od 0\n" );
            return;
        }
    }
   
    // Get values of b
    for( i = 0; i < n; i++ ) {
        printf( "b[%d] = ",( i + 1 ) );
        scanf( "%f", & b[ i ] );
    }
   
    // Divide A into L + D + U
    for( i = 0; i < n; i++ )
    for( j = 0; j < n; j++ ) {
        if( i < j ) {
            U[ i ][ j ] = A[ i ][ j ];
        }
        else if( i > j ) {
            L[ i ][ j ] = A[ i ][ j ];
        }
        else {
            D[ i ][ j ] = A[ i ][ j ];
        }
    }
   
    // Calculate D^-1
    for( i = 0; i < n; i++ )
         D[ i ][ i ] = 1 / D[ i ][ i ];
   
    // Calculate D^-1 * b
    for( i = 0; i < n; i++ )
         b[ i ] *= D[ i ][ i ];
   
    //Calculate D^-1 * L
    for( i = 0; i < n; i++ )
    for( j = 0; j < i; j++ )
         L[ i ][ j ] *= D[ i ][ i ];
   
    //Calculate D^-1 * U
    for( i = 0; i < n; i++ )
    for( j = i + 1; j < n; j++ )
         U[ i ][ j ] *= D[ i ][ i ];
   
    //Initialize x
    for( i = 0; i < n; i++ )
         x[ i ] = 0;
   
    printf( "Ile iteracji algorytmu wykonac?\n" );
    scanf( "%d", & iter );
   
    for( k = 0; k < iter; k++ )
    for( i = 0; i < n; i++ ) {
        x[ i ] = b[ i ]; // x = D^-1*b -
        for( j = 0; j < i; j++ )
             x[ i ] -= L[ i ][ j ] * x[ j ]; // D^-1*L * x -
       
        for( j = i + 1; j < n; j++ )
             x[ i ] -= U[ i ][ j ] * x[ j ]; // D^-1*U * x
       
    }
   
    printf( "Wynik\n" );
    for( i = 0; i < n; i++ )
         printf( "x[%d] = %f\n",( i + 1 ), x[ i ] );
   
    return;
   
}

// MacA - macierz kwadratowa rzędu N=MacA.size()-l
// MacB - macierz wyrazów wolnych o Ni41acX.size()-l    -wierszach i
// M=MacX[l].size()-l    -kolumnach
// MacX - macierz rozwiązania o N=MacX.size()-l-wierszach i
// M=MacX[-l].size()-l-kolumnach
// eps - dokładność bezwzględna iteracji  (np.  EPS-1E-8)
// omega - parametr relaksacji
// metoda iteracji Gaussa-Seidela omega=l oraz
// nadrelaksacji   2<omega>l
// maxit - zadana maksymalna liczba iteracji
// PG - wskaźnik postępu rozwiązania związany z komponentem
// PG=NULL - brak wskaźnika
// return 0 brak błędu,  inna wartość - numer błędu
template < class Typ >
int RozRowMacIGS( vector < vector < Typ > >& MacA,
vector < vector < Typ > >& MacB,
vector < vector < Typ > >& MacX,
double eps = le - 4, double omega = l.int maxit = 2000,
TWskaznikPostepuAbstr * PG = NULL )
{
    iint i.j, l.k, p, N, M.U.W.MaxWsk;
    double R.R1.S.T.Tl.Skala:
    Typ SZ;
    N = MacA.size() - l
        : M - MacA[ N ].size() - l;
    W = MacB.size() - l; U - MacB[ W ].size() - l
        : vector < vector < Typ > > Y;
    ImcjacjaMacierzy( Y, N.U );
    if( PG != NULL )
    { PG->ZapiszMinW( 0 )
            : PG->ZapiszMaxW( N ); PG->ZapiszPozycje( 0 ); }
    try
    {
        if( W == N && M == N )
        { // Przekształcenie macierzy A do postaci z możliwie //maksymalnymi co do modułu elementami na głównej //przekątnej metodą przestawiania wierszy
            for( i - 1; l <- N; i++ )
            { T = absy( MacA[ ij[ i ] ); k = i;
                for( j = i + 1; j <= N; j++ )
                {
                    Tl = absy( MacALJ ][ i ] ); if( T1 > T ) { T - Tl; k - j; };
                } if( i != k )
                { swap( MacB[ kJ.MacB[ i ] ); swap( MacA[ k ], MacA[ i ] );
                } } //i
            SkalRowMacTyp( MacA.MacB ); P = 0;
            for( i - 1; i <- N; 1 ++ )
                 for( j = l; j <= U; j++ ) MacX[ i ][ j ] = MacB[ i ][ jJ; //if (PG!=NULL)  { PG->ZapiszMinW(0);    PG->ZapiszMaxW(rnaxit):  }; do
           
            { R1 = 0; p++;
                for( 1 - 1; i <= N; i++ )
                     for( j - 1; j <- U; j++ ) Y[ i ][ j ] - MacX[ i ][ j ]; for( 1 - 1; 1 <= U; 1 ++ )
                { R = 0.0;
                    for( i - 1; i <= N; i++ ) { SZ = MacB[ i ][ l ]; for( j - 1; j <- i - l; j++ ) SZ--MacA[ i ][ j3 * MacX[ j ][ l ]; for( j - i; j <= N; j++ ) SZ - MacA[ i ][ j ] * Y[ jJ[ l ]
                            : MacX[ i ][ 1K[ i ][ l ] + omega * SZ / MacA[ i ][ i ]; S - absy( SZ ); if( S > R !R = S; } //1 if (R>R1) Rl-R;
                    if( PG.'=NULL)
                    ( if( p — 1 )
                    { Skala = MaxWsk / Rl; PG->ZapiszPozycje( 0 ); }
                    else
                    { if( Rl > eps ) PG->ZapiszPozycje( MaxWsk - ceill( Skala * RD )
                            : else PG->ZapiszPozycje( MaxWsk );
                        while( !( Rl < eps || p > maxit ) ); if( p > maxit ) return 23; else return 0; } else return 22;
                    catch(...)
                    {
                        PiszKomBladAlgeLin( 20 ); return 33;
                    }, //RozRowMacIGS

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 * Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1( TComponent * Owner )
    : TForm( Owner )
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click( TObject * Sender )
{
    int n, iter;
    try {
        n = StrToInt( Edit1->Text );
        iter = StrToInt( Edit2->Text );
    }
    catch( Exception * e )
    {
        Edit1->Text = "";
        Edit2->Text = "";
        return;
    }
    W->ColCount = n;
    W->RowCount = n;
    X0->RowCount = n;
    Z->RowCount = n;
    X->RowCount = n;
    X->ColCount = iter;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click( TObject * Sender )
{
    Application->Terminate();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click( TObject * Sender )
{
    int n, iter, i, j, k;
    double ** Ws, * X0s, * Xs, * Zs, suma;
   
    try {
        n = StrToInt( Edit1->Text );
        iter = StrToInt( Edit2->Text );
    }
    catch( Exception * e )
    {
        Edit1->Text = "";
        Edit2->Text = "";
        return;
    }
   
    Ws = new double *[ n ];
    for( i = 0; i < n; i++ )
         Ws[ i ] = new double[ n ];
   
    X0s = new double[ n ];
    Zs = new double[ n ];
    Xs = new double[ n ];
   
    for( i = 0; i < n; i++ ) {
        for( j = 0; j < n; j++ )
             Ws[ i ][ j ] = StrToFloat( W->Cells[ j ][ i ] );
       
        X0s[ i ] = StrToFloat( X0->Cells[ 0 ][ i ] );
        Zs[ i ] = StrToFloat( Z->Cells[ 0 ][ i ] );
    }
   
   
    for( k = 1; k < iter; k++ ) { //wlasciwa metoda iteracji prostej
        for( i = 1; i < n; i++ )
        {
            suma = 0;
            for( j = 0; j < n; j++ )
                 suma += Ws[ i ][ j ] * X0s[ j ];
           
            Xs[ i ] = suma + Zs[ i ];
        }
        for( i = 0; i < n; i++ ) {
            X0s[ i ] = Xs[ i ];
            X->Cells[ k ][ i ] = FloatToStr( Xs[ i ] );
        }
       
    }
}
//-----------------------------------------------------------