4.

7 Operaciones sobre Ejemplos de Equivalencia

Objetos
en Scheme (eq? ‘a ‘a) ;=> #t
(eq? 3.1 3.1) ;=> ()
(eq? (cons ‘a ‘b)(cons ‘a ‘b)) ;=> ()
Equivalencias y predicados de
(eqv? ‘a ‘a) ;=> #t
tipos, listas, números, caracteres, (eqv? 3.1 3.1) ;=> #t
strings y vectores (eqv? (cons ‘a ‘b)(cons ‘a ‘b)) ;=> ()

(equal? ‘a ‘a) ;=> #t

(equal? 3.1 3.1) ;=> #t
(equal? (cons ‘a ‘b)(cons ‘a ‘b)) ;=> #t

a) Equivalencias b) Predicados de Tipos

l (eq? obj1 obj2) l (boolean? obj)
retorno: #t si son idénticos retorno: #t si obj #t o #f
l (eqv? obj1 obj2) l (null? obj)
retorno: #t si son equivalentes retorno: #t si obj #f o lista vacia
l (pair? obj)
l eqv? es similar a eq?, salvo que no es dependiente retorno: #t si obj es un par
de la implementación, pero es algo más costoso.
l eq? no permite comparar en forma fiable números

equal? Tipos de Números

l (number? obj)
l (equal? obj1 obj2) retorno: #t si obj es número
retorno: #t si tienen la misma l (complex? obj)
estructura y contenido retorno: #t si obj es número complejo
l equal? es similar a eqv?, salvo que se aplica l (real? obj)
retorno: #t si obj es número real
también para strings, pares y vectores.
l (rational? obj)
l Es más costoso que eqv? y eq?, retorno: #t si obj es número racional
l (integer? obj)
retorno: #t si obj es número entero

1
Otros Tipos Otros Operadores con Listas
l (char? obj)
l (list-ref list n)
retorno: #t si obj es un caracter
retorno: elemento #n (basado en 0) de
l (string? obj)
list
retorno: #t si obj es un string
l (list-tail list n)
l (vector? obj) retorno:el resto de list a partir de elemento
retorno: #t si obj es un vector #n
l (symbol? obj) l (append list ...)
retorno: #t si obj es un símbolo retorno: concatenación de list ...
l (procedure? obj) l (reverse list)
retorno: #t si obj es un procedimiento retorno: list en orden invertido

c) Listas Membresía en Listas

l El par es la estructura más fundamental de los tipos l (memq obj list)
de objetos retorno:el resto de list a partir de elemento
l Los pares normalmente se usan para construir listas obj si es encontrado, sino #f
l (memv obj list)
l Las listas son secuencias ordenadas donde cada retorno:el resto de list a partir de elemento
elemento ocupa el car de un par y el cdr del par obj si es encontrado, sino #f
del último elemento es la lista vacía. l (member obj list)
l Si no se cumple lo anterior, es una lista impropia retorno:el resto de list a partir de elemento
obj si es encontrado, sino #f
l Usan eq? y eqv? y equal? respectivamente

Operadores Básicos con Listas d) Listas Asociativos (Hash tables)

l (list obj ...)

retorno: una lista de elementos obj ...
l (list? obj)
retorno: #t si obj es una lista propia
l (length list)
retorno: el número de elementos de list
l Una lista asociativa (alist) es una lista
propia cuyos elementos son pares.
l Un par tiene la forma (clave . valor)
l Asociaciones son útiles para almacenar
información (valor) relacionada con un objeto
(clave)

2
Operadores con Listas Asociativos Operadores Aritméticos

l (assq obj alist) l (+ num ... )

retorno: primer elemento de alist cuyo car es
equivalente a obj, sino #f
l (assv obj alist)
retorno: primer elemento de alist cuyo car es
equivalente a obj, sino #f
l (assoc obj alist)
retorno: primer elemento de alist cuyo car es
equivalente a obj, sino #f
l Usan eq? y eqv? y equal? respectivamente
retorno: la suma de los argumentos num...
l (- num)
retorno: cambio de signo de num
l (- num1 num2 ...)
retorno: substracción a num1 de num2 ...
l (* num ... )
retorno: la multiplicación de num...
l (/ num)
retorno: recíproco multiplicativo de num
l (/ num1 num2 num3 ...)
retorno: la división de num1 por la multiplicación
de num2 ...

