Precedente Indice Successivo



Corit


Scopo: correzione iterativa della soluzione di un sistema lineare
Specifiche: subroutine corit(lu, p, b, x, ldlu, n, tol, maxit, r, ifail)

integer ldlu, n, p(n), maxit, ifail
real lu(ldlu, n), x(n), b(n), tol
double precision r(n)
Descrizione: Backgroud del problema

Il problema è quello di migliorare l'accuratezza della soluzione di un sistema lineare mediante un procedimento iterativo, col quale si genera una successione di approssimazioni che tentano di ridurre il residuo del sistema.

Descrizione dell'algoritmo

L'algoritmo riceve in ingresso i dati di un sistema A*x = b e una approssimazione della sua soluzione x' eventualmente calcolata in precedenza tramite la subroutine slup, quindi, calcola il residuo r = b - A*x' e risolve il sistema A*dx = r per determinare il termine correttivo dx tale che x' + dx » x. Il procedimento è iterato finché l'approssimazione raggiunta non soddisfa la tolleranza richiesta.

Raccomandazioni sull'uso

La matrice in ingresso e il vettore delle permutazioni devono essere nel formato di uscita di lup. La dimensione del sistema deve essere positiva e minore o uguale alla leading dimension , che a sua volta deve essere uguale alla dimensione di riga dichiarata nel programma chiamante. La tolleranza deve essere positiva e minore di uno. Il numero massimo di iterazioni deve essere positivo.

Bibliografia: [1], [3], [4]
Parametri di I/O: input

lu - matrice di reali, matrice dei coefficienti
x - vettore di reali, approssimazione della soluzione
p - vettore di interi, vettore delle permutazioni
b - vettore di reali, vettore dei termini noti
ldlu - intero, leading dimension di lu
n - intero, ordine del sistema
tol - reale, tolleranza relativa
maxit - intero, numero massimo di iterazioni da eseguire

output

x - vettore di reali, soluzione corretta
r - vettore di reali (in doppia precisione), residuo del sistema
ifail - intero, indicatore d'errore
Indicatori d'errore: errori gestiti dalla subroutine
ifail = 0 nessun errore
ifail = 1 la tolleranza è minore di zero o non minore di uno
ifail = 3 la dimensione inserita non è valida
ifail = 4 la matrice inserita è singolare
ifail = 8 il numero massimo di iterazioni è non positivo
ifail = 9 è stato raggiunto il numero massimo di iterazioni
Routines ausiliarie: nessuna.
Tempo d'esecuzione: funzione dell'ordine del sistema, del numero di iterazioni e della tolleranza
Memoria richiesta: sono allocati una matrice n*n, e quattro array di dimensione n
Accuratezza fornita: funzione della tolleranza richiesta
Esempio di programma chiamante: 
      Program coritd
c     Programma dimostrativo della subroutine corit

      external corit
      
      integer dim
      parameter (dim=6)
      
      real lu(dim,dim),x(dim),b(dim),tol
      integer p(dim),n,maxit,ifail
      double precision r(dim)
      character*12 fin1,fin2,fout
       
      print*
      print*,'*** PROGRAMMA DIMOSTRATIVO DELLA SUBROUTINE CORIT ***'
      print*
      write(*,10)'Ordine del sistema (max ',dim,')= '
      read(*,*)n   
      
      print*,'Nome del file di input (dati del sistema)= '
      read(*,'(A)')fin1
      open(11,FILE=fin1,STATUS='OLD')
      do 2 i=1,n
         do 1 j=1,n
            read(11,*)lu(i,j)
    1    continue
    2 continue
      read(11,*)
      do 3 i=1,n
         read(11,*)p(i)
    3 continue
      read(11,*)
      do 4 i=1,n
         read(11,*)b(i)
    4 continue
      close(11)
      
      print*,'Nome del file di input (soluzione del sistema)= '
      read(*,'(A)')fin2
      open(12,FILE=fin2,STATUS='OLD')
      do 5 i=1,n
         read(12,*)x(i)
    5 continue
      close(12)
      
      print*,'Tolleranza relativa= '
      read(*,*)tol
      
      print*,'Numero massimo di iterazioni= '
      read(*,*)maxit
            
      call corit(lu,p,b,x,dim,n,tol,maxit,r,ifail)
       
      if (ifail .eq. 1) stop 'Errore! tolleranza relativa non valida'
      if (ifail .eq. 3) stop 'Errore! dimensione non valida'
      if (ifail .eq. 4) stop 'Errore! matrice singolare'
      if (ifail .eq. 8) stop 'Errore! numero di iterazioni non valido'
      if (ifail .eq. 9) print*,'Attenzione! raggiunto il numero',
     %                         ' massimo di iterazioni'
      
      print*,'Nome del file di output= '
      read(*,'(A)')fout
      open(13,FILE=fout)
      write(13,20)(x(i),i=1,n)
      write(13,*)
      write(13,20)(r(i),i=1,n)
      close(13)
      
      print*,'Soluzione corretta= '
      write(*,20)(x(i),i=1,n)
      
      print*,'Residuo del sistema= '
      write(*,20)(r(i),i=1,n)
      
   10 format (1X,A,I3,A)
   20 format (1X,E14.7)  
   
      End




Precedente Indice Successivo