Transformación de coordenadas

;; Top-level definitions are global-scope
(def dozen 12)

;; Functions create a new scope.
;; Referencing the outer variable here is a closure.
(fn [n] (* dozen n))

;; This function closure increments the counter's state
;; in the outer lexical context.
;; This way the counter can be shared between many calling contexts.

(def increment
  (let [counter (atom 0)]
    (fn [] (swap! counter inc))))

(increment)
;;=> 1
(increment)
;;=> 2

Instrucciones

Tu empresa de diseño ha estado trabajando principalmente con transformaciones CSS para crear páginas web. Después de hablarlo, se decide empezar a usar Clojure para realizar algunos cálculos de forma dinámica. Algunos de tus compañeros de equipo tienen menos experiencia con Clojure, así que decides usar una clausura de función para crear transformaciones reutilizables para pares de coordenadas {x, y}.

1. Traslada las coordenadas

Implementa la función translate2d que devuelve una función que hace uso de una clausura para realizar una traslación 2D repetible de un par de coordenadas.

(def move-coordinates-right-2px (translate2d 2 0))
(def result (move-coordinates-right-2px 4 8))
;; result => [6 8]

2. Escala las coordenadas

Implementa la función scale2d que devuelve una función que hace uso de una clausura para realizar un escalado 2D repetible de un par de coordenadas.

Para este ejercicio, supón que solo hay valores de escalado positivos.

(def double-scale (scale2d 2 2))
(def result (double-scale 6 -3))
;; result => [12 -6]

3. Compón funciones de transformación

Combina dos funciones de transformación para realizar una transformación repetible. A esto se le suele llamar composición de funciones, donde el resultado de la primera función 'f(x)' se usa como entrada de la segunda función 'g(x)'.

(def move-coordinates-right-2px (translate2d 2 0))
(def double-coordinates (scale2d 2 2))
(def composed-transformations 
  (compose-transform move-coordinates-right-2px 
                     double-coordinates))
(def result (composed-transformations 0 1))
;; result => [4 2]

4. Guarda los resultados de las funciones

Implementa la función memoize-transform. Toma una función para memoizar y devuelve una nueva función que recuerda las entradas de la función proporcionada, de modo que el último valor devuelto pueda «recordarse» y solo se calcule una vez si se llama de nuevo con los mismos argumentos.

La memoización a veces se llama programación dinámica. Permite realizar operaciones costosas solo una vez, ya que su resultado se recuerda.

(def triple-scale (scale2d 3 3))
(def memoized-scale (memoize-transform triple-scale))

(memoized-scale 4 3)
;; => [12, 9], this is computed since it hasn't been computed before for the arguments

(memoized-scale 4 3)
;; => [12, 9], this is remembered, since it was computed already