e) Números Predicados con Números

l Scheme soporta enteros, racionales, reales y
l (zero? num)
complejos (que definen una jerarquía) retorno: #t si num es cero
l Los números pueden ser exactos o inexactos l (positive? num)
l Enteros y racionales pueden soportan precisión retorno: #t si num es positivo
l (negative? num)
arbitraria
retorno: #t si num es negativo
l Números inexactos se representan en punto flotante l (even? num)
l Los complejos se representan como un par, usando retorno: #t si num es par
coordenadas polares o rectangulares l (odd? num)
retorno: #t si num es impar

Operadores con Números Operadores con Enteros

l (exact? num) l (quotient int1 int2)

retorno: #t si num es exacto
l (inexact? num)
retorno: #t si num es inexacto
l (= num1 num2 ...)
retorno: #t si los números son iguales
l (op real1 real2 ...)
retorno: #t si los números cumplen la
relación op, con op en {<, >, <=,>=}
(no está definido para complejos)
retorno: el cuociente de int 1 y int2
l (remainder int1 int2)
retorno: el residuo de int1 y int2
l (modulo int1 int2)
retorno: el módulo entero de int1 y int2
l (gcd int ...)
retorno: máximo común divisor de num…
l (lcm int ...)
retorno: mínimo común múltiplo de num...

3
Operadores con Reales Predicados de Caracteres

l (truncate real) l (char=? char1 char2 ...)

retorno: truncar a entero hacia cero
l (round real)
retorno: rondear a entero más cercano
l (abs real)
retorno: valor absoluto
l (max real ...)
retorno: máximo de real ...
l (min real ...)
retorno: mínimo de real ...
l (char<? char1 char2 ...)
l (char>? char1 char2 ...)
l (char<=? char1 char2 ...)
l (char>=? char1 char2 ...)
retorno: #t si relación es verdadera,
sino #f
l Relaciones son sensibles a mayúsculas
l Operadores char-ci@? son insensibles

Funciones Matemáticas Otros Operadores con Caracteres

l (sqrt num) l (char -alphabetic? char )

retorno: raíz cuadrada de num
l (exp num )
retorno: e elevado a la potencia de num
l (log num )
retorno: el logaritmo natural de num
l (sin num )
retorno: el seno de num
l (cos num )
retorno: el coseno de num
l (tan num )
retorno: la tangente de num
retorno: # t si char es letra
l (char -number ? char)
retorno: # t si char es número
l (char -lower- case? letter )
retorno: # t si char es letra minúscula
l (char -upper- case? letter )
retorno: # t si char es letra mayúscula
l (char ->integer char)
retorno: código del carácter char
l (integer -> char int)
retorno: carácter con código int

f) Caracteres g) Strings
l Representan objetos atómicos (letras, l Representan cadenas o secuencias de caracteres
números, caracteres especiales) l Se emplean en mensajes o buffers de caracteres
l Se escriben con el prefijo #\ l Se escriben entre citación doble; doble citación se
introduce en el texto con \”
l Ejemplos:
l Se indexan con base en 0
#\a carácter ‘a’
#\newline cambio de línea l Ejemplo:
“Hola”
#\space espacio en blanco
“\”Ohhh\””

4
Predicados de Strings Operadores con Vectores

l (string=? string1 string2 ...) l (vector obj ...)

l (string<? string1 string2 ...) retorno: un vector con objetos obj ...
l (string>? string1 string2 ...) l (make-vector n)
l (string<=? string 1 string2 ...) retorno: un vector de largo n
l (string>=? string 1 string2 ...) l (vector-length vector)
retorno: #t si relación es verdadera, retorno: largo de vector
sino #f l (vector-ref vector n)
retorno: el elemento n de vector
l Relaciones son sensibles a mayúsculas
l Operadores string-ci@? son insensibles

Otros Operadores con Strings

Más Operadores con Vectores
l (string char ...)
retorno: un string que contiene char ...
l (vector-set! vector n obj)
l (make -string n)
retorno: un string de n caracteres (indefinido) acción: define elmto n de vector como obj
l (string- length string) l (vector-fill! vector obj)
retorno: largo del string acción: reemplaza cada elemento de vector
l (string- ref string n ) con obj
retorno: el carácter n (desde 0) del string l (vector->list vector)
l (string- set! string n char) retorno: una lista con elementos de vector
acción: cambia el carácter n de string a char l (list->vector list)
l (string- copy string) retorno: una vector con elementos de lista
retorno: una copia de string
list
l (string- append string ...)
retorno: concatenación de string ...

