Programmazione Funzionale e Parallela: Esercizi di preparazione all'esame: programmazione funzionale e parallela (2016-2017)

Revision [871]

Last edited on 2017-11-08 12:01:42 by CamilDemetrescu

Additions:

La seguente classe, in combinazione con le classi ""Shape"" e ""Frame2D"" dell'esercizio 26, permette di visualizzare il grafico di una qualsiasi funzione Scala ##Double => Double## in un certo intervallo:
Aggiungere alla classe ##Fun## dell'esercizio 30 un metodo ##deriv## che calcola la derivata di una funzione. Ad esempio, se ##f## è un oggetto ##Fun## che rappresenta una funzione polinomiale, ##f.deriv## è un oggetto ##Fun## che rappresenta la derivata di ##f##. La funzione può essere usata come segue:

Deletions:

La seguente classe, in combinazione con le classi ""Shape"" e ""Frame2D"" dell'esercizio 25, permette di visualizzare il grafico di una qualsiasi funzione Scala ##Double => Double## in un certo intervallo:
Aggiungere alla classe ##Fun## dell'esercizio 29 un metodo ##deriv## che calcola la derivata di una funzione. Ad esempio, se ##f## è un oggetto ##Fun## che rappresenta una funzione polinomiale, ##f.deriv## è un oggetto ##Fun## che rappresenta la derivata di ##f##. La funzione può essere usata come segue:

Revision [870]

Edited on 2017-11-08 11:14:36 by CamilDemetrescu

Additions:

