;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PRACTICA-8.TXT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Abstracci\'on de procedimientos. Procedimientos como argumentos y valores.


Para facilitar el trabajo divide la pantalla en dos ventanas mediante
CTRL-X 2 y, en una de ellas,  crea un buffer para trabajar con el
int\'erprete, mediante ESC-X run-scheme ENTER. Utiliza CTRL-X O para
saltar de una a otra ventana, mientras haces los ejercicios.


|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
| NOTA: Recuerda que no es necesario teclear en el int\'erprete              |
| expresiones que ya aparezcan en este fichero. Para ello primero debes      |
| pasar a modo scheme, tecleando (con el cursor en este buffer)              |
| ESC-X scheme-mode ENTER. Luego, cada vez que quieras evaluar una expresi\'on |
| que ya est\'a escrita en este fichero, no tendr\'as que teclearla de nuevo |
| en el buffer del int\'erprete. Bastar\'a que coloques el cursor al         |
| principio de la expresi\'on y teclees CTRL-C CTRL-E.                       |
| Observar\'as que en la ventana de scheme aparece el valor de la            |
| expresi\'on.                                                               |
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
| NOTA: Recuerda tambi\'en que no es necesario escribir las expresiones      |
| pedidas  en el int\'erprete. Puedes escribirlas en este buffer debajo      |
| de cada apartado y evaluar lo que escribes con CTRL-C CTRL-E, viendo la    |
| respuesta en el buffer de Scheme. As\'i, podr\'as corregir fallos          |
| f\'acilmente y adem\'as al final de la clase, si grabas este fichero,      |
| tendr\'as los ejercicios resueltos, sin necesidad de anotar en papel       |
| las soluciones. Al usar CTRL-C CTRL-E recuerda que la expresi\'on que      |
| deseas evaluar debe comenzar con par\'entesis y el primero de ellos debe   |
| ocupar la PRIMERA COLUMNA DE LA IZQUIERDA.                                 |
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|



**************************************************************************
* EJERCICIO 1                                                            *
**************************************************************************

Eval\'ua las siguientes expresiones, razonando el resultado:

