;; Ejercicio 3.2.1.

rkt

#|

Problema: calcular el área de un rectángulo dados su

ancho y altura.

A fin de diseñar la función que lo resuelva

escribir:

1) la definición de datos

2) la firma, el propósito, y el encabezamiento

3) ilustrar la firma y el propósito con ejemplos

4) tomar el inventario, o sea escribir el formato

5) escribir el código

6) probar la función con los ejemplos.

Verificando:

a) que el nombre de la función coincida con los del encabezamiento

y los del formato

b) que coincida el número de parámetros del encabezamiento con el

de los parámetros del formato, con el de los de la función, y con
el de los argumentos de los ejemplos

c) que coincidan los tipos de datos de la firma con los de los

ejemplos

d) que coincida el tipo de datos de lo que se produce en la firma,

con los resultados que se esperan en los ejemplos, y con el del
cuerpo del encabezamiento.

|#

;; Ancho y Altura son Números. 1)

;; interpretación representan los lados de un rectángulo
;; Número Número -> Número 2)
;; obtiene área de rectángulo de ancho, an, y altura, al
;; (define (área-rect an al) 0)
;; dados: 2 y 4, espera: 8, o sea 2 * 4 = 8 3)
;; dados: 14 y 7, espera: 98, o sea 14 * 7 = 98
;; (define (área-rect an al) 4)
;; (... an ... al ...))
(define (área-rect an al) ;; 5)
(* an al))

#|

Las pruebas de los ejemplos en la ventana de Interacciones

resultan en:

> (área-rect 2 4)
8
> (área-rect 14 7)
98
>

Como 8 y 98 son iguales a los resultados esperados, no se requiere

recalcular ningún ejemplo ni revisar el código.

Lo que no garantiza que el programa pudiera tener algún error

lógico, por ejemplo, si en lugar de multiplicar la base por la
altura; se hubiera supuesto que la fórmula matématica para obtener
el área del rectángulo fuera otra diferente. Sin embargo, el
diseño cuidadoso y sistemático de programas ayuda a prevenir
tales errores.

===================================================================

Si ahora el problema es calcular el perímetro del rectángulo dados

su ancho y altura, y se desea diseñar la función que lo resuelva
mediante realizar los pasos de diseño y las verificaciones
correspondientes,

¿cómo cambia el nuevo diseño?

¿cambia la definición de datos?

¿Cambia el contrato?
¿Cambia el propósito?

¿Cambian los ejemplos?

¿Cambia el encabezamiento?

¿Cambia el formato o inventario?

¿Cambia el cuerpo de la función?

|#

;; Ancho Altura -> Número

;; calcula el perímetro de un rectángulo de ancho, an, y altura, al
;; dados: 2 y 4, espera: 12, o sea (+ (* 2 2)(* 2 4)) = 12
;; dados: 14 y 7, espera: 42, o sea (+ (* 2 14)(* 2 7)) = 42
;; (define (perímetro-rect an al) 0)
;; (define (perímetro-rect an al)
;; (... an ... al ...))

#|

Si ahora el problema es dibujar un rectángulo de lados an y al,

sólido de color rojo. ¿cómo es su diseño y la verificación de sus
partes? Primero, como hemos visto manejar imágenes requiere cargar
la biblioteca correspondiente.

|#

#|

Si ahora el problema es determinar si una figura es más ancha que

alta. Diseñar la función que lo resuelva, lo cual significa
realizar y verificar las partes del diseño del programa
correspondiente.

|#

;; Alto Ancho -> Número

;; calcula el área de un rectángulo de ancho, an, y altura, al
;; dados: 2 y 4, espera: 8, o sea 2 * 4 = 8
;; dados: 14 y 7, espera: 98, o sea 14 * 7 = 98
;; (define (ancho>alto an al) 0)
;; (define (ancho>alto an al)
;; (... an ... al ...))
#; (define (ancho>alto an al)
(* an al))

;; Ejercicio 3.2.2.rkt

