Introduzione all uso delle funzioni in C++

Transcript

1 Introduzione all uso delle funzioni in C++ Roberto Basili University of Rome Tor Vergata, Department of Computer Science, Systems and Production, Roma (Italy), January 24, 2001 /****************************************************************************** Esempio -- Introduzione alle funzioni Il metodo di Newton per la soluzione di equazioni non lineari Progetto del programma ******************************************************************************/ 1 PASSO (0) Fase di Specifica dei requisiti. /* Name: main Obbiettivo: Calcolo della radice della equazione f(x) = e^(-x) - x^2;. con una precisione assegnata pari a 1.0e-011 e stampa a video del numero di iterazioni effettuato, della radice <zero> determinata e del valore della funzione f(<zero>). Input: Valore di partenza (X0) per il metodo di Newton e limite al numero di iterazioni da effettuare; Output: <zero>, f(<zero>) e numero di iterazioni del metodo di Newton */ 2 PASSO (1): Determinare le variabili necessarie ed il loro tipo Variabili di ingresso valore iniziale x 0 della iterazione (reale) numero massimo di iterazioni (intero) Variabile d uscita: variabile zero della funzione zero (reale) 1

2 3 PASSI (2-3) Determinare la decomposizione in sottoproblemi e l algoritmo migliore OSSERVAZIONE: In questo caso l algoritmo e dato dalla soluzione analitica. Inoltre la decomposizione verra introdotta piu tardi 4 PASSO (4) Codifica del programma 4.1 PASSO (4.1) Definire la struttura del programma int main() // Dichiarazione delle Variabili // Chiedi i valori iniziali // - valore x0 di partenza della iterazione // - Limite al numero di passi // // Trova poi lo zero applicando il metodo di Newton... // Stampa delle soluzioni // Uscita dal programma system("pause"); return 0; L ingresso ed uscita del programma potrebbero essere: int main() // Dichiarazione delle Variabili // Chiedi i valori iniziali // - valore "startx" di partenza della iterazione // - Limite al numero di passi, variabile "maxsteps" // cout << "Insert the starting value: " ; cin >> startx; cout << "Insert the maximum number of steps: "; cin >> maxsteps; // Trova Lo zero applicando il metodo di Newton... 2

3 // Stampa delle soluzioni cout << "Soluzione x=" << setprecision(12) << zero << " con f(x)=" << setprecision(12) <<... << endl << endl; // Uscita dal programma system("pause"); return 0; 4.2 PASSO (4.2) Dichiarazione delle variabili/costanti Discutiamo ora alcune variabili (non solo di input/output) necessarie al controllo della iterazione del metodo di Newton Stato della iterazione di Newton TRY il metodo non ha raggiunto la precisione attesa DONE il metodo ha raggiunto la precisione attesa TOO MANY il metodo ha gia effettuato il numero massimo di iterazioni e quindi va sospeso DIV BY ZERO, quando una derivata nulla viene incontrata Per rappresentare lo stato dell iterazione uso un intero e definisco 4 costanti per i 4 stati possibili (TRY, DONE, TOO MANY, DIV BY ZERO) Poi ci sono ancora Variabile zero (reale) Variabile valore iniziale per il metodo iterativo (reale) Variabile di controllo per il massimo numero di passi (intera) Sentinella: numero di passi eseguiti (intera) Variabili della formula di Newton (reali): x (per il valore x i ) x next (per il valore x i+1 ) 3

