 |
Calcolo numerico |
|
Programmazione in Fortran 77.
Metodi di convergenza non lineare.
In questa rubrica presento una completa serie di algoritmi implementati in Digital Visual Fortran ( totalmente compatibile con il FORTRAN 77 ).
Nel 2005 questi programmi sono serviti agli studenti dei corsi serali per studenti lavoratori per superare l'esame universitario "Calcolo numerico e programmazione" presso la facoltą di ingegneria di Padova ( corso della professoressa Michela Redivo Zaglia per allievi aereospaziali).
I programmi sono testati e funzionanti ma essi non assicurano il superamento della prova d'esame senza un approfondito studio teorico nel testo "Calcolo numerico" dell'autrice Redivo Zaglia.
Attenzione: Nell'anno in cui questi programmi sono stati creati sono stati prodotti in sede d'esame (quindi vanno ben memorizzati nella loro essenza e non solo a memoria) usando il compilatore in linea del sistema operativo Linux installato in aula Taliercio della facoltą di ingegneria in via Belzoni 7 (PD). E' indispensabile al fine di superare la prova d'esame, sapere compilare in ambiente Linux ed effettuare la visualizzazione degli eventuali grafici con i tools di default presenti in quel sistema operativo.
I programmi name.f posso essere tagliati ed incollati nell'editor di programmazione per un corretto funzionamento. Ove sia necessario bisognerą far trovare nel direttorio di compilazione i file di testo contenenti l'insieme di input "formattato" ovvero con righe e colonne al posto in cui l'algoritmo le aspetta. Nella stessa directory troveremo il file testuale di output.
Marco Gottardo.
| bisez.for |
|
C==================================================================== C Programma per il Metodo di Bisezione C Versione con controlli in ingresso C==================================================================== program bis implicit none C==================== C Parte dichiarativa C==================== real*8 funz external funz real*8 a,b,toll real*8 amp,fa,fx integer nmax, maxdim parameter (maxdim=100) real*8 x(0:maxdim) integer n, i character*20 nomefile C==================== C Parte esecutiva C==================== C Ingresso ed uscita dati C print *, 'Dammi gli estremi a e b dell''intervallo iniziale' read*, a, b do while (funz(a)*funz(b).gt.0.0d0 .or. a .ge. b) print *, 'f(a)*f(b)>0 OPPURE a>=b! Reinserisci a e b' read*, a, b end do print *, 'Dammi il numero massimo di iterazioni nmax' read*, nmax do while (nmax .gt. 100) print *, * 'Numero massimo di iterazioni >', maxdim, ' Reinserisci nmax' read*, nmax end do print *, 'Dammi la tolleranza toll' read*, toll print *, 'Dammi il nome del file in uscita' read*, nomefile c open(unit=10,file=nomefile) write(10,*)'Estremi dell''intervallo iniziale a = ',a,' b = ',b write(10,*)'Numero massimo iterazioni = ',nmax write(10,*)'Tolleranza = ',toll write(10,*) C C Esecuzione metodo di bisezione C CALL bisezione (funz, a, b, toll, nmax, x, n) C C Uscita finale risultati C do i = 0, 2 write(10,'(i5,f20.15)') i, x(i) end do do i = 3, n write(10,'(i5,f20.15)') i, x(i) end do write(10,*) write(10,*) ' Numero iterazioni effettuate ', n write(10,'(a,f20.15)') ' Soluzione approssimata ', x(n) print *, ' Numero iterazioni effettuate ', n write(*,'(a,f20.15)') ' Soluzione approssimata ', x(n) close(10) stop end C==================================================================== C Subroutine per metodo di bisezione C==================================================================== SUBROUTINE bisezione (f, a, b, toll, nmax, x, n) implicit none C C Variabili INGRESSO: C f funzione di cui si cerca la soluzione C a, b estremi dell'intervallo che contiene la radice C toll tolleranza sull'ampiezza dell'intervallo C nmax numero massimo di iterazioni da eseguire C C Variabili USCITA: C x vettore contenente le iterate di lunghezza (0:n) C n indice dell'ultima iterata calcolata C C==================== C Parte dichiarativa C==================== real*8 f external f real*8 a,b,toll real*8 amp,fa,fx integer nmax real*8 x(0:*) integer n C==================== C Parte esecutiva C==================== n=0 amp=toll+1 fa=f(a) do while (amp.ge.toll.and.n.lt.nmax) amp=abs(b-a) x(n)=a+amp*0.5d0 fx=f(x(n)) if(fa*fx.lt.0.0d0) then b=x(n) else if (fa*fx.gt.0.0d0) then a=x(n) fa=fx else amp=0.0d0 endif n=n+1 enddo n=n-1 if (amp.ne.0) then n=n+1 x(n)=a+amp*0.25d0 endif return end C==================================================================== C Funzione assegnata C==================================================================== real*8 function funz(x) implicit none real*8 x funz=x-2.0d0 return end |
Metodo di bisezione con stima.
| bisezioneStima.f |
|
C==================================================================== C Programma per il Metodo di Bisezione C Versione con controlli in ingresso e con stima dell'ordine C==================================================================== program bis implicit none C==================== C Parte dichiarativa C==================== real*8 funz external funz real*8 a,b,toll real*8 amp,fa,fx integer nmax, maxdim parameter (maxdim=100) real*8 x(0:maxdim), p(3:maxdim) integer n, i character*20 nomefile C==================== C Parte esecutiva C==================== C Ingresso ed uscita dati C print *, 'Dammi gli estremi a e b dell''intervallo iniziale' read*, a, b do while (funz(a)*funz(b).gt.0.0d0 .or. a .ge. b) print *, 'f(a)*f(b)>0 OPPURE a>=b! Reinserisci a e b' read*, a, b end do print *, 'Dammi il numero massimo di iterazioni nmax' read*, nmax do while (nmax .gt. 100) print *, * 'Numero massimo di iterazioni >', maxdim, ' Reinserisci nmax' read*, nmax end do print *, 'Dammi la tolleranza toll' read*, toll print *, 'Dammi il nome del file in uscita' read*, nomefile c open(unit=10,file=nomefile) write(10,*)'Estremi dell''intervallo iniziale a = ',a,' b = ',b write(10,*)'Numero massimo iterazioni = ',nmax write(10,*)'Tolleranza = ',toll write(10,*) C C Esecuzione metodo di bisezione C CALL bisezione (funz, a, b, toll, nmax, x, n) C C Calcolo del vettore stime dell'ordine C CALL stimao (x,p,n) C C Uscita finale risultati C do i = 0, 2 write(10,'(i5,f20.15)') i, x(i) end do do i = 3, n write(10,'(i5,2f20.15)') i, x(i), p(i) end do write(10,*) write(10,*) ' Numero iterazioni effettuate ', n write(10,'(a,f20.15)') ' Soluzione approssimata ', x(n) print *, ' Numero iterazioni effettuate ', n write(*,'(a,f20.15)') ' Soluzione approssimata ', x(n) close(10) stop end C==================================================================== C Subroutine per metodo di bisezione C==================================================================== SUBROUTINE bisezione (f, a, b, toll, nmax, x, n) implicit none C C Variabili INGRESSO: C f funzione di cui si cerca la soluzione C a, b estremi dell'intervallo che contiene la radice C toll tolleranza sull'ampiezza dell'intervallo C nmax numero massimo di iterazioni da eseguire C C Variabili USCITA: C x vettore contenente le iterate di lunghezza (0:n) C n indice dell'ultima iterata calcolata C C==================== C Parte dichiarativa C==================== real*8 f external f real*8 a,b,toll real*8 amp,fa,fx integer nmax real*8 x(0:*) integer n C==================== C Parte esecutiva C==================== n=0 amp=toll+1 fa=f(a) do while (amp.ge.toll.and.n.lt.nmax) amp=abs(b-a) x(n)=a+amp*0.5d0 fx=f(x(n)) if(fa*fx.lt.0.0d0) then b=x(n) else if (fa*fx.gt.0.0d0) then a=x(n) fa=fx else amp=0.0d0 endif n=n+1 enddo n=n-1 if (amp.ne.0) then n=n+1 x(n)=a+amp*0.25d0 endif return end C==================================================================== C Subroutine per il calcolo della stima dell'ordine C==================================================================== SUBROUTINE stimao(x,p,n) implicit none C C Variabili INGRESSO: C x vettore contenente le iterate - dimensione (0:n) C n indice dell'ultima iterata calcolata C C Variabili USCITA: C C p vettore contenente le stime - dimensione (3:n) C C==================== C Parte dichiarativa C==================== real*8 x(0:*), p(3:*) integer i, n C==================== C Parte esecutiva C==================== do i = 3,n p(i) = dlog(dabs(x(i)-x(i-1))/dabs(x(i-1)-x(i-2))) / * dlog(dabs(x(i-1)-x(i-2))/dabs(x(i-2)-x(i-3))) end do return end C==================================================================== C Funzione assegnata C==================================================================== real*8 function funz(x) implicit none real*8 x !funz=x-2.0d0 !funz=(x-1)*log(x) funz=x**2-x-2 return end |
Metodo di Newton.
| newtonC.f |
|
C==================================================================== C Programma per il Metodo di Newton con stima C Versione con controlli in ingresso C==================================================================== program bis implicit none C==================== C Parte dichiarativa C==================== real*8 funz external funz real*8 dfun external dfun real*8 toll,vi real*8 diff integer nmax, maxdim parameter (maxdim=100) real*8 x(0:maxdim) integer n, i character*20 nomefile C==================== C Parte esecutiva C==================== C Ingresso ed uscita dati C print *, 'Dammi il numero massimo di iterazioni nmax' read*, nmax do while (nmax .gt. 100) print *, * 'Numero massimo di iterazioni >', maxdim, ' Reinserisci nmax' read*, nmax end do print *, 'Dammi la tolleranza toll' read*, toll print*,'Dammi il valore di vi ' read*,vi print *, 'Dammi il nome del file in uscita' read*, nomefile c open(unit=10,file=nomefile) write(10,*)'Numero massimo iterazioni = ',nmax write(10,*)'Tolleranza = ',toll write(10,*) C C Esecuzione metodo di Newton C CALL pippo(funz,dfun,vi,toll,nmax,x,n) C C Uscita finale risultati C do i = 0, 2 write(10,'(i5,f20.15)') i, x(i) end do do i = 3, n write(10,'(i5,f20.15)') i, x(i) end do write(10,*) write(10,*) ' Numero iterazioni effettuate ', n write(10,'(a,f20.15)') ' Soluzione approssimata ', x(n) print *, ' Numero iterazioni effettuate ', n write(*,'(a,f20.15)') ' Soluzione approssimata ', x(n) close(10) stop end C==================================================================== C Subroutine per metodo di bisezione C==================================================================== SUBROUTINE pippo(f,df,vi,toll,nmax,x,n) implicit none C C Variabili INGRESSO: C f funzione di cui si cerca la soluzione C df derivata della funzione C toll tolleranza sull'ampiezza dell'intervallo C nmax numero massimo di iterazioni da eseguire C C Variabili USCITA: C x vettore contenente le iterate di lunghezza (0:n) C n indice dell'ultima iterata calcolata C C==================== C Parte dichiarativa C==================== real*8 f external f real*8 df external df real*8 toll,diff real*8 vi integer n,nmax real*8 x(0:*) C==================== C Parte esecutiva C==================== n=0 x(n)=vi diff=toll+1 do while (diff.ge.toll.and.n.lt.nmax) diff=-(f(x(n))/df(x(n))) x(n+1)=x(n)+diff diff=abs(diff) n=n+1 enddo return end C==================================================================== C Funzione assegnata C==================================================================== real*8 function funz(x) implicit none real*8 x funz=(x-1.0d0)*dlog10(x) return end c===================================================================== c funzione derivata assegnata c===================================================================== real*8 function dfun(x) implicit none real*8 x dfun=dlog10(x)+(x-1.0d0)*(1.0d0/x) return end c----------------------------------------- c----------------------------------------- |
Programma per il Metodo di Newton con stima.Versione con controlli in ingresso, con stima dell'ordine e molteplicitą
| newtonstima_r.f |
|
C============================================================================ C Programma per il Metodo di Newton con stima C Versione con controlli in ingresso, con stima dell'ordine e molteplicitą C============================================================================ program bis implicit none C==================== C Parte dichiarativa C==================== real*8 funz external funz real*8 dfun external dfun real*8 toll,vi real*8 diff integer nmax, maxdim parameter (maxdim=100) real*8 x(0:maxdim), p(3:maxdim) integer n, i, r character*20 nomefile C==================== C Parte esecutiva C==================== C Ingresso ed uscita dati C print *, 'Dammi il numero massimo di iterazioni nmax' read*, nmax do while (nmax .gt. 100) print *, * 'Numero massimo di iterazioni >', maxdim, ' Reinserisci nmax' read*, nmax end do print *, 'Dammi la tolleranza toll' read*, toll print*,'Dammi il valore di vi ' read*,vi print*,'Dammi il valore dela molteplicita r' read*,r print *, 'Dammi il nome del file in uscita' read*, nomefile c open(unit=10,file=nomefile) write(10,*)'Numero massimo iterazioni = ',nmax write(10,*)'Tolleranza = ',toll write(10,*) C C Esecuzione metodo di Newton C CALL pippo(funz,dfun,vi,toll,nmax,x,n,r) C C Calcolo del vettore stime dell'ordine C CALL stimao (x,p,n) C C Uscita finale risultati C do i = 0, 2 write(10,'(i5,f20.15)') i, x(i) end do do i = 3, n write(10,'(i5,2f20.15)') i, x(i), p(i) end do write(10,*) write(10,*) ' Numero iterazioni effettuate ', n print*, ' Molteplicita r=',r write(10,'(a,f20.15)') ' Soluzione approssimata ', x(n) print *, ' Numero iterazioni effettuate ', n write(10,*) ' Molteplicita r= ', r write(*,'(a,f20.15)') ' Soluzione approssimata ', x(n) close(10) stop end C==================================================================== C Subroutine per metodo di NEWTON STIMA CON MOLTEPLICITA' C==================================================================== SUBROUTINE pippo(f,df,vi,toll,nmax,x,n,r) implicit none C C Variabili INGRESSO: C f funzione di cui si cerca la soluzione C df derivata della funzione C toll tolleranza sull'ampiezza dell'intervallo C nmax numero massimo di iterazioni da eseguire C C Variabili USCITA: C x vettore contenente le iterate di lunghezza (0:n) C n indice dell'ultima iterata calcolata C C==================== C Parte dichiarativa C==================== real*8 f external f real*8 df external df real*8 toll,diff real*8 vi integer n,nmax,r real*8 x(0:*) C==================== C Parte esecutiva C==================== n=0 x(n)=vi diff=toll+1 do while (diff.ge.toll.and.n.lt.nmax) diff=-(f(x(n))/df(x(n))) x(n+1)=x(n)+r*diff diff=abs(diff) n=n+1 enddo return end C==================================================================== C Subroutine per il calcolo della stima dell'ordine C==================================================================== SUBROUTINE stimao(x,p,n) implicit none C C Variabili INGRESSO: C x vettore contenente le iterate - dimensione (0:n) C n indice dell'ultima iterata calcolata C C Variabili USCITA: C C p vettore contenente le stime - dimensione (3:n) C C==================== C Parte dichiarativa C==================== real*8 x(0:*), p(3:*) integer i, n C==================== C Parte esecutiva C==================== do i = 3,n p(i) = dlog(dabs(x(i)-x(i-1))/dabs(x(i-1)-x(i-2))) / * dlog(dabs(x(i-1)-x(i-2))/dabs(x(i-2)-x(i-3))) end do return end C==================================================================== C Funzione assegnata C==================================================================== real*8 function funz(x) implicit none real*8 x funz=(x-1.0d0)*dlog10(x) return end c===================================================================== c funzione derivata assegnata c===================================================================== real*8 function dfun(x) implicit none real*8 x dfun=dlog10(x)+(x-1.0d0)*(1.0d0/x) return end c----------------------------------------- c----------------------------------------- |
Metodo di Newton con stima dell'ordine della molteplicitą.
| newtonstima.f |
|
C==================================================================== C Programma per il Metodo di Newton con stima C Versione con controlli in ingresso e con stima dell'ordine C==================================================================== program Newton implicit none C==================== C Parte dichiarativa C==================== real*8 funz external funz real*8 dfun external dfun real*8 toll,vi real*8 diff integer nmax, maxdim parameter (maxdim=100) real*8 x(0:maxdim), p(3:maxdim) integer n, i character*20 nomefile C==================== C Parte esecutiva C==================== C Ingresso ed uscita dati C print *, 'Dammi il numero massimo di iterazioni nmax' read*, nmax do while (nmax .gt. 100) print *, * 'Numero massimo di iterazioni >', maxdim, ' Reinserisci nmax' read*, nmax end do print *, 'Dammi la tolleranza toll' read*, toll print*,'Dammi il valore di vi ' read*,vi print *, 'Dammi il nome del file in uscita' read*, nomefile c open(unit=10,file=nomefile) write(10,*)'Numero massimo iterazioni = ',nmax write(10,*)'Tolleranza = ',toll write(10,*) C C Esecuzione metodo di Newton C CALL pippo(funz,dfun,vi,toll,nmax,x,n) C C Calcolo del vettore stime dell'ordine C CALL stimao (x,p,n) C C Uscita finale risultati C do i = 0, 2 write(10,'(i5,f20.15)') i, x(i) end do do i = 3, n write(10,'(i5,2f20.15)') i, x(i), p(i) end do write(10,*) write(10,*) ' Numero iterazioni effettuate ', n write(10,'(a,f20.15)') ' Soluzione approssimata ', x(n) print *, ' Numero iterazioni effettuate ', n write(*,'(a,f20.15)') ' Soluzione approssimata ', x(n) close(10) stop end C==================================================================== C Subroutine per metodo di bisezione C==================================================================== SUBROUTINE pippo(f,df,vi,toll,nmax,x,n) implicit none C C Variabili INGRESSO: C f funzione di cui si cerca la soluzione C df derivata della funzione C toll tolleranza sull'ampiezza dell'intervallo C nmax numero massimo di iterazioni da eseguire C C Variabili USCITA: C x vettore contenente le iterate di lunghezza (0:n) C n indice dell'ultima iterata calcolata C C==================== C Parte dichiarativa C==================== real*8 f external f real*8 df external df real*8 toll,diff real*8 vi integer n,nmax real*8 x(0:*) C==================== C Parte esecutiva C==================== n=0 x(n)=vi diff=toll+1 do while (diff.ge.toll.and.n.lt.nmax) diff=-(f(x(n))/df(x(n))) x(n+1)=x(n)+diff diff=abs(diff) n=n+1 enddo return end C==================================================================== C Subroutine per il calcolo della stima dell'ordine C==================================================================== SUBROUTINE stimao(x,p,n) implicit none C C Variabili INGRESSO: C x vettore contenente le iterate - dimensione (0:n) C n indice dell'ultima iterata calcolata C C Variabili USCITA: C C p vettore contenente le stime - dimensione (3:n) C C==================== C Parte dichiarativa C==================== real*8 x(0:*), p(3:*) integer i, n C==================== C Parte esecutiva C==================== do i = 3,n p(i) = dlog(dabs(x(i)-x(i-1))/dabs(x(i-1)-x(i-2))) / * dlog(dabs(x(i-1)-x(i-2))/dabs(x(i-2)-x(i-3))) end do return end C==================================================================== C Funzione assegnata C==================================================================== real*8 function funz(x) implicit none real*8 x !funz=x+1.0d0 funz=(x-1)*dlog(x) return end c===================================================================== c funzione derivata assegnata c===================================================================== real*8 function dfun(x) implicit none real*8 x !dfun=1.0d0 dfun=dlog(x)+((x+1)*(1/x)) return end c----------------------------------------- c----------------------------------------- |
Programma per il Metodo di Punto fisso con stima. Versione con controlli in ingresso.
| puntofisso.f |
|
C==================================================================== C Programma per il Metodo di Punto fisso con stima C Versione con controlli in ingresso C==================================================================== program bis implicit none C==================== C Parte dichiarativa C==================== real*8 funz external funz real*8 toll,vi real*8 diff integer nmax, maxdim parameter (maxdim=100) real*8 x(0:maxdim) integer n, i character*20 nomefile C==================== C Parte esecutiva C==================== C Ingresso ed uscita dati C print *, 'Dammi il numero massimo di iterazioni nmax' read*, nmax do while (nmax .gt. 100) print *, * 'Numero massimo di iterazioni >', maxdim, ' Reinserisci nmax' read*, nmax end do print *, 'Dammi la tolleranza toll' read*, toll print*,'Dammi il valore di vi ' read*,vi print *, 'Dammi il nome del file in uscita' read*, nomefile c open(unit=10,file=nomefile) write(10,*)'Numero massimo iterazioni = ',nmax write(10,*)'Tolleranza = ',toll write(10,*) C C Esecuzione metodo di Newton C CALL pfisso(funz,vi,toll,nmax,x,n) C C C Uscita finale risultati C do i = 0, 2 write(10,'(i5,f20.15)') i, x(i) end do do i = 3, n write(10,'(i5,f20.15)') i, x(i) end do write(10,*) write(10,*) ' Numero iterazioni effettuate ', n write(10,'(a,f20.15)') ' Soluzione approssimata ', x(n) print *, ' Numero iterazioni effettuate ', n write(*,'(a,f20.15)') ' Soluzione approssimata ', x(n) close(10) stop end C==================================================================== C Subroutine per metodo di Punto fisso C==================================================================== SUBROUTINE pfisso(f,vi,toll,nmax,x,n) implicit none C C Variabili INGRESSO: C f funzione di cui si cerca la soluzione C toll tolleranza sull'ampiezza dell'intervallo C nmax numero massimo di iterazioni da eseguire C C Variabili USCITA: C x vettore contenente le iterate di lunghezza (0:n) C n indice dell'ultima iterata calcolata C C==================== C Parte dichiarativa C==================== real*8 f external f real*8 toll,diff real*8 vi integer n,nmax real*8 x(0:*) C==================== C Parte esecutiva C==================== n=0 x(n)=vi diff=toll+1 do while (diff.ge.toll.and.n.lt.nmax) n=n+1 x(n)=f(x(n-1)) x(n+1)=f(x(n)) diff=abs(x(n+1)-x(n)) enddo return end C==================================================================== C Funzione assegnata C==================================================================== real*8 function funz(x) implicit none real*8 x funz=((2.0d0*x**3+4.0d0*x**2+10)/(3.0d0*x**2+8.0d0*x)) return end c==================================================================== |
Programma per il Metodo di Punto fisso con stima Versione con controlli in ingresso e con stima dell'ordine
|
C==================================================================== C Programma per il Metodo di Punto fisso con stima C Versione con controlli in ingresso e con stima dell'ordine C==================================================================== program puntofisso implicit none C==================== C Parte dichiarativa C==================== real*8 funz external funz real*8 toll,vi real*8 diff integer nmax, maxdim parameter (maxdim=100) real*8 x(0:maxdim), p(3:maxdim) integer n, i character*20 nomefile C==================== C Parte esecutiva C==================== C Ingresso ed uscita dati C print *, 'Dammi il numero massimo di iterazioni nmax' read*, nmax do while (nmax .gt. 100) print *, * 'Numero massimo di iterazioni >', maxdim, ' Reinserisci nmax' read*, nmax end do print *, 'Dammi la tolleranza toll' read*, toll print*,'Dammi il valore di vi ' read*,vi print *, 'Dammi il nome del file in uscita' read*, nomefile c open(unit=10,file=nomefile) write(10,*)'Numero massimo iterazioni = ',nmax write(10,*)'Tolleranza = ',toll write(10,*) C C Esecuzione metodo di Newton C CALL pfisso(funz,vi,toll,nmax,x,n) C C Calcolo del vettore stime dell'ordine C CALL stimao (x,p,n) C C Uscita finale risultati C do i = 0, 2 write(10,'(i5,f20.15)') i, x(i) end do do i = 3, n write(10,'(i5,2f20.15)') i, x(i), p(i) end do write(10,*) write(10,*) ' Numero iterazioni effettuate ', n write(10,'(a,f20.15)') ' Soluzione approssimata ', x(n) print *, ' Numero iterazioni effettuate ', n print *, ' Valore iniziale ', vi write(10,*) ' Valore iniziale ', vi write(*,'(a,f20.15)') ' Soluzione approssimata ', x(n) close(10) stop end C==================================================================== C Subroutine per metodo di Punto fisso C==================================================================== SUBROUTINE pfisso(f,vi,toll,nmax,x,n) implicit none C C Variabili INGRESSO: C f funzione di cui si cerca la soluzione C toll tolleranza sull'ampiezza dell'intervallo C nmax numero massimo di iterazioni da eseguire C C Variabili USCITA: C x vettore contenente le iterate di lunghezza (0:n) C n indice dell'ultima iterata calcolata C C==================== C Parte dichiarativa C==================== real*8 f external f real*8 toll,diff real*8 vi integer n,nmax real*8 x(0:*) C==================== C Parte esecutiva C==================== n=0 x(n)=vi diff=toll+1 do while (diff.ge.toll.and.n.lt.nmax) n=n+1 x(n)=f(x(n-1)) x(n+1)=f(x(n)) diff=abs(x(n+1)-x(n)) enddo return end C==================================================================== C Subroutine per il calcolo della stima dell'ordine C==================================================================== SUBROUTINE stimao(x,p,n) implicit none C C Variabili INGRESSO: C x vettore contenente le iterate - dimensione (0:n) C n indice dell'ultima iterata calcolata C C Variabili USCITA: C C p vettore contenente le stime - dimensione (3:n) C C==================== C Parte dichiarativa C==================== real*8 x(0:*), p(3:*) integer i, n C==================== C Parte esecutiva C==================== do i = 3,n p(i) = dlog(dabs(x(i)-x(i-1))/dabs(x(i-1)-x(i-2))) / * dlog(dabs(x(i-1)-x(i-2))/dabs(x(i-2)-x(i-3))) end do return end C==================================================================== C Funzione assegnata C==================================================================== real*8 function funz(x) implicit none real*8 x !funz=x+1.0d0 !funz=(x*(x**2+6))/(3*x**2+2) !funz=(2*x**3+4*x**2+10)/(3*x**2+8*x) funz=x**2-2 return end c==================================================================== |