(map (lambda (x) (* x x)) '(1 2 3 4 5 6))                        ;;;(a)

(map pair? '((a.b) (1 2 3) 1 2 3))                               ;;;(b)

(let ((imprime (lambda (x) (display x) (newline) (string-length x)))) 
  (for-each imprime '("Lista" "de" "strings")))                  ;;;(c)

(let ((imprime (lambda (x) (display x) (newline) (string-length x))))
  (map imprime '("Lista" "de" "strings")))                       ;;;(d)

(define aplica-a-dos                                             ;;;(e)
  (lambda (f) (f 2)))

(aplica-a-dos sqrt)						 ;;;(f)

(aplica-a-dos (lambda (x) (* x x)))				 ;;;(g)

(aplica-a-dos even?)						 ;;;(h)

(map aplica-a-dos (list  sin    (lambda (x) (expt x 3))   odd?)) ;;;(i)

(define tonta                                                    ;;;(j)
  (lambda (f)
    (lambda (x) (f x))))

((tonta sqrt) 2)                                                 ;;;(k)

(apply + '(1 2))						 ;;;(l)

(apply (lambda (x y z) (list z y x)) '(a b c))			 ;;;(m)



***************************************************************************
* EJERCICIO 2                                                             *
***************************************************************************

(1) Define un procedimiento a-cada, que reciba como entrada una funci\'on
f de un argumento, y devuelva como resultado la funci\'on que recibiendo
una lista l como entrada, devuelve la lista de los resultados de aplicar
f a cada elemento de l. 

Define, USANDO el procedimiento a-cada, un procedimiento cuad-list que
calcula la lista de los cuadrados de una lista dada.

Por ejemplo:

((a-cada sqrt) '(4 9 16 25 36)) ==> (2.0 3.0 4.0 5.0 6.0)
((a-cada (lambda (x) (cons x 'hola))) '(1 2 3 4)) ==>
              ((1 . hola) (2 . hola) (3 . hola) (4 . hola))
(cuad-list '(4 2 7 3 3)) ==> (16 4 49 9 9)
 



(2) Define un procedimiento filtra, que reciba como entrada un predicado p
de un argumento, y devuelva como resultado la funci\'on que recibiendo
una lista l como entrada, devuelve la lista de los elementos de l que
verifican p.

Define, USANDO el procedimiento filtra, una funci\'on lista-simb que
calcula la lista de los s\'imbolos de una lista dada.

Por ejemplo:

((filtra even?) '(1 2 3 4 5 6 7 8 9)) ==> (2 4 6 8) 
((filtra (lambda (x) (< x 5))) '(1 9 2 8 3 7 4 6 5)) ==> (1 2 3 4)
(lista-simb '(1 hse iacs #f ccia)) ==> (hse iacs ccia)



(3) Define un procedimiento compone, que recibiendo como entrada dos
funciones g y f devuelve la funci\'on g compuesta de f (es decir, la
funci\'on que para cada x devuelve g aplicado al valor resultante de
aplicar f a x).

Define, USANDO compone, filtra y a-cada, un procedimiento
el-primero-de-cada que recibiendo como entrada una lista de listas
devuelve el primer elemento de cada una de las sublistas, ignorando las
sublistas vac\'ias.

Ejemplos:

((compone sin asin) 0.5) ==> 0.5
((compone asin sin) 3) ==> 0.141592653589793
(el-primero-de-cada '((1 2 3) () (a b c) pepe)) ==> (1 a)




***************************************************************************
* EJERCICIO 3                                                             *
***************************************************************************

Define un procedimiento iterativo repite-hasta que recibe como
argumentos una funci\'on f, un predicado p y un elemento x, y devuelve
el resultado de aplicar f a x hasta que se verifique el predicado p.

Ejemplos:

(repite-hasta (lambda (x) (> x 534.3)) (lambda (x) (+ x 1)) 1) ==> 535
(repite-hasta (lambda (l) (> (length l) 15)) (lambda (x) (cons 'a x)) ()) 
==> (a a a a a a a a a a a a a a a a)




***************************************************************************
* EJERCICIO 4                                                             *
***************************************************************************

Recuerda la definici\'on de la funci\'on raiz-seno (usando el m\'etodo de
b\'usqueda dicot\'omica) de la practica 5:

(define raiz-seno
  (lambda (r s)
    (cond
     ((= (sin r) 0) r)
     ((= (sin s) 0) s)
     ((> (* (sin r) (sin s)) 0)
      (error "raiz-seno: no se puede asegurar que haya raiz en el intervalo"))
     ((< (- s r) 0.001) (/ (+ r s) 2))
     ((>= (* (sin r) (sin (/ (+ r s) 2))) 0)
      (raiz-seno (/ (+ r s) 2) s))
     (else (raiz-seno r (/ (+ r s) 2))))))


Define ahora una funci\'on dicotomia que recibiendo como entrada una
funci\'on f (continua), un intervalo (dado por un par de n\'umeros
reales a y b), y un numero real epsilon, encuentra, usando el m\'etodo
de b\'usqueda dicot\'omica, una raiz de f en el intervalo [a,b] (siempre
que se pueda asegurar su existencia), con un error menor que epsilon.

Ejemplos:

(dicotomia sin 3 4 0.000000001) ==> 3.14159265393391
(dicotomia (lambda (x) (- (* x x) 2)) 1 2 0.000000001) ==> 1.41421356191859
(dicotomia (lambda (x) (- (log x) 1)) 2 3 0.000000001) ==> 2.71828182833269
(dicotomia sin 3.5 4 0.0001) ==> 
          ERROR: dicotomia: no se puede asegurar la existencia de raiz
(dicotomia sqrt 4 3 0.0001) ==> ERROR: dicotomia: el intervalo es incorrecto
(dicotomia (lambda (x) x) 0 4 0.1) ==> 0.03125






***************************************************************************
* EJERCICIO 5                                                             *
***************************************************************************


Usa la funci\'on repite-hasta para definir una funci\'on
inserta-en-orden que recibiendo como entrada un n\'umero y una lista
ordenada de n\'umeros, obtiene la lista obtenida insertando el n\'umero
en la lista en la posici\'on que le corresponde en el orden.

Ejemplos:

(inserta-en-orden 7 '(2 4 8 9)) ==> (2 4 7 8 9)
(inserta-en-orden 5 ()) ==> (5)
(inserta-en-orden 10 '(2 4 6 8)) ==> (2 4 6 8 10)