4 Il programma risulta ora: /* Name: main Obbiettivo: Calcolo della radice della equazione f(x) = -e^(-x) - 2x;. con una precisione assegnata pari a 1.0e-011 e stampa a video del numero di iterazioni effettuato, della radice <zero> determinata e del valore della funzione f(<zero>). Input: Valore di partenza (X0) per il metodo di Newton e limite al numero di iterazioni da effettuare; Output: <zero>, f(<zero>) e numero di iterazioni del metodo di Newton */ #include <iostream> #include <stdlib.h> #include <iomanip.h> const int TRY = 0; const int DONE = 1; const int TOOMANY = 2; const int DIV_BY_ZERO = 3; int main() int stato = TRY; int maxsteps; int steps; // Lo stato iniziale // Memorizza il massimo numero di passi // Sentinella double zero, // Variabile che rappresenta la Soluzione startx; // Valore inziale X0 della successione delle X_i double x, x_next; // Variabili nella formula di Newton // Chiedi i valori iniziali // - valore x0 di partenza della iterazione // - Limite al numero di passi cout << "Insert the starting value: " ; cin >> startx; cout << "Insert the maximum number of steps: "; cin >> maxsteps; // Trova Lo zero applicando il metodo di Newton... // Stampa delle soluzioni: aggiornata if( stato == DONE ) cout << "Soluzione x=" << setprecision(12) << zero << " con f(x)=" << setprecision(12) <<... << endl << endl; else if (stato == TOOMANY) cout << "Convergenza troppo lenta\n\n"; 4

5 else if (stato == DIV_BY_ZERO) cout << "Divisione per zero!! Metodo inapplicabile\n\n"; // Uscita dal programma system("pause"); return 0; 4.3 PASSO(4.3) Codifica dell algoritmo di Newton Vanno rappresentate: La Funzione non lineare in C++ data da che si rappresenta come: La Derivata di f(x) in C++ che si rappresenta come: Inoltre va gestito il ciclo ierativo che: f(x) = e x x 2 exp(-x) - pow(x,2) f(x) = e x 2x -exp(-x) - 2*x richiede un controllo sulla precisione richiesta calcola un passo di iterazione secondo la formula di Newton verifica ed aggiorna lo stato ad ogni passo In conseguenza delle osservazioni precedenti, la variabile stato verra usata per il controllo di iterazione. OSS: Uno dei controlli deve prevedere una verifica della possibilita che uno degli x n sia 0, nel qual caso il metodo e inapplicabile (cioe stato = DIV BY ZERO) 5

6 Le osservazioni di sopra si riflettono nel programmma C++ nel seguente modo: #include <iostream> #include <stdlib.h> #include <iomanip.h> // Dichiarazioni di costanti... // Aggiungo la precisione richiesta const double EPS = 1.0e-011; // tolleranza 10 alla meno 11 int main() //... Dichiarazioni // Input // Trova Lo zero applicando il metodo di Newton steps=0; // Schema iterativo di NEWTON x_next = startx; while ( state == TRY ) ++steps; x = x_next; // Controllo sullo zero della derivata if ( (-exp(-x) - 2*x) == 0 ) state = DIV_BY_ZERO; zero = 0.0; else // Calcolo della formula di Newton // x_n+1 = x_n - f(x)/df(x) x_next = x - (exp(-x) - pow(x,2))/ (-exp(-x) - 2*x); // Controllo della precisione if ( fabs( x - x_next ) < EPS ) state = DONE; zero = x_next; else if ( steps > maxsteps ) // Controllo numero dei passi state = TOOMANY; // WHILE // Stampa delle soluzioni che si presenta quindi nella sua versione completa come segue: 6

7 #include <iostream> #include <stdlib.h> #include <iomanip.h> #include <math.h> // Dichiarazioni di costanti const int TRY = 0; const int DONE = 1; const int TOOMANY = 2; const int DIV_BY_ZERO = 3; // Aggiungo la precisione richiesta const double EPS = 1.0e-011; // tolleranza 10 alla meno 11 int main() int stato = TRY; int maxsteps; int steps; // Lo stato iniziale // Memorizza il massimo numero di passi // Sentinella double zero, // Variabile che rappresenta la Soluzione startx; // Valore inziale X0 della successione delle X_i double x, x_next; // Variabili nella formula di Newton // Chiedi i valori iniziali // - valore x0 di partenza della iterazione // - Limite al numero di passi cout << "Insert the starting value: " ; cin >> startx; cout << "Insert the maximum number of steps: "; cin >> maxsteps; // Trova Lo zero applicando il metodo di Newton steps=0; // Schema iterativo di NEWTON x_next = startx; while ( stato == TRY ) ++steps; x = x_next; // Controllo sullo zero della derivata if ( (-exp(-x) - 2*x) == 0 ) stato = DIV_BY_ZERO; zero = 0.0; else // Calcolo della formula di Newton // x_n+1 = x_n - f(x)/df(x) 7

