AN FI Iterazione&Invarianti Il ragionamento iterativo Gli invarianti di ciclo

AN FI Iterazione&Invarianti Impostazione di soluzioni iterative si parte dallidea che la soluzione possa essere ottenuta in un numero finito di n passi computazionali; si inizializza una variabile (detta accumulatore ) con il valore della soluzione al passo iniziale si imposta un ragionamento del tipo: sapendo che al passo generico i laccumulatore esprime il valore corrente della soluzione, la soluzione al passo i+1 si ottiene modificando laccumulatore come segue ….. Se il passo i rappresenta il passo finale, allora il valore della soluzione coincide con il valore dellaccumulatore.

AN FI Iterazione&Invarianti Il calcolo di b k double power(double b, int k ){ return (k==0) ? 1 : //k>0 b * power(b,k-1); }

AN FI Iterazione&Invarianti b k : progetto iterativo si inizializza un accumulatore v al valore b, inteso come il valore di b i al passo i=1 ; sapendo che al passo generico i (i<k) v esprime il valore corrente b i della soluzione, la soluzione al passo i+1 si ottiene modificando laccumulatore in v*b. Se i=k, allora la soluzione e v.

AN FI Iterazione&Invarianti b k : versione iterativa double power( double b, int k ){ return (k==0) ? 1 : powerIt(b,k,b,1);} double powerIt(double b,int k, double v, int i ){ return (i==k) ? v : powerIt(b, k, v*b, i+1);}

AN FI Iterazione&Invarianti Invarianti di ciclo u una relazione sempre vera (ad ogni iterazione) b k =v*b k-i inizialmente v=b, i=1

AN FI Iterazione&Invarianti b k : linvariante double powerIt( double b, int k, double v, int i ){ return (i==k) ? // b k =v*b k-i and i=k => b k =v v : // b k =v* b k-i and i<k // b k =v* b * b k-(i+1) and i<k // Ponendov = v*b, i=i+1 // si riottiene b k =v* b k-i powerIt(b, k, v*b, i+1); }

AN FI Iterazione&Invarianti Progettare per invarianti b k b k = v k con v=b Se k=0, si ha b k =v 0 =b 0 = 1 Trasformazioni: b k = (v 2 ) k/2 se k pari b k = v*v k-1 se k dispari

AN FI Iterazione&Invarianti b k : una soluzione a complessita log 2 (k) boolean odd(int n){ return(n%2==1); } double exp(double b,int k){ return (k==0) ? 1 : ( odd(k) ) ? b*exp(b,k-1) : exp(b*b,k/2); }

AN FI Iterazione&Invarianti b k in log 2 (k) : versione iterativa b k = t*v n con v=b, t=1,n=k –Se n=0, si ha b k =t. b k = t*(v 2 ) n/2 se n pari b k = t*v*v n-1 se n dispari

AN FI Iterazione&Invarianti Progetto versione iterativa log 2 (k) double expIt(double b,int k,double t,double v,int n ){ //Calcolare b k sapendo che b k = t*v n. //Inizialmente e v=b, n=k,t=1. Se n=0, b k =t. return (n==0) ? t : //Se n dispari, si itera con t=t*v ed n=n-1 (odd(n)) ? expIt(b,k,t*v,v,n-1) : //Se n pari si itera con v=v 2 e n=n/2 expIt(b,k,t,v*v,n/2) u le variabili b,k non servono

AN FI Iterazione&Invarianti Codice double power( double b, int k ){ return (k==0) ? 1 : expIt(1,b,k); // b k = 1*b k } double expIt(double t, double v, int n){ //b k = t*v n return (n==0) ? t : (odd(n)) ? // b k =t*v*v n-1 expIt(t*v,v,n-1) : // b k = t*(v 2 ) n/2 expIt(t,v*v,n/2); }

AN FI Iterazione&Invarianti Un caso strano int MulNat( int a, int b ){ return MulNat(a,b,0); } int MulNat( int x, int y, int z ){ return(y == 0) ? z : MulNat(x*2,y/2,z+x*(y%2)); }

AN FI Iterazione&Invarianti Una diversa versione int MulNat( int x, int y, int z ){ return(y == 0) ? z : ( odd(y) ) ? MulNat(x >1,z+x) : MulNat(x >1,z); }

AN FI Iterazione&Invarianti La relazione di base y = Q * B + R u B intero positivo u Q=y/B (quoziente) u R=y%B(resto)

AN FI Iterazione&Invarianti La moltiplicazione disgregata p = x* y = x *(Q * B + R) = x*B*Q + x*R u pensando che x*R e x*B siano primitive, si deve calcolare x*Q

AN FI Iterazione&Invarianti Lalgoritmo ricorsivo (B=2) int MulNatR( int x, int y ){ return (y == 0) ? 0 : x*(y%2)+MulNatR(x*2, y/2); }

AN FI Iterazione&Invarianti Verso un invariante di ciclo p = x*y + z = con y=0 si ha: p = z p = x*B*Q + x*R + z inizialmente z=0

AN FI Iterazione&Invarianti Il caso B=2 p = x*2*Q + x*R + z essendo Q=y/2 e R=y%2 p = x*2*y/2 + x*y%2 + z Ponendo x=x*2, y=y/2 e z=z+x*(y%2) si riottiene la relazione di partenza p=x*y+z

AN FI Iterazione&Invarianti Il codice spiegato int MulNat(int x,int y,int z){ //a*b=x*y+z inizialmente x=a, y=b, z=0 return(y == 0) ? //a*b =x*y + z and y=0 => a*b=z z : //a*b = x*( y/2*2+y%2) + z = //x*2*(y/2) + x*(y%2) + z MulNat(x*2,y/2,z+x*(y%2)); }

AN FI Iterazione&Invarianti La rappresentazione binaria y%2=0 se y pari, y%2=1 se y dispari; x*2 si ottiene spostando la rappresentazione binaria di x di una posizione a sinistra; x/2 si ottiene spostando la rappresentazione binaria di x di una posizione a destra.

AN FI Iterazione&Invarianti Lalgoritmo per moltiplicare int MulNat( int x, int y, int z ){ //a*b = x * y + z inizialmente x=a, y=b, z = 0 return(y == 0) ? //a*b=x*y+z and y=0 => a*b=z Z : (odd(y))? //a*b=x*( y/2*2+y%2)+z and y dispari //a*b=x*2*y/2 + x*1 + z MulNat(x >1,z+x) : //a*b = x*( y/2*2+y%2) + z and y pari //a*b = x*2*y/2 + x*0 + z MulNat(x >1,z); }