==Esercizio 30 (rappresentazione simbolica di funzioni)==
Si consideri il problema di rappresentare una funzione polinomiale della forma ""f(x) = a_nxⁿ+ a_n-1x^n-1+...+ a₂x²+ a₁x+ a₀"". Possiamo partire dalle seguenti classi case:
%%(java;Fun.scala)
import scala.language.implicitConversions
sealed abstract class Fun {
def apply(x:Double):Double = {
this match {
case X() => x
case Const(i) => i
case Add(a,b) => a(x)+b(x)
}
def +(e:Fun) = Add(this,e)
case class X() extends Fun
case class Const(i:Int) extends Fun
case class Add(a:Fun, b:Fun) extends Fun
object Fun {
val x = X()
implicit def intToFun(i:Int) = Const(i)
che possiamo testare ad esempio con:
%%(java;ProvaFun.scala)
import Fun._
object ProvaFun extends App {
val f = Add(X(), Const(1)) // x+1
val h = x+1 // equivalente a: Add(X(), Const(1))
val y = h(10.7) // stampa 11.7
println(y)
La seguente classe, in combinazione con le classi ""Shape"" e ""Frame2D"" dell'esercizio 25, permette di visualizzare il grafico di una qualsiasi funzione Scala ##Double => Double## in un certo intervallo:
def getFunChart(steps:Int)(minX:Double, maxX:Double)(f:Double=>Double) = {
require(steps >= 2 && minX <= maxX)
def x(min:Double, max:Double, i:Int) = min+i*(max-min)/steps
def norm(min:Double, max:Double, x:Double) = (x-min)/(max-min)
val (minY, maxY) =
Stream.range(0, steps+1) .
map { i => { val y = f(x(minX, maxX, i)); (y,y) } } .
reduce { (a,b) => (a._1 min b._1, a._2 max b._2) }
val s = for {
i <- 1 to steps
val x1 = x(0, 1, i-1)
val x2 = x(0, 1, i)
val y1 = norm(minY, maxY, f(x(minX, maxX, i-1)))
val y2 = norm(minY, maxY, f(x(minX, maxX, i)))
} yield new Line(x1,y1,x2,y2)
val zeroX = norm(minX, maxX, 0)
val zeroY = norm(minY, maxY, 0)
new Line(zeroX, 0, zeroX, 1) :: new Line(0, zeroY, 1, zeroY) :: s.toList
Ad esempio, possiamo visualizzare la funzione ##f## nell'intervallo [-10,10], con 100 segmenti di linea, come segue:
val l = Model2D.getFunChart(100)(-10, 10)(x=>f(x))
Frame2D.display(l, 700, 300)
Completare la classe ##Fun## come segue:
~- aggiungere nuove classi:
~~- ##Pow(a,i)##, con ##a## funzione e ##i## intero che rappresenta l'elevamento a potenza ##""aⁱ""##;
~~- ##Mul(a,b)## e ##Sub(a,b)## che rappresentano il prodotto e la differenza di funzioni ##a## e ##b##, rispettivamente;
~- aggiungere metodo ##toString##;
~- definire metodi *, -, ""**"" per le operazioni prodotto, differenza, potenza;
Le estensioni devono rendere possibile compilare ed eseguire il seguente esempio:
val f = x**2-x*(x+1)+3 // f(x)=x^2-x(x+1)+3
println(f) // stampa "x => x^2-x*(x+1)+3"
println(f(4)) // stampa -1
==Esercizio 31 (derivate di funzioni polinomiali)==
Aggiungere alla classe ##Fun## dell'esercizio 29 un metodo ##deriv## che calcola la derivata di una funzione. Ad esempio, se ##f## è un oggetto ##Fun## che rappresenta una funzione polinomiale, ##f.deriv## è un oggetto ##Fun## che rappresenta la derivata di ##f##. La funzione può essere usata come segue:
// f(x) = x^2 - 1
val f = x**2 - 1
println(f(4)) // stampa 15
println(f.deriv(4)) // stampa 8
println(f.deriv.deriv(4)) // stampa 2
println(f.deriv.deriv.deriv(4)) // stampa 0

Revision [846]

Edited on 2017-10-26 15:26:36 by CamilDemetrescu

Additions:

def g(h:Int=>Int): Int=>Int = x => h(h(x))

Deletions:

~~def g(f:Int=>Int): Int=>Int = x => f(f(x))~~

Revision [841]

Edited on 2017-10-22 15:31:28 by CamilDemetrescu

Additions:

==Esercizio 23: estensione del linguaggio con nuovi costrutti==
==Esercizio 24: query su collezioni==

Deletions:

==Esercizio 23 (estensione del linguaggio con nuovi costrutti)==
==Esercizio 24 (query su collezioni)==

Revision [840]

Edited on 2017-10-22 13:31:13 by CamilDemetrescu

Additions:

==Esercizio 23 (estensione del linguaggio con nuovi costrutti)==
Il nome Scala è un acronimo di SCAlable LAnguage, che riflette il design del linguaggio orientato all'estensibilità. In Scala è possibile introdurre nuovi costrutti sfruttando il meccanismo del passaggio dei parametri per nome e la flessibilità nell'invocazione dei metodi senza dover mettere argomenti tra parentesi.
Questo esercizio richiede di definire un costrutto ##repeat(n) I## che ripete l'istruzione ##I## per ##n## volte, dove ##n## è un ##Int##. Deve essere possibile scrivere:
%%(java)
repeat(3) {
println("ciao")
che esegue tre volte la stampa.
~& **Suggerimento:** definire un metodo ##repeat## parzialmente applicato dove il secondo parametro è un ##Unit## passato per nome.
==Esercizio 24 (query su collezioni)==
Completare il seguente frammento di programma usando for comprehension:
%%(java)
case class Studente(val nome:String, val età:Int, val esami:List[String])
val q = List(
Studente("Marco", 23, List("PFP","SC")),
Studente("Laura", 19, List("SC", "FI1", "PFP")),
Studente("Stefano", 23, List("SC", "FI1")),
Studente("Marco", 25, List("SC", "FI1", "FI2")),
Studente("Paola", 22, List("SC", "PFP"))
)
val query1 = // estrarre tutti gli studenti con età compresa tra 20 e 24 anni (inclusi) che hanno sostenuto l'esame di "PFP"
// stampare i dati degli studenti in query1
val query2 = // estrarre tutti gli studenti con età strettamente inferiore a 24 anni che hanno sostenuto almeno due esami
// stampare i dati degli studenti in query2
==Esercizio 29 (estensione della classe List)==
Fare in modo di poter compilare ed eseguire il seguente programma:
%%(java)
import MyRichList._
val l:List[Int] = List(4,1,2,4,7,0) intersection List(3,3,2,5,3,4,1,7,9)
println(l) // stampa List(7, 2, 1, 4) (in qualsiasi ordine)

Deletions:

==Esercizio 23==
==Esercizio 24==

Revision [839]

Edited on 2017-10-22 13:28:09 by CamilDemetrescu

Additions:

==Esercizio 23==
==Esercizio 24==
==Esercizio 25: classe per numeri razionali==
Scrivere una classe Rational che rappresenta numeri razionali della forma num/den, dove num e den sono interi. Scrivere la classe in modo che sia possibile eseguire il seguente frammento Scala:
val r1 = new Rational(2, 7)
val r2 = new Rational(8, 6)
val r3 = new Rational(4,14)
println(r1+r2) // stampa 34/21
println(r1-r2) // stampa -22/21
println(r1*r2) // stampa 8/21
println(r1/r2) // stampa 3/14
println(r1==r3) // stampa true
println(r1!=r2) // stampa true
println(r1 println(r2 ~& **Suggerimento:** calcolare il massimo comun divisore di numeratore e denominatore per riportare la frazione ai minimi termini (o irriducibile). Ad esempio, 4/14 dovrebbe essere memorizzato in un oggetto Rational come 2/7.
==Esercizio 26: disegno di una griglia n x n (grafica 2D)==
Completare il metodo ##get## dell'object ##""Model2D""## seguente in modo che costruisca un modello 2D che raffigura una griglia ##n x n##. La figura è creata utilizzando esclusivamente segmenti di linea. La figura deve essere confinata nello spazio quadrato bidimensionale di lato unitario delimitato dall'origine degli assi fino al punto di coordinate (1,1). La figura viene poi scalata automaticamente dal modulo di visualizzazione per occupare la dimensione della finestra. Si ricordi che da Scala è possibile accedere a tutte le funzioni delle librerie Java (es. quelle della classe ##Math## se dovessero servire).
Per compilare da riga di comando usare: ##""scalac Frame2D.scala Shape.scala Model2D.scala""##.
%%(java;Model2D.scala)
object Model2D {
def getGrid(n:Int) = {
// completare costruzione di un modello 2D di una griglia con n linee verticali ed n linee orizzontali
List(new Line(0.0,0.0,1.0,1.0)) // esempio di linea
}
def main(args:Array[String]) {
println("Displaying 20x20 grid...")
Frame2D.display(Model2D.getGrid(20), 500, 500)
}
%%(java;Shape.scala)
abstract class Shape
class Circle(val x:Double, val y:Double, val r:Double) extends Shape
class Line(val x1:Double, val y1:Double, val x2:Double, val y2:Double) extends Shape
%%(java;Frame2D.scala)
import java.awt.{EventQueue,Graphics,Graphics2D,Dimension}
import javax.swing.{JFrame,JPanel}
object Frame2D {
def display(l:List[Shape], width:Int, height:Int) {
EventQueue.invokeLater(new Runnable() {
override def run() {
val ex = new Frame2D(l,width,height)
ex.setVisible(true)
}
})
}
class Frame2D(l:List[Shape], width:Int, height:Int) extends JFrame {
class Surface2D extends JPanel {
def doDrawCircle(c:Circle, g2d:Graphics2D) {
val xc = (width*(c.x-c.r)).toInt
val yc = height/2-(height*(c.y-c.r)).toInt
val wc = (2*width*c.r).toInt
val hc = (2*height*c.r).toInt
g2d.drawOval(xc, yc, wc, hc)
}
def doDrawLine(l:Line, g2d:Graphics2D) {
val x1 = (width*l.x1).toInt
val y1 = height-(height*l.y1).toInt
val x2 = (width*l.x2).toInt
val y2 = height-(height*l.y2).toInt
g2d.drawLine(x1, y1, x2, y2)
}
def doDrawing(g:Graphics) {
g match {
case g2d:Graphics2D =>
l foreach (_ match {
case c:Circle => doDrawCircle(c, g2d)
case l:Line => doDrawLine(l, g2d)
})
}
}
override def paintComponent(g:Graphics) {
super.paintComponent(g);
doDrawing(g);
}
}
val panel = new Surface2D()
panel.setPreferredSize(new Dimension(width, height))
add(panel);
setTitle("Shapes");
setResizable(false)
pack();
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
==Esercizio 27: disegno di un Mandala toroidale (grafica 2D)==
>>""

"">> Completare il metodo ##get## dell'object ##""ToroidalMandala""## seguente in modo che costruisca un modello 2D del Mandala toroidale a 24 "petali" mostrato in figura. La figura è creata utilizzando esclusivamente cerchi. La figura deve essere confinata nello spazio quadrato bidimensionale di lato unitario delimitato dall'origine degli assi fino al punto di coordinate (1,1). La figura viene poi scalata automaticamente dal modulo di visualizzazione per occupare la dimensione della finestra. Si ricordi che da Scala è possibile accedere a tutte le funzioni delle librerie Java (es. ##Math.sin##).
**Approfondimento.** I [[http://thes.bncf.firenze.sbn.it/termine.php?id=7159 Mandala]] sono dei disegni di grande suggestione che rivestono un significato spirituale e rituale sia nel Buddhismo che nell'Hinduismo. Il Mandala (dal sanscrito maṇḍala (मण्डल), tradotto come "cerchio") rappresenta, secondo i buddhisti, il processo mediante il quale il cosmo si è formato dal suo centro. Attraverso un articolato simbolismo, il Mandala consente una sorta di viaggio iniziatico che permette di crescere interiormente.
Usare il seguente programma di prova e le classe ##Shape## e ##""Frame2D""## dell'esercizio 26.
%%(java;Model2D.scala)
object Model2D {
def getToroidalMandala(petals:Int) = {
// completare costruzione di un modello 2D di un Mandala toroidale
List(new Circle(0.5, 0.5, 0.5))
}
def main(args:Array[String]) {
println("Displaying Toroidal Mandala...")
Frame2D.display(Model2D.getToroidalMandala(24), 500, 500)
}
==Esercizio 28: creazione di un modello 2D basato su linee==
>>""

"">> Aggiungere un metodo ##getLinesModel(x:Int)## all'object ##""Model2D""## dell'Esercizio 26 in modo che costruisca il modello 2D mostrato in figura in cui da ogni lato partono ##x## segmenti di linea (l'esempio in figura è stato generato con x=40), e modificare il metodo ##main## in modo che lo visualizzi. La figura deve essere confinata nello spazio quadrato bidimensionale di lato unitario delimitato dall'origine degli assi fino al punto di coordinate (1,1). La figura viene poi scalata automaticamente dal modulo di visualizzazione per occupare la dimensione della finestra. L'origine degli assi è nell'angolo inferiore sinistro della finestra.
**Nota bene:** La soluzione non deve usare alcuna variabile ##var## né il costrutto ##while##.

Revision [794]

Edited on 2017-10-13 12:21:39 by CamilDemetrescu

Additions:

==Esercizio 14: funzione ##map## su liste (alla vaccinara)==
Scrivere una funzione Scala **ricorsiva** ##mymap## che, data una lista e una funzione, si comporta come la ##map## predefinita delle liste. Esempio di uso:
println(mymap(l, _+1)) // stampa 4,2,3,5,6

Deletions:

==Esercizio 14: funzione ##filter## su liste (alla vaccinara)==
Scrivere una funzione Scala **ricorsiva** ##filter## che, data una lista e un predicato booleano, si comporta come la ##filter## predefinita delle liste. Esempio di uso:
println(filter(l, _>2)) // stampa 3,4,5

Revision [793]

Edited on 2017-10-13 12:09:04 by CamilDemetrescu

Additions:

==Esercizio 7: funzioni parzialmente applicate==
==Esercizio 8: test di primalità==
==Esercizio 9: numeri di Fibonacci==
==Esercizio 10: uguaglianza parziale di funzioni==
==Esercizio 11: costruzione di funzioni per casi==
==Esercizio 12: uso di map e reduce su liste ==
==Esercizio 13: funzione ##equal## su liste (alla vaccinara)==
==Esercizio 14: funzione ##filter## su liste (alla vaccinara)==
==Esercizio 15: minimo e massimo di una lista==
==Esercizio 16: processamento dati di un sensore==
==Esercizio 17: verifica se una lista di interi contiene duplicati==
==Esercizio 18: numero elementi inferiori==
==Esercizio 19: ricerca di un elemento in una lista==
==Esercizio 20: rimozione duplicati==
==Esercizio 21: unione di liste==
==Esercizio 22: intersezione di liste==

Deletions:

==Esercizio 8: funzioni parzialmente applicate==
==Esercizio 9: test di primalità==
==Esercizio 10: numeri di Fibonacci==
==Esercizio 11: uguaglianza parziale di funzioni==
==Esercizio 12: costruzione di funzioni per casi==
==Esercizio 13: uso di map e reduce su liste ==
==Esercizio 14: funzione ##equal## su liste (alla vaccinara)==
==Esercizio 15: funzione ##filter## su liste (alla vaccinara)==
==Esercizio 16: minimo e massimo di una lista==
==Esercizio 17: processamento dati di un sensore==
==Esercizio 18: verifica se una lista di interi contiene duplicati==
==Esercizio 19: numero elementi inferiori==
==Esercizio 20: ricerca di un elemento in una lista==
==Esercizio 21: rimozione duplicati==
==Esercizio 22: unione di liste==
==Esercizio 23: intersezione di liste==

Revision [792]

Edited on 2017-10-13 12:07:50 by CamilDemetrescu

Additions:

==Esercizio 8: funzioni parzialmente applicate==
Si consideri il seguente metodo parzialmente applicato:
def f(a:Int)(b:Int)(c:Int) = a+b+c
~1) ##f(1)(2)(3)##
~1) ##f(1)(2) _##
~1) ##f(1) _##
~1) ##f _##
==Esercizio 9: test di primalità==
Scrivere una funzione Scala che verifica se un numero è primo.
==Esercizio 10: numeri di Fibonacci==
Scrivere una funzione Scala che calcola l'n-esimo numero di Fibonacci F(n), dove F(1)=1, F(2)=1, F(3)=2, F(4)=3, F(5)=5, ecc.
==Esercizio 11: uguaglianza parziale di funzioni==
Scrivere una funzione Scala che, date due funzioni ##f1:Int=>Int## e ##f2:Int=>Int## e un intero ##n##, verifica che ##f1## e ##f2## calcolino lo stesso valore su ogni input compreso tra ##0## e ##n##. La funzione deve restituire un ##Boolean##.
==Esercizio 12: costruzione di funzioni per casi==
Scrivere una funzione Scala ##concatena## che, date tre funzioni ##f1:Double=>Double##, ##f2:Double=>Double## e ##f3:Double=>Double## e due valori ##Double## ##a## e ##b## con ##a##<=##b##, restituisce una funzione che coincide con ##f1## per tutti gli argomenti prima di ##a##, con ##f2## nell'intervallo ##[a,b]##, e con ##f3## dopo b.
==Esercizio 13: uso di map e reduce su liste ==
Scrivere un metodo ##max## che, data una lista di stringhe, restituisce la lunghezza della stringa più lunga.
~& Suggerimento: usare ##map## e ##reduce##
==Esercizio 14: funzione ##equal## su liste (alla vaccinara)==
Scrivere una funzione Scala **ricorsiva** ##equal## che verifica se due liste di interi sono uguali (uguaglianza profonda).
~& Suggerimento: usare ##head##, ##tail## e ##isEmpty##
==Esercizio 15: funzione ##filter## su liste (alla vaccinara)==
Scrivere una funzione Scala **ricorsiva** ##filter## che, data una lista e un predicato booleano, si comporta come la ##filter## predefinita delle liste. Esempio di uso:
val l = List(3,1,2,4,5)
println(filter(l, _>2)) // stampa 3,4,5
==Esercizio 16: minimo e massimo di una lista==
Scrivere una funzione Scala **ricorsiva** ##minMax## che, data una lista **non vuota** di interi, restituisce una coppia ##(min,max)##, dove ##min## e ##max## sono il minimo e il massimo elemento della lista, rispettivamente. Nota: data una coppia ##t=(a,b)##, ##t._1## è il primo elemento, ##t._2## è il secondo elemento.
Scrivere inoltre una variante **non ricorsiva** basata sui metodi standard della classe ##List## visti a lezione.
==Esercizio 17: processamento dati di un sensore==
Un sensore misura il numero di veicoli che passano in un tratto stradale in ogni minuto, producendo una lista di interi. Occasionalmente, il sensore smette di funzionare e richiede manutenzione. Quando il sensore smette di funzionare, produce un intero negativo e da quel momento in poi i numeri prodotti sono inattendibili.
Scrivere un metodo ##mediaVeicoli(l:List[Int]):Double## che calcola il numero medio di veicoli al minuto, ignorando tutti i valori a partire dal primo negativo. Il metodo deve essere realizzato in uno stile funzionale utilizzando i metodi di ordine superiore delle liste (e non iterazione o ricorsione).
~& **Suggerimento:** usare il metodo ##span## delle liste come documentato in [[http://www.scala-lang.org/api/current/#scala.collection.immutable.List]]. Per il cast a double, usare il metodo ##toDouble##.
==Esercizio 18: verifica se una lista di interi contiene duplicati==
Scrivere un metodo ##allDistinct[T](l:List[T]):Boolean## che restituisce ##true## se e solo se la lista di interi non contiene duplicati. Per motivi prestazionali, è possibile assumere che il dominio degli elementi sia totalmente ordinato e scrivere ##allDistinct[T<%Ordered[T]](l:List[T]):Boolean##
~& **Suggerimento:** usare i metodi ##sorted## e ##sliding## delle liste come documentato in [[http://www.scala-lang.org/api/current/#scala.collection.immutable.List]].
==Esercizio 19: numero elementi inferiori==
Scrivere un metodo ##inferiori(l:List[Int]):List[(Int,Int)]## che, data una lista di interi, restituisce una lista di coppie contenente gli elementi distinti della lista e il corrispondente numero di elementi più piccoli.
Esempio:
println(inferiori(List(1,3,1,2,2,1))) // deve restituire List((1,0), (2,3), (3,5))
==Esercizio 20: ricerca di un elemento in una lista==
Scrivere una funzione generica ##find[T](x:T, l:List[T]):Boolean## che, dato un elemento ##x##, verifica se è presente nella lista ##l##. Usare il costrutto ##match## e non ##if ... else##.
==Esercizio 21: rimozione duplicati==
Scrivere una funzione generica ##removeDuplicates[T](l:List[T]):List[T]## che crea una nuova lista ottenuta da ##l## rimuovendo gli elementi duplicati.
==Esercizio 22: unione di liste==
Scrivere una funzione generica ##union[T](l1:List[T], l2:List[T]):List[T]## che costruisce l'unione di due liste. La lista restituita non deve contenere duplicati.
==Esercizio 23: intersezione di liste==
Scrivere una funzione generica ##intersection[T](l1:List[T], l2:List[T]):List[T]## che costruisce l'intersezione di due liste. La lista restituita non deve contenere duplicati.

Revision [769]

Edited on 2017-10-08 16:45:47 by CamilDemetrescu

Additions:

Si scriva una funzione Scala ##mcd## che calcola il massimo comun divisore (MCD) di due numeri interi. Usare la seguente definizione ricorsiva:
Si scriva una funzione Scala ricorsiva ##sumOfSquares## che, dati due interi x e y con x<=y, calcola la somma dei quadrati dei numeri da x a y, compresi.
Un semplice metodo iterativo basato sul metodo di Newton per calcolare la radice quadrata di un numero x consiste nel partire da una stima iniziale y (es. y=1) e raffinarla successivamente calcolando la media tra y e x/y. Il procedimento termina quando il quadrato della stima è sufficientemente vicino a x. Completare la seguente definizione usando un approccio ricorsivo:

Deletions:

Si scriva una funzione Scala che calcola il massimo comun divisore (MCD) di due numeri interi. Usare la seguente definizione ricorsiva:
Si scriva una funzione Scala ricorsiva che, dati due interi x e y con x<=y, calcola la somma dei quadrati dei numeri da x a y, compresi.
Un semplice metodo iterativo basato sul metodo di Newton per calcolare la radice quadrata di un numero x consiste nel partire da una stima iniziale y (es. y=1) e raffinarla successivamente calcolando la media tra y e x/y. Il procedimento termina quando il quadrato della stima è sufficientemente vicino a x. Completare la seguente definizione usando la ricorsione:

Revision [768]

Edited on 2017-10-08 16:44:50 by CamilDemetrescu

Additions:

~& Suggerimento: scomporre **sempre** un problema in funzioni più semplici. Questo non peggiora in pratica le prestazioni poiché il compilatore effettua inlining automaticamente, ma migliora molto la leggibilità, l'analisi di correttezza e la manutenibilità del codice. Definire funzioni annidate (es. per il calcolo del valore assoluto, ecc.).

Deletions:

Revision [767]

Edited on 2017-10-08 16:44:14 by CamilDemetrescu

Additions:

Un semplice metodo iterativo basato sul metodo di Newton per calcolare la radice quadrata di un numero x consiste nel partire da una stima iniziale y (es. y=1) e raffinarla successivamente calcolando la media tra y e x/y. Il procedimento termina quando il quadrato della stima è sufficientemente vicino a x. Completare la seguente definizione usando la ricorsione:
~& Suggerimento: scomporre **sempre** un problema in funzioni più semplici. Questo non peggiora in pratica le prestazioni poiché il compilatore effettua inlining automaticamente, ma migliora molto la leggibilità, l'analisi di correttezza e la manutenibilità del codice.

Deletions:

~~Un semplice metodo iterativo basato sul metodo di Newton per calcolare la radice quadrata di un numero x consiste nel partire da~~