8 x_next = x - (exp(-x) - pow(x,2))/ (-exp(-x) - 2*x); // Controllo della precisione if ( fabs( x - x_next ) < EPS ) stato = DONE; zero = x_next; else if ( steps > maxsteps ) // Controllo numero dei passi stato = TOOMANY; // WHILE // Stampa delle soluzioni if( stato == DONE ) cout << "Soluzione x=" << setprecision(12) << zero << " con f(x)=" << setprecision(12) << (exp(-zero) - pow(zero,2)) << endl << endl; cout << "Il numero di passi effettuati dall algoritmo e " << steps << endl << endl; else if (stato == TOOMANY) cout << "Convergenza troppo lenta\n\n"; else if (stato == DIV_BY_ZERO) cout << "Divisione per zero!! Metodo inapplicabile\n\n"; // Uscita dal programma system("pause"); return 0; 8

9 5 Revisione critica del programma Il programma illustrato consta di 85 linee di programma e di un blocco funzionale (il MAIN()) che controlla e gestisce ogni operazione: INPUT dei dati OUTPUT dei dati Calcolo della funzione f(x) Calcolo della funzione derivata di f(x) Iterazione Controllo dello stato Inoltre le istruzioni // Calcolo della formula di Newton x_next = x - (exp(-x) - pow(x,2))/ (-exp(-x) - 2*x); e // Stampa a video risultati cout << "Soluzione x=" << setprecision(12) << zero << " con f(x)=" << setprecision(12) << (exp(-zero) - pow(zero,2)) << endl << endl; cosi come le altre due // Controllo sugli zeri della derivata if ( (-exp(-x) - 2*x) == 0 ) e // Calcolo della formula di Newton x_next = x - (exp(-x) - pow(x,2))/ (-exp(-x) - 2*x); sono evidentemente ridondanti: in entrambi i casi siamo costretti a duplicare le definizioni stesse delle funzioni f(x) ed f (x). Inoltre soprattutto nel primo caso tali definizioni sono necessarie (e diverse) poiche agiscono su due variabili diverse: e (exp(-x) - pow(x,2)) (exp(-zero) - pow(zero,2)) In realta pero tale differenza (algoritmicamente) non esiste poiche in entrambi i casi abbiamo la stessa sequenza di operazioni numeriche sui dati: calcolo dell esponsneziale calcolo del quadrato differenza tra i due 9

