Para entender la recursividad primero tenemos que entender la recursividad

Transcripción

1 Para entender la recursividad primero tenemos que entender la recursividad Funcional Clase 1 Matias Reparaz, Agustín Nieto Departamento de Computación, FCEyN,Universidad de Buenos Aires. 20 de Septiembre

2 Funcional - Matemática Menú de esta tarde Vamos a hacer una introducción a la sintaxis de Haskell y a como hacer nuestros propios tipos de datos. Vamos a mostrar el Hugs. Vamos a implementar funciones recursivas simples sobre tipos y listas.

3 Funcional - Matemática Paralelismo Funcional - Matemática En matemática... func1 : Z Z 6 si x == 1 func1(x) = x + 2 si x == 5 ó x == 6 0 si x == 8 En funcional... Una forma: func1 :: Int -> Int func1 1 = 6 func1 5 = 7 func1 6 = 8 func1 8 = 0

4 Funcional - Matemática Paralelismo Funcional - Matemática En matemática... func1 : Z Z 6 si x == 1 func1(x) = x + 2 si x == 5 ó x == 6 0 si x == 8 En funcional... Otra forma: func1 :: Int -> Int func1 x (x==1) = 6 (x==5 x==6) = x + 2 (x==8) = 0

5 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Un poco de sintaxis Cada expresión que define el comportamiento de una función se denomina ecuación. Cada función puede tener más de una ecuación. Una función puede recibir muchos parámetros, pero solo devolver uno ( es una función!) a esto se le llama aridad. No es necesario indicarle a Haskell el tipo de parámetros, pero nosotros lo vamos a hacer siempre. Por Ej.: multiplicar :: Int -> Int -> Int multiplicar x y = x * y prm :: (Int,Int) -> Int prm (a,b) = a

6 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Un poco de sintaxis (Cont.) El nombre de las funciones empieza con letra minúscula y los tipos de datos con mayúscula. Cuando la forma de calcular el resultado depende de algún predicado (con respecto a los parámetros), solemos usar guardas... func :: Param1 -> Param2 ->... -> ParamN -> Res func p1 p2... pn (p1 > p2) =... (p1 < p2) =... otherwise =...

7 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Un poco de sintaxis (Cont.) Se analizan de arriba hacia abajo y cuando una de las condiciones se satisface, se determina qué ecuación debe utilizarse. Si no hay guarda que se haga verdadera, la expresión que se trata de evaluar se indefine. otherwise se utiliza para indicar que, si no se cumple la condición de ninguna de las guardas anteriores, se debe ingresar en esa guarda.

8 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Pattern matching Cuando la forma de calcular el resultado depende de que es el parámetro, solemos usar pattern matching... algunoescero :: Int -> Int -> Bool algunoescero 0 _ = True algunoescero _ 0 = True algunoescero = False

9 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Tipos en Haskell, vienen gratis con el preludio Int (==,/=,>,<,+,-,*,mod,rem,div) Integer (más grande) Float (==,/=,>,<,+,-,*,/) Bool (==,/=,not,&&,,true,false) Char (==,/=,>,<) También podemos usar listas de cualquiera de estos tipos.

10 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Funciones parciales y totales Una función se dice total si, para cualquier instancia de parámetros, es capaz de indicar un resultado. doble :: Int -> Int doble x = x + x En caso contrario se dice que la función es parcial. chartoint :: Char -> Int chartoint x (x== a ) = 0 (x== b ) = 1 (x== c ) = 2

11 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Evaluación y reducción de una expresión Una vez que se definen las funciones uno puede querer saber cuánto vale, por ejemplo: doble 2 Para obtener el resultado se procede a reducir la expresión. Esto se hace reemplazando el nombre de la función y sus parámetros según la ecuación que corresponda. Si no se encuentra ecuación alguna, la evaluación se indefine. doble Forma de evaluar una expresión: siempre se hace desde la función más externa que aparece y los parámetros de izquierda a derecha. Por ejemplo con doble (doble 5) tenemos la siguiente reducción.

12 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Evaluación y reducción de una expresión doble (doble 5) (doble 5) + (doble 5) (5 + 5) + (doble 5) 10 + (doble 5) 10 + (5 + 5)

13 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Ejercicios Implementar la función suma que satisface la siguiente especificación. problema suma (x, y:z) = result : Z { asegura result == x + y ; } suma :: Int -> Int -> Int suma x y = x + y

14 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Implementar la función espar que satisface la siguiente especificación. problema espar (n:z) = result : Bool { asegura res == (n mod 2 == 0) ; } espar :: Int -> Bool espar x = (mod x 2) == 0 La función mod se puede usar en notación infija con el uso de acento francés. Esto se puede hacer con todas las funciones binarias (las que tienen dos parámetros). espar :: Int -> Bool espar x = (x mod 2) == 0