h) Vectores 4.8 Operaciones de

Entrada y Salida en
l Forma más conveniente y eficiente de listas en
algunas aplicaciones Scheme
l A diferencia de listas, el acceso a un elemento
se hace en tiempo constante
l Al igual que strings, se referencian con base 0
l Elementos pueden ser de cualquier tipo
l Se escriben como lista, pero precedidos por #
l Ejemplo:
#(a b c)

5
Entrada y Salida Ejemplos de Entrada
l Toda E/S se realiza por puertos.
l Un puertos es un puntero a un flujo (posiblemente (input-port? ‘(a b c)) => unspecified
infinito) de caracteres (e.g. archivo) (input-port? (current-input-port)) => #t
(input-port? (open-input-file “f.dat”)) => #t
l Un puerto es un objeto de primera clase
l El sistema tiene dos puertos por defecto: entrada y (let ((p (open-input-file “mi_archivo”)))
salida estándar (normalmente es el terminal en un (let leer ((x (read p)))
(if (eof-object? x)
ambiente interactivo)
(begin
l Cuando se agotan los datos de entrada se retorna (close-input-port p)
el objeto especial eof ‘())
(cons x (leer (read x))))))

Operaciones de Entrada (1/2) Otro Ejemplo de Entrada

(define read-word
l (input-port? obj) (lambda (p)
retorno: # t si obj es puerto de entrada
(list->string
l (current -input- port) (let leer_entrada ()
retorno: puerto de entrada actual (let ((c (peek-char p)))
l (open -input- file filename) (cond
retorno: nuevo puerto de entrada asociado a ((eof-object? c) '())
archivo filename ((char-alphabetic ? c)
l (call -with -input- file file proc ) (read-char p)
acción: abre file y llama a proc con puerto (cons c (leer_entrada )))
abierto como parámetro; luego cierra puerto (else '())))))))
retorno: valor de evaluación de proc ;=> read-word
l (close-input -port input- port)
acción: cierra puerto de entrada (read-word (current-input-port))
hola
;=> "hola"

Operaciones de Entrada (2/2) Operaciones de Salida (1/2)

l (output- port ? obj )
l (eof- object? obj) retorno: # t si obj es puerto de salida
retorno: # t si obj es fin de archivo l (current -output -port )
l (read ) retorno: puerto de salida actual
(read input- port) l (open -output -file file )
retorno: próximo objeto de input-port retorno: nueva puerto de salida asociado a archivo
file
l (read -char )
l (call -with -output -file file proc)
(read -char input- port)
acción: abre file y llama a proc con puerto abierto
retorno: próximo carácter de input -port como parámetro; luego cierra puerto
(con consumo) retorno: valor de evaluación de proc
l (peek -char ) l (close-output-port output-port)
(peek -char input- port) acción: cierra puerto de salida
retorno: próximo carácter de input -port
(sin consumo)

6
Operaciones de Salida (2/2) Operaciones Especiales de E/S
l (write obj )
(write obj output -port ) l (transcript-on file)
acción: escribe obj a output- port acción: inicia registro en file la sesión
l (display obj ) interactiva de Scheme
(display obj output- port ) l (transcript-off)
acción: escribe obj a output- port acción: termina de registrar sesión
l (write-char char)
l (load file)
(write-char char output- port)
acción: carga file leyendo y evaluando
acción: escribe char a output -port
secuencialmente las expresiones contenidas.
l (newline )
(newline output -port )
acción: escribe nueva línea a output -port

Observaciones a E/S
l write escribe objetos que luego pueden ser leídos
con read
l Strings se escriben con citación doble
l Un carácter se escribe con prefijo #\
l display se usa normalmente para escribir objetos
que no serán leídos
l Strings y caracteres no escriben doble citación o #\
l write-char y read-char escriben y leen un
único carácter sin usar #\

Ejemplo de E/S

(define copy- file

(lambda (infile outfile)
(call-with-input-file infile
(lambda (iport)
(call-with-output-file outfile
(lambda (oport)
(do ((c (read -char iport )
(read-char iport)))
((eof-object? c))
(write-char c oport))))))))
;=> copy -file

(copy-file “infile” “outfile”)

;=> #t