10 Se potessimo astrarre questa definizione dal nome della variabile (x e/o zero) e definire una sola volta nel programma una f(y) tale da determinare quelle operazioni, potremmo, ogni volta che nel programma occorre la valutazione di f (quindi indifferentemente per f(x) o f(zero), richiamare la definizione semplificando la scrittura del programma. Tale ruolo di garanzia delle astrazioni funzionali (come f(x) ed f (x)) viene svolto in C++ dalle funzioni (dette anche funzioni definite dal programmatore). Esse garantiscono una DICHIARAZIONE, che definisce nome della funzione (f ne nostro esempio) argomenti della funzione (il loro numero, 1 nell esempio) tipo degli argomenti (reale nel nostro caso) tipo (di ritorno) della funzione (reale nel nostro caso) DEFINIZIONE, che definisce le operazioni da eseguire durante il calcolo della funzione sulle variabili INVOCAZIONE, che permette la attivazione di tale calcolo sugli argomenti di volta in volta necessari (nell esempio x o zero). Vediamo allora le funzioni viste nel problema di Newton. DICHIARAZIONI (anche detti PROTOTIPI) double f( double x); // dichiarazione funzione f() double df( double x); // dichiarazione della funzione f () DEFINIZIONI // Definizione di f(x) double f( double y) double tmp; tmp = exp(-y) - pow(y,2); return tmp; // FINE di f(x) // Definizione di f (x) double df( double z) double tmp; tmp = - exp(-z) - 2*z; return tmp; // FINE di df(x) Esempi di INVOCAZIONE (o attivazione, chiamata) // Calcolo della formula di Newton // Versione Senza funzioni f, df x_next = x - (exp(-x) - pow(x,2))/ (-exp(-x) - 2*x); // Versione con le funzioni f() e df x_next = x - f(x) / df(x); 10

11 e // Stampa a video risultati // Versione Senza funzione f cout << "Soluzione x=" << setprecision(12) << zero << " con f(x)=" << setprecision(12) << (exp(-zero) - pow(zero,2)) << endl << endl; // VersioneCon la funzione f cout << "Soluzione x=" << setprecision(12) << zero << " con f(x)=" << setprecision(12) << f(zero) << endl << endl; Osserviamo che una funzione C++ indipendente puo essere definita anche per le operazioni riguardanti il metodo stesso di Newton in modo da eliminare dai compiti del main() quello di gestire l iterazione DICHIARAZIONE/PROTOTIPO double newton( double x0, int &state, int maxsteps); DEFINIZIONE double newton( double x0, int &state, int maxsteps) int steps=0; double x, x_next; // Schema iterativo di NEWTON x_next = x0; while ( state == TRY ) ++steps; x = x_next; if ( df(x) == 0 ) state = DIV_BY_ZERO; x_next = 0.0; else x_next = x - f(x)/df(x); if ( fabs( x - x_next ) < EPS ) state = DONE; else if ( steps > maxsteps ) state = TOOMANY; // WHILE return x_next; //FINE funzione NEWTON() INVOCAZIONE zero = newton( startx, stato, maxsteps); 11

12 Date le tre definizioni di funzioni il programma e ora costituito dalla seguente struttura: main() f(x) df(x) newton(..) La sua versione in C++ e ora come segue. Si osservi il ruolo della definizione delle tre funzioni (che precede il main() e che svolge anche il ruolo della dichiarazione (che e quindi assente). /* */ Name: Newton Author: RBAS Description: Algorithm for finding zero s by the Newton iterative method Main File Date: Copyright: UTV #include <iostream> #include <stdlib.h> #include <iomanip.h> #include <math.h> const int TRY = 0; const int DONE = 1; const int TOOMANY = 2; const int DIV_BY_ZERO = 3; const double EPS = 1.0e-011; // tolleranza 10 alla meno 11 double f( double y) double tmp; tmp = exp(-y) - pow(y,2); return tmp; double df( double y) double tmp; 12

13 tmp = - exp(-y) - 2*y; return tmp; double newton( double x0, int &state, int maxsteps) int steps=0; double x, x_next; // Schema iterativo di NEWTON x_next = x0; while ( state == TRY ) ++steps; x = x_next; if ( df(x) == 0 ) state = DIV_BY_ZERO; x_next = 0.0; else x_next = x - f(x)/df(x); if ( fabs( x - x_next ) < EPS ) state = DONE; else if ( steps > maxsteps ) state = TOOMANY; // WHILE return x_next; int main() int stato = TRY; int maxsteps; double zero, //Solution startx; //Starting value for X_i // ASK for initial VALUES cout << "Insert the starting value: " ; cin >> startx; cout << "Insert the maximum number of steps: "; cin >> maxsteps; // FIND the ZERO zero = newton( startx, stato, maxsteps); 13

14 // PRINT the solutions if( stato == DONE ) cout << "Soluzione x=" << setprecision(12) << zero << " con f(x)=" << setprecision(12) << f(zero) << endl << endl; else if (stato == TOOMANY) cout << "Convergenza troppo lenta\n\n"; else if (stato == DIV_BY_ZERO) cout << "Divisione per zero!! Metodo inapplicabile\n\n"; system("pause"); return 0; 14