15 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Bueno, ahora a implementar nuestros tipos A lo largo de la materia aprenderemos cómo hacer nuestros propios tipos de datos. En esta ocasión veremos los tipos enumerados. Para estos se debe declarar cuáles son los valores posibles del tipo. Esto se hace de la siguiente forma: data NombreTipo = Valor1 Valor2... ValorN Cuando uno declara un tipo enumerado es importante notar que no hay ninguna función definida para este. Ni siquiera ==. Por tal motivo las funciones que utilicen como entrada valores de este tipo van a tener, por lo general, una ecuación por cada valor del tipo.

16 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Como ejemplo definiremos el tipo DiaSemana, que representa los dias de la semana, y algunas funciones que lo utilizan. data DiaSemana = Lunes Martes Miercoles Jueves Viernes Sabado Domingo cursoalgo1 :: DiaSemana -> Bool cursoalgo1 Lunes = True cursoalgo1 Miercoles = True cursoalgo1 Viernes = True cursoalgo1 _ = False Si quisieramos definir esta función utilizando el ==, necesitamos definir la igualdad. Podemos construirla nosotros, o podemos usar la igualdad que Haskell provee por defecto. Para hacer esto último, debemos agregar deriving Eq a la definición del tipo

17 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs data DiaSemana = Lunes Martes Miercoles Jueves Viernes Sabado Domingo deriving (Eq) cursoalgo1 :: DiaSemana -> Bool cursoalgo1 d (d == Lunes d == Miercoles d == Viernes ) = True otherwise = False cursoalgo1 :: DiaSemana -> Bool cursoalgo1 d = (d == Lunes d == Miercoles d == Viernes )

18 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs De la misma forma que se puede utilizar la igualdad provista por Haskell podemos hacer lo mismo con la relación de orden (Ord). También vamos a necesitar que Haskell muestre por pantalla estos tipos. Para eso, utilizamos Show. data DiaSemana = Lunes Martes Miercoles Jueves Viernes Sabado Domingo deriving (Ord, Eq, Show) Cuándo es la próxima clase de algo1? proximaclase :: DiaSemana -> DiaSemana proximaclase d d <= Lunes = Lunes d <= Miercoles = Miercoles d <= Viernes = Viernes otherwise = Lunes

19 Sintaxis Tipos Funciones parciales y totales Reducciones Tipos Enumerados Hugs Hugs Es un programa que entiende Haskell, no es el único pero es el que vamos a usar en la materia. Los que usan Window$ se lo pueden bajar de la página. Los que usan GNU/Linux usen su gestor de paquetes favorito. Los que usan Mac OS X (no nos olvidamos de ustedes =) ) tienen que instalarse las macports. Cualquier cosa google. Ahora vamos a mostrar como se usa.

20 Funciones Recursivas La definición de una función también puede ser recursiva. Esto quiere decir que alguna ecuación de la función necesita evaluar la misma función (pero para otra instancia). La idea es pensar que la función que definimos sabe resolver el problema para una instancia más chica de la entrada. De esa forma puedo usarlo para resolver una instancia más grande. No hay que olvidarse el (o los) caso base, piensen cual es la instancia mas chica de la entrada que va a aceptar su función. Por ejemplo, para hacer un programa que compute n! tenemos la siguiente posibilidad.

21 problema factorial (n: Z) = result : Z { requiere n 0 ; asegura result == [1..n] ; } factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

22 Qué pasa cuando hacemos recursión? factorial(3) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

23 Qué pasa cuando hacemos recursión? factorial(3) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

24 Qué pasa cuando hacemos recursión? 3 * (factorial (2)) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

25 Qué pasa cuando hacemos recursión? 3 * (factorial (2)) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

26 Qué pasa cuando hacemos recursión? 3 * (2 * factorial(1)) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

27 Qué pasa cuando hacemos recursión? 3 * (2 * factorial(1)) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

28 Qué pasa cuando hacemos recursión? 3 * (2 * (1 * factorial (0))) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

29 Qué pasa cuando hacemos recursión? 3 * (2 * (1 * factorial (0))) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

30 Qué pasa cuando hacemos recursión? 3 * (2 * (1 * 1)) - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

31 Qué pasa cuando hacemos recursión? 6 - Programa factorial :: Int -> Int factorial n n == 0 = 1 n > 0 = n * (factorial (n-1))

32 Para que la función pueda calcular el resultado de una instancia dada es necesario que el caso recursivo vaya acercando el problema hacia el caso base. En este ejemplo es claro que para calcular factorial n, con n >= 0, en algún momento se llegará a necesitar factorial 0 y el programa va a terminar de forma correcta. Bueno, ahora hagamos de nuevo espar con lo que sabemos.

33 problema espar (n:z) = result : Bool { asegura res == (n mod 2 == 0) ; } espar :: Int -> Bool espar n n == 0 = True (abs n) == 1 = False (abs n) >= 2 = espar( (abs n) -2) Otra opción espar :: Int -> Bool espar 0 = True espar n = not (espar ( (abs n) -1)) El aux abs les queda de ejercicio ;)