#| Cambios y extensiones a Ejercicio 3.2.1.rkt

Problema, calcular el área de un rectángulo dados su

ancho y altura. A fin de diseñar la función que lo resuelva:

1) escribir la definición de datos

2) escribir la firma, el propósito, y el encabezamiento

Con base en 1) la definición de datos, la firma puede hacerse

empleando como tipo de datos los alias de Número: Ancho y Alto

;; Ancho Alto -> Número

lo cual precisa más la firma y pasos siguientes

3) ilustrar la firma y el propósito con ejemplos,

éstos últimos se pueden englobar con operadores check-expect,

cuyo primer operando sea la aplicación de la función
área-rect a las parejas respectivas de argumentos 2 y 4,
14 y 7, siendo el segundo operando el resultado esperado de
cada una:

(check-expect (área-rect 2 4) 8)
(check-expect (área-rect 14 7) 98)

o mejor incluir en lugar del resultado la expresión que lo genera

(check-expect (área-rect 2 4) (* 2 4))

(check-expect (área-rect 14 7)(* 14 7))

lo que convierte los comentarios de los ejemplos en código que se

puede evaluar con el borrador
(define (área-rect an al) 0)

evaluación que abrirá una ventana Test Results informando

-------------------------------------------------------------------
Ran 2 tests.
0 tests passed.
No signature violations.

Check failures:
Actual value 0 differs from 8, the expected value.
in Ejercicio 3.2.2.rkt, line 155, column 0
Actual value 0 differs from 98, the expected value.
in Ejercicio 3.2.2.rkt, line 156, column 0

-------------------------------------------------------------------

en la que se menciona
Corrieron dos pruebas.
0 pruebas pasaron.
No violaciones a firma.

Verificación de fallas:
Valor actual 0 difiere de 8, el valor esperado.
en Ejercicio 3.2.2.rkt, línea 155, columna 0,
Valor actual 0 difiere de 98, el valor esperado.
en Ejercicio 3.2.2.rkt, línea 156, columna 0
-------------------------------------------------------------------

Indicando además las líneas "en Ejercicio... " el punto donde se

presenta el error.

Todo lo cual es valioso, pues sin tener el código final de la

función, se cuenta con código que corre, con fallas, pero que
corre ya!

Al tener pruebas que corren, se validan mutuamente la

coherencia entre el borrador y los ejemplos, en cuanto: al
nombre de la función, los tipos, el número, y el orden de sus
argumentos, así como el tipo del resultado.

Si alguna prueba check-expect hubiera fallado, se habrían

manifestado inconsistencias en los primeros pasos de diseño,
lo cual es siempre preferible, a que eso suceda en pasos
posteriores.

De ahí la conveniencia de escribir el borrador y los ejemplos

englobados en expresiones check-expect como comentarios
con sólo un ; a fin de realizar pruebas previas y parciales como
las mencionadas.

Las cuales si funcionan correctamente en la última versión

mencionada se relacionan mejor con el paso siguiente

4) tomar el inventario, o sea escribir el formato

(define (área-rect an al)

(... an ... al))

con base en el cual se facilita escribir el código mediante las

acciones adicionales previamente mencionadas en 3)

pues si fueron exitosas las pruebas parciales y previas

(check-expect (área-rect 2 4) (* 2 4))

(check-expect (área-rect 14 7)(* 14 7))

el segundo operando de las expresiones check-expect da la

clave para escribir el cuerpo de la función, el cual debe ser
algo parecido a:

(* 2 4)
(* 14 7)

sustituyendo los argumentos 2 y 4 o 14 y 7 por los parámetros

an y al, queda el cuerpo de la función en:

(* an al)

por lo que ahora es directo el paso 5)

5) escribir el código

(define (área-rect an al)

(* an al))

al descomentar los ejemplos englobados en expresiones check-expect,

es directo el paso 6)
6) probar la función con los ejemplos.

Con los cambios y agregados previos se avanza significativamente en

Verificar:

a) que el nombre de la función coincida con el del encabezamiento,

el de los ejemplos y el del formato

b) que coincida el número de parámetros del encabezamiento con el

de los parámetros del formato, con el de los de la función, y con
el de los argumentos de los ejemplos

c) que coincidan los tipos de datos de la firma con los de los

ejemplos

d) que coincida el tipo de datos de lo que se produce en la firma,

con los resultados que se esperan en los ejemplos, y con el del
cuerpo del encabezamiento.

Por lo que el código extendido y ampliado del primer ejemplo queda

en un primer paso:

|#

;; Ancho y Altura son Números. 1)

;; interpretación representan los lados de un rectángulo

;; Ancho Altura -> Número 2)

;; obtiene área de rectángulo de ancho, an, y altura, al
(define (área-rect an al) 0)
(check-expect (área-rect 2 4) (* 2 4)) ;; 3)
(check-expect (área-rect 14 7)(* 14 7))
;; (define (área-rect an al) 4)
;; (... an ... al ...))
;; (define (área-rect an al) ;; 5)
;; (* an al))

#|

Surgiendo la ventana Test Results mencionada previamente

Si en el diseño se comentan con ; el borrador y las pruebas,

Se copia y se pega el formato y se trabaja según lo visto

anteriormente, y cambiando el comentario ;; por un comentario
más cómodo a "copiar y pegar", el formato y el diseño de la función
resultan en

;; Ancho y Altura son Números. 1)

;; interpretación representan los lados de un rectángulo

;; Ancho Altura -> Número 2)

;; obtiene área de rectángulo de ancho, an, y altura, al
; (define (área-rect an al) 0)
; (check-expect (área-rect 2 4) (* 2 4)) ;; 3)
; (check-expect (área-rect 14 7)(* 14 7))
#; (define (área-rect an al) 4)
(... an ... al ...))
(define (área-rect an al) ;; 5)
(* an al))

;; Ejercicio 3.2.3.rkt

;; Cambios y extensiones a Ejercicio 3.2.2.rkt

;; Problema, calcular el área de un rectángulo dados su

;; ancho y altura. Diseñar la función que lo resuelva:

;; Ancho y Altura son Números. 1)

;; interpretación representan los lados de un rectángulo

;; Ancho Altura -> Número 2)

;; obtiene área de rectángulo de ancho, an, y altura, al
; (define (área-rect an al) 0)
(check-expect (área-rect 2 4) (* 2 4)) ;; 3)
(check-expect (área-rect 14 7)(* 14 7))
#; (define (área-rect an al) ;; 4)
(... an ... al ...))
(define (área-rect an al) ;; 5)
(* an al))

#|

lo cual al oprimirse el botón Revisa la sintáxis no marca ningún

error, coloreando significativamente las pruebas y el código, y si
se ejecuta con Ejecutar, o control r, en la ventana de
Interacciones devuelve:

Both tests passed!

Indicando que ¡Ambas pruebas pasaron!

===================================================================

Si ahora el problema es calcular el perímetro del rectángulo dados

su ancho y altura, al diseñar la función que lo resuelva
mediante realizar los pasos de diseño y las verificaciones
correspondientes, se desea completar el diseño con base en lo
siguiente:

|#

;; Ancho Alto -> Número

;; calcula el perímetro de un rectángulo de ancho, an, y altura, al
(check-expect (perímetro-rect 2 4) (+ (* 2 2)(* 2 4)))
(check-expect (perímetro-rect 14 7)(+ (* 2 14)(* 2 7)))
(define (perímetro-rect an al) 0)
#; (define (perímetro-rect an al)
(... an ... al ...))

#| Ejercicio 3.2.4.rkt

Cambios y extensiones al Ejercicio 3.2.3.rkt

Problema, calcular el perímetro del rectángulo dados

su ancho y altura, al diseñar la función que lo resuelva
mediante realizar los pasos de diseño y las verificaciones
correspondientes, se desea completar el diseño con base en lo
siguiente:

|#

;; Ancho Alto -> Número

;; calcula el perímetro de un rectángulo de ancho, an, y altura, al
(check-expect (perímetro-rect 2 4) (+ (* 2 2)(* 2 4)))
(check-expect (perímetro-rect 14 7)(+ (* 2 14)(* 2 7)))
; (define (perímetro-rect an al) 0)
#; (define (perímetro-rect an al)
(... an ... al ...))
(define (perímetro-rect an al)
(+ (* 2 an)(* 2 al)))

#|

Con base en lo cual se plantea el problema es dibujar un rectángulo

de lados an y al, sólido de color rojo. ¿cómo es su diseño y la
verificación de sus partes? Primero, como hemos visto al manejar
imágenes se requiere cargar la biblioteca correspondiente.

Completar el diseño de dibuja-rect

|#

(require 2htdp/image)

;; Ancho Alto -> Imagen

;; dibuja rectángulo de ancho an y alto al (pixeles), sólido y rojo
; (check-expect (dibuja-rect 20 40) .)
; (check-expect (dibuja-rect 30 20)(rectangle 30 20 "solid" "red"))
; (define (dibuja-rect an al) (rectangle 20 20 "outline" "black"))
#; (define (dibuja-rect an al)
(... an ... al))

#| Ejercicio 3.2.5.rkt

Cambios y extensiones al Ejercicio 3.2.4.rkt

Dibujar un rectángulo de lados an y al, sólido de color rojo.

¿cómo es su diseño y la verificación de sus partes? Primero, como
se ha visto al manejar imágenes se requiere cargar la biblioteca
correspondiente.

Completar el diseño de dibuja-rect

|#

(require 2htdp/image)

;; Ancho Alto -> Imagen

;; dibuja rectángulo de ancho an y alto al (pixeles), sólido y rojo
; (check-expect (dibuja-rect 20 40) .)
; (check-expect (dibuja-rect 30 20)(rectangle 30 20 "solid" "red"))
; (define (dibuja-rect an al) (rectangle 20 20 "outline" "black"))
#; (define (dibuja-rect an al)
(... an ... al))
(define (dibuja-rect an al)
(rectangle an al "outline" "black"))

#|

Si ahora el problema es determinar si un dibujo es más ancho que

alto. Diseñar la función que lo resuelva, lo cual significa
realizar y verificar las partes del diseño del programa
correspondiente.

|#

;; Imagen -> ...

;; devuelve #true si ancho dibujo d mayor que su altura
(check-expect (ancho?(circle 5 "solid" "red"))
(> (image-width (circle 5 "solid" "red"))
(image-height (circle 5 "solid" "red"))))
(check-expect (ancho? (rectangle 50 49 "solid" "red")) #true)
(define (ancho? d) #false)

;; Ejercicio 3.2.7.rkt

;; Solución Ejercicio 3.2.6.rkt

(require 2htdp/image)

;; Constantes
(define CIRCULO (circle 5 "solid" "red"))
;; Se define la variable CIRCULO ya que se maneja una expresión
;; tres veces en una prueba

;; Imagen -> Boolean

;; devuelve #true si ancho dibujo d mayor que su altura
(check-expect (ancho? CIRCULO)
(> (image-width CIRCULO)
(image-height CIRCULO)))
(check-expect (ancho? (rectangle 50 49 "solid" "red")) #true)
; (define (ancho? d) #false)
#; (define (ancho? d)
(... d ...))
(define (ancho? d)
(> (image-width d)(image-height d)))

; ===============================================================>>

;; Diseñar las funciones ubica-punto-en y alto del programa-mundo

;; siguiente

(define FONDO (empty-scene 100 100))

(define PUNTO (circle 3 "solid" "red"))

(define (principal y)
(big-bang y
[on-tick sub1]
[stop-when zero?]
[to-draw ubica-punto-en]
[on-key alto]))

(define (ubica-punto-en y)
(place-image PUNTO 50 y FONDO))

(define (alto y et)

100)