34 EL ejemplo clásico de recursividad Implementar una función que dado un natural n, calcule el n-ésimo número de Fibonacci. fibonacci :: Int -> Int fibonacci n n == 0 = 1 n == 1 = 1 n >= 2 = (fibonacci (n-1)) + (fibonacci (n-2))

35 En algunos casos es necesario definir una función auxiliar para resolver un problema. En el caso de factorial no era necesario saber qué instancia del problema se está tratando de resolver para el usuario. Cuando sí es necesario, se suele recurrir a una función auxiliar recursiva en donde algunos parámetros representan el problema que se trata de resolver.

36 Escribir una función que dado un número natural distinto de cero, diga si es primo o no. problema esprimo (n: Z) = result : Bool { requiere n > 0 ; asegura result == (n 1) ( d [2..n))(n mod d 0) ; } esprimo :: Int -> Bool esprimo n n == 1 = False n >= 2 = not (haydivisorhasta (n-1) n) haydivisorhasta :: Int -> Int -> Bool haydivisorhasta i n i == 1 = False n mod i == 0 = True otherwise = haydivisorhasta (i-1) n

37 Escribir una función que dado un número natural distinto de cero, nos devuelva la suma de sus divisores. problema sumadivisores (n: Z) = result : Z { requiere n > 0 ; asegura result == [d d [1..n], n mod d == 0] ; } sumadivisores :: Int -> Int sumadivisores n = sumadivisoreshasta n n sumadivisoreshasta :: Int -> Int -> Int sumadivisoreshasta h n h == 1 = 1 h > 1 && n mod h == 0 = h + (sumadivisoreshasta (h-1) n) otherwise = sumadivisoreshasta (h-1) n

38 Pattern Matching con Listas Dada una lista de caracteres... Exijo la cabeza de esa lista! cabeza:: [Char] -> Char cabeza [] = error"no pierdas la cabeza" cabeza (x:xs) = x Y si lo hacemos con una lista de tipo paramétrico? cabeza:: [a] -> a

39 Dada una lista... quiero averiguar su longitud. longitud:: [a] -> Int longitud [] = 0 longitud (x:xs) = 1 + longitud xs

40 Dada una lista de enteros... quiero averiguar su máximo. maximo:: Int -> [Int] -> Int maximo [] = error"no hay maximo" maximo [x] = x maximo (x:xs) x < maximo xs = maximo xs x >= maximo xs = x

41 Cómo es que esta cosa funciona? max [2,3,1] (2 < max[3, 1]) max [3,1] (3 < 1) FALSE (3 >= max[1]) max [1] 1 Caso Base max [1] = 1

42 Cómo es que esta cosa funciona? max [2,3,1] (2 < max[3, 1]) max [3,1] (3 < 1) FALSE (3 >= 1) TRUE max [3,1] = 3

43 Cómo es que esta cosa funciona? max [2,3,1] (2 < 3) TRUE max[2,3,1] = max [3,1] max [3,1] (3 < 1) FALSE (3 >= max[1]) max [1] 1 Caso Base max [1] = 1

44 Cómo es que esta cosa funciona? max [2,3,1] (2 < 3) TRUE max[2,3,1] = max [3,1] max [3,1] (3 < 1) FALSE (3 >= 1) TRUE max [3,1] = 3

45 Cómo es que esta cosa funciona? max [2,3,1] (2 < 3) TRUE max[2,3,1] = 3

46 Otras formas maximo [] = error"no hay maximo" maximo [x] = x maximo (x:xs) = if (x < maximo xs) then (maximo xs) else x maximo [] = error"no hay maximo" maximo [x] = x maximo (x:xs) x < max = max x >= max = x where max= maximo xs

47 Dada un entero... quiero conseguir una lista de sus divisores. divisores:: Int -> [Int] divisores n = divisoresdesde n 1 divisoresdesde:: Int -> Int -> [Int] divisoresdesde n m n == m = [n] n > m && (n mod m == 0) = m:(divisoresdesde n (m+1)) n > m && (n mod m /= 0) = divisoresdesde n (m+1)

48 Ahora, teniendo esta función... podemos hacer de otra forma sumadivisores? sumadivisores:: Int -> Int sumadivisores n = sumalista (divisores n) sumalista::[int] -> Int sumalista [] = 0 sumalista (x:xs) = x + sumalista xs

49 Notas importantes NUNCA pueden usar funciones del lado del Pattern Matching. Ej. FuncionAlocada :: Int -> Bool FuncionAlocada n-1 =... NO se pueden usar listas por comprensión para resolver los ejercicios.

50 Hacer cualquiera de estas cosas implica un NO APROBADO (Fatality), sin miramientos, en cualquier instancia de evaluación de Algo 1 (y el repudio por parte de todo el plantel docente). En los TP s también se evalua legibilidad y claridad al escribir código, esto va a quedar más claro en las siguientes clases.

51 Consultas?