Splitted READMEs

README-en.md

@@ -0,0 +1,165 @@
+
+#Recursion - Recursive Shapes
+
+![main1.jpg](images/main1.jpg)
+![main2.jpg](images/main2.jpg)
+![main3.png](images/main3.png)
+
+One commonly used programming technique is *recursion*. With this technique, problems are solved by solving similar problems but for smaller cases. We can construct sets of objects or tasks using *recursive rules* and *initial values*. *Recursive functions* are functions that are self-invoking, using smaller sets or elements each time, until reaching a point where an initial value is used instead of self-invoking. Fractals are an example of figures that can be created using recursion. In this laboratory experience you will practice the definition and implementation of recursive functions to draw self-similar objects (fractals). 
+
+The exercises in this laboratory experience are an adaptation of https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-6-turtle-recursion.
+
+##Objectives:
+
+1. Practice the definition and implementation of recursive functions.
+
+
+
+##Pre-Lab:
+
+Before coming to the laboratory session you should have:
+
+1. Reviewed the basic concepts related to recursive functions.
+
+2. Studied the `box` function to draw boxes, included in the `boxes.cpp` file in the `Qt` project.
+
+3. Studied the concepts and instructions related to the laboratory session.
+
+4. Taken the Pre-Lab quiz available through the course’s Moodle portal.
+
+---
+
+---
+
+
+##Self-similar forms
+
+![figure2.png](images/figure2.png)
+
+**Figure 2.** Fractal tree [5].
+
+---
+
+One ingenious way of practicing and visualize recursion is programming functions that produce recursive figures, or fractals. For example, consider a recursive figure that we'll call *branch*. Figure 3 shows `branch(0,90)`, `branch(1,90)`, and `branch(2,90)`.
+
+---
+
+![figure3.jpg](images/figure3.jpg)
+
+**Figure 3.** (a) `branch(0,90)`, (b) `branch(1,90)`, y (c) `branch(2,90)`. 
+
+---
+
+Can you see the recursive behavior in this figure? Notice that `branch(0,90)` is only a vertical segment (a segment in an angle of 90 degrees); `branch(1,90)` is `branch(0,90)` with two segments inclined in its top. More precisely, `branch(1,90)` is `branch(0,90)` with a `branch(0,60)` and a `branch(0,120)` in its top. Similarly, `branch(2,90)` is `branch(0,90)` with two `branch(1,90)` inclined in the top. That is, `branch(2,90)` is:
+`branch(0,90)` with a `branch(1,60)` and a `branch(1,120)` in its top. Notice that $$60=90-30$$ and $$120=90+30$$.
+
+This way we can express `branch(n,A)` as a composition of branches with smaller inclined $$n$$'s. Code 1 provides a way of expressing `branch` as a recursive function.
+
+---
+
+```
+branch(0, A) = draws a segment of length L and angle A
+branch(n, A) = draws: branch(0,A), branch(n-1,A-30), branch(n-1,A+30)
+```
+
+**Code 1.** Function to draw branches.
+
+---
+
+Notice that the recursive definition includes a base case, that is, includes `branch(0,A)`, and a recurrence relation, that is, `branch(n,A)`. To simplify, we assume that `branch(n-1,A-30)` and `branch(n-1,A+30)` are drawn at the top of `branch(0,A)`.
+
+Figure 4 illustrates the recursive expansion for `branch(2,90)`. The color of each expression is the corresponding segment color in the figure.
+
+---
+
+![figure4.jpg](images/figure4.jpg)
+
+**Figure 4.** Illustration for `branch(2,90)`.
+
+---
+ 
+Can you predict how the next iteration for the figure will look? That is, what figure will `branch(3,A)` produce?
+
+---
+
+---
+
+##Laboratory Session
+
+In today's laboratory experience you will implement recursive functions to produce fractals.
+
+###Exercise 1: Snowflake
+
+One of the simplest fractal figures is the snowflake. This figure is formed by an isosceles triangle, substituting the middle third segment on each side by an inverted "V". The measurements of each side of the "V" is equal to the measurements of the segment it substitutes. We will use the snowflake to illustrate the process of recursion.
+
+---
+
+![figure5.png](images/figure5.png)
+
+**Figure 5.** Part of the construction of the snowflake fractal.
+
+---
+
+####Instructions
+
+1. Load the project `RecursiveShapes` onto `QtCreator` by double clicking on the `RecursiveShapes.pro` file in the `Documents/eip/Recursion-RecursiveShapes` folder of your computer. You may also go to `http://bitbucket.org/eip-uprrp/recursion-recursiveshapes` to download the `Recursion-RecursiveShapes` folder to your computer.
+
+2. Compile and run the program so you see a snowflake figure constructed with 3 iterations of the `snowflake` function. You can see the code of this function in the `snowflake.cpp` file of the `Qt` project.
+
+In the `main` function, look up the line where the variable `level` is declared and given a value. Change the value of `level` to `0` and run the program. You'll be able to see the triangle that represents the recursive base case for the snowflake. Continue changing the value for `level` and running the program so you can see the recursion process and produce self-similar figures.
+
+
+###Exercise 2: Self-similar boxes
+
+In this exercise, your task is to program a recursive function `boxes`, in the file `boxes.cpp`, that produces the following figures.
+
+---
+
+![figure6.jpg](images/figure6.jpg)
+
+**Figure 6.** Illustration of the box figures that your program should produce.
+
+---
+
+The `boxes` recursive function includes three parameters: `sideLength`, `shrinkFactor`, and `smallestLength`.
+
+* `sideLength`: an integer that determines the length of the sides of the largest box.
+* `shrinkFactor`: a real number that determines the rate of the next level of boxes. For example, if `sideLength` is `100`, and `shrinkFactor` is `0.3`, the length of the sides of the largest box will be `100` units, and the length of the sides of the smallest box will be `100*.3=30` units. Four copies of that smaller box are placed within the previous box, **one box in each corner**.
+* `smallestLength`: is an integer that determines the length of the sides of the smallest box that will be drawn. For example, in Figure 6, `boxes(400,0.4,200)` only draws the box with sides of length `400`, since the size that will follow will be `400 * 0.4 = 160`, which is smaller than `200`. On the other hand, `boxes(400, 0.4, 75)` draws the box of size `400` and the boxes with size `160`, but not the following ones in size, since they would be of size `160 * 0.4 = 64`, which is less than `75`.
+
+####Instructions
+
+1. Study the `box` function included in the `boxes.cpp` file. This function receives as arguments the coordinates of the upper left corner, the length of the sides and the color of the box. The function draws a box with these specifications. 
+
+2. Write a recursive algorithm for the `boxes` function described above. Remember to include the base case! The algorithm should also invoke the `box` function to draw the boxes.
+
+3. Implement the function in `QtCreator`. You will need to provide additional parameters to your function so you can control the position and the color of the squares.
+
+4. Invoke the `boxes` function from the `main` function in the `main.cpp` file. Compare your results with the images in Figure 6.
+
+
+
+---
+
+---
+
+##Deliverables
+
+1. Use "Deliverables" in Moodle to upload the `boxes.cpp` and `main.cpp` files. Remember to use good programming techniques, include the names of the programmers involved, and to document your program.
+
+
+---
+
+---
+
+##References
+
+[1] https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-6-turtle-recursion.
+
+[2] "Mandel zoom 00 mandelbrot set". Licensed under Creative Commons Attribution-Share Alike 3.0 via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Mandel_zoom_00_mandelbrot_set.jpg#mediaviewer/File:Mandel_zoom_00_mandelbrot_set.jpg
+
+[3] "Mandel zoom 04 seehorse tail". Licensed under Creative Commons Attribution-Share Alike 3.0 via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Mandel_zoom_04_seehorse_tail.jpg#mediaviewer/File:Mandel_zoom_04_seehorse_tail.jpg
+
+[4] http://www.coolmath.com/fractals/images/fractal5.gif
+
+[5] "Fractal tree (Plate b - 2)". Licensed under Public domain via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Fractal_tree_(Plate_b_-_2).jpg#mediaviewer/File:Fractal_tree_(Plate_b_-_2).jpg

README-es.md

@@ -0,0 +1,177 @@
+
+#Recursión - Figuras Recursivas
+
+![main1.jpg](images/main1.jpg)
+![main2.jpg](images/main2.jpg)
+![main3.png](images/main3.png)
+
+
+Una técnica muy utilizada en programación es la *recursión*. Con esta técnica se resuelven problemas resolviendo un problema similar pero para casos más pequeños. Podemos construir conjuntos de objetos o procesos utilizando *reglas recursivas* y *valores iniciales*. Las *funciones recursivas* son funciones que se auto-invocan, utilizando cada vez conjuntos o elementos más pequeños,  hasta llegar a un punto en donde se utiliza el valor inicial en lugar de auto-invocarse. Los fractales son un ejemplo de figuras que se pueden crear usando recursión. En esta experiencia de laboratorio practicarás la definición e implementación de funciones recursivas para dibujar formas auto-similares (fractales).
+
+Los ejercicios de esta experiencia de laboratorio son una adaptación de https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-6-turtle-recursion.
+
+
+##Objetivos:
+
+1. Practicar el definir e implementar funciones recursivas.
+
+
+##Pre-Lab:
+
+Antes de llegar al laboratorio debes haber:
+
+1. Repasado los conceptos relacionados a funciones recursivas.
+
+2. Estudiado la función `box` para dibujar cajas, incluida en el archivo `boxes.cpp` del proyecto de `Qt`.
+
+3. Haber estudiado los conceptos e instrucciones para la sesión de laboratorio.
+
+4. Haber tomado el quiz Pre-Lab que se encuentra en Moodle.
+
+---
+
+---
+
+
+
+## Figuras auto-similares
+
+![figure2.png](images/figure2.png)
+
+**Figura 2.** Árbol fractal [5].
+
+---
+
+
+
+Una manera ingeniosa de practicar y "visualizar" recursión es programando funciones que produzcan figuras auto-similares (o recursivas). Por ejemplo, considera una figura recursiva que llamaremos *rama*. La Figura 3 muestra `rama(0,90)`, `rama(1,90)` y `rama(2,90)`.
+
+---
+
+![figure3.jpg](images/figure3.jpg)
+
+**Figura 3.** (a) `rama(0,90)`, (b) `rama(1,90)`, y (c) `rama(2,90)`. 
+
+---
+
+¿Puedes ver el comportamiento recursivo de esta figura? Nota que `rama(0,90)` es solo un segmento vertical (un segmento en un ángulo de 90 grados); `rama(1,90)` es `rama(0,90)` con dos segmentos inclinados en  su extremo superior. Más preciso, `rama(1,90)` es `rama(0,90)` con una  `rama(0,60)` y una `rama(0,120)` en el extremo superior. Similarmente, `rama(2,90)` es `rama(0,90)`  con dos `rama(1,90)` inclinadas en el extremo superior. Esto es,  `rama(2,90)` es:
+`rama(0,90)` con una `rama(1,60)` y una `rama(1,120)` en el extremo superior. Nota que $$60=90-30$$ y que $$120=90+30$$.
+
+De esta manera podemos expresar `rama(n,A)` como una composición de ramas con $$n$$'s más pequeñas inclinadas. El Código 1 provee una manera de expresar `rama` como una función recursiva.
+
+---
+
+```
+rama(0, A) = dibuja un segmento de largo L en un ángulo A
+rama(n, A) = dibuja: rama(0,A), rama(n-1, A-30), rama(n-1, A+30)
+```
+
+**Código 1.** Función para dibujar las ramas.
+
+---
+
+Nota que la definición recursiva incluye un caso base, esto es, incluye `rama(0,A)`, y una relación de recurrencia (o caso recursivo), esto es, `rama(n,A)`. Para simplificar, asumimos que  `rama(n-1,A-30)` y `rama(n-1,A+30)` se dibujan en el extremo superior de `rama(0,A)`.
+
+La Figura 4 ilustra la expansión recursiva para `rama(2,90)`. El color de cada expresión es el color del segmento que le corresponde en la figura.
+
+---
+
+![figure4.jpg](images/figure4.jpg)
+
+**Figura 4.** Ilustración de `rama(2,90)`.
+
+---
+ 
+¿Puedes predecir cómo será la próxima iteración de la figura? Es decir, ¿qué figura producirá `rama(3,A)`?
+
+---
+
+---
+
+## Sesión de laboratorio
+
+En la experiencia de laboratorio de hoy implementarás  funciones recursivas para producir fractales.
+
+###Ejercicio 1: Copo de nieve
+
+Una de las figuras fractales más simples es la figura de un copo de nieve. Esta figura se forma a partir de un triángulo isósceles, sustituyendo el segmento del tercio del medio de cada lado por una "V" invertida. La medida de los lados de la "V" es igual a la medida del segmento que sustituye. Usaremos el copo de nieve para ilustrar el proceso de recursión.
+
+---
+
+![figure5.png](images/figure5.png)
+
+**Figura 5.** Parte de la construcción del fractal "copo de nieve".
+
+---
+
+####Instrucciones
+
+1. Carga a QtCreator el proyecto `RecursiveShapes`  haciendo doble "click" en el archivo `RecursiveShapes.pro` en el directorio `Documents/eip/Recursion-RecursiveShapes` de tu computadora. También puedes ir a `http://bitbucket.org/eip-uprrp/recursion-recursiveshapes` para descargar la carpeta `Recursion-RecursiveShapes` a tu computadora.
+ 
+2. Compila y corre el programa para que veas una figura del copo de nieve construida con 3 iteraciones de la función `snowflake`. Puedes ver el código que define esta función en el archivo `snowflake.cpp` del proyecto de `Qt`.
+
+    En la función `main`, busca la línea en donde se declara y dá valor a la variable `level`. Cambia el valor de `level` a `0` y corre el programa de nuevo. Podrás ver el triángulo que representa el caso base de la recursión para el copo de nieve. Continúa cambiando el valor de la variable `level` y corriendo el programa para que veas el proceso de la recursión y de producir figuras auto-similares.
+
+
+###Ejercicio 2: Cajas autosimilares
+
+Tu tarea en este ejercicio es programar una función recursiva `boxes`, en el archivo `boxes.cpp`, que produzca las siguientes figuras. 
+
+---
+
+![figure6.jpg](images/figure6.jpg)
+
+**Figura 6.** Ilustración de las figuras de cajas que debe producir tu programa.
+
+---
+
+La función recursiva `boxes` incluye tres parámetros: `sideLength`, `shrinkFactor`, y `smallestLength`.
+
+* `sideLength`: un entero que determina el largo de los lados del cuadrado más grande.
+* `shrinkFactor`: un número real que determina la razón del siguiente nivel de cuadrados. Por ejemplo, si `sideLength` es `100`, y `shrinkFactor` es `0.3`, el largo de los lados del cuadrado más grande será `100` unidades, y el largo de los lados del próximo cuadrado más pequeño  será `100*.3=30` unidades. Se colocan 4 copias de ese cuadrado más pequeño dentro del cuadrado anterior, **un cuadrado en cada esquina**.
+* `smallestLength`: es un valor entero que determina el largo del lado del cuadrado más pequeño que será dibujado. Por ejemplo, en la Figura 6, `boxes(400, 0.4, 200)` solo dibuja el cuadrado con lados de largo `400`, ya que el tamaño que le seguiría sería `400 * 0.4 = 160`, que es más pequeño que `200`. Por otro lado, `boxes(400, 0.4, 75)` dibuja el cuadrado de tamaño `400` y los cuadrados de tamaño `160`, pero no los siguientes en tamaño, porque serían de tamaño `160 * 0.4 = 64`, que es menor que `75`.
+
+####Instrucciones
+
+1. Estudia la función `box` incluida en el archivo `boxes.cpp`. Esta función recibe como argumentos las coordenadas de la esquina superior izquierda, el largo de los lados y el color de una caja. La función dibuja una caja con esas especificaciones.
+
+2. Escribe un algoritmo recursivo para la función `boxes` descrita arriba. ¡Recuerda incluir el caso base! El algoritmo también debe invocar la función `box` para dibujar las cajas. 
+
+3. Implementa la función en `QtCreator`. Necesitarás proveer parámetros adicionales a tu función para que puedas controlar la posición y el color de los cuadrados. 
+
+4. Invoca la función `boxes` desde la función main en el archivo `main.cpp`. Compara tus resultados con las imágenes de la Figura 6.
+
+
+---
+
+---
+
+##Entrega
+
+Utiliza "Entrega" en Moodle para entregar los archivos `boxes.cpp` y `main.cpp`. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
+
+
+---
+
+---
+
+
+## Referencias
+
+[1] https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-6-turtle-recursion.
+
+[2] "Mandel zoom 00 mandelbrot set". Licensed under Creative Commons Attribution-Share Alike 3.0 via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Mandel_zoom_00_mandelbrot_set.jpg#mediaviewer/File:Mandel_zoom_00_mandelbrot_set.jpg
+
+[3] "Mandel zoom 04 seehorse tail". Licensed under Creative Commons Attribution-Share Alike 3.0 via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Mandel_zoom_04_seehorse_tail.jpg#mediaviewer/File:Mandel_zoom_04_seehorse_tail.jpg
+
+[4] http://www.coolmath.com/fractals/images/fractal5.gif
+
+[5] "Fractal tree (Plate b - 2)". Licensed under Public domain via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Fractal_tree_(Plate_b_-_2).jpg#mediaviewer/File:Fractal_tree_(Plate_b_-_2).jpg
+
+---
+
+---
+
+---
+
+

README.md

@@ -1,344 +1,2 @@
-[English](#markdown-header-recursion-recursive-shapes) | [Español](#markdown-header-recursion-figuras-recursivas)
-
-#Recursión - Figuras Recursivas
-
-![main1.jpg](images/main1.jpg)
-![main2.jpg](images/main2.jpg)
-![main3.png](images/main3.png)
-
-
-Una técnica muy utilizada en programación es la *recursión*. Con esta técnica se resuelven problemas resolviendo un problema similar pero para casos más pequeños. Podemos construir conjuntos de objetos o procesos utilizando *reglas recursivas* y *valores iniciales*. Las *funciones recursivas* son funciones que se auto-invocan, utilizando cada vez conjuntos o elementos más pequeños,  hasta llegar a un punto en donde se utiliza el valor inicial en lugar de auto-invocarse. Los fractales son un ejemplo de figuras que se pueden crear usando recursión. En esta experiencia de laboratorio practicarás la definición e implementación de funciones recursivas para dibujar formas auto-similares (fractales).
-
-Los ejercicios de esta experiencia de laboratorio son una adaptación de https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-6-turtle-recursion.
-
-
-##Objetivos:
-
-1. Practicar el definir e implementar funciones recursivas.
-
-
-##Pre-Lab:
-
-Antes de llegar al laboratorio debes haber:
-
-1. Repasado los conceptos relacionados a funciones recursivas.
-
-2. Estudiado la función `box` para dibujar cajas, incluida en el archivo `boxes.cpp` del proyecto de `Qt`.
-
-3. Haber estudiado los conceptos e instrucciones para la sesión de laboratorio.
-
-4. Haber tomado el quiz Pre-Lab que se encuentra en Moodle.
-
----
-
----
-
-
-
-## Figuras auto-similares
-
-![figure2.png](images/figure2.png)
-
-**Figura 2.** Árbol fractal [5].
-
----
-
-
-
-Una manera ingeniosa de practicar y "visualizar" recursión es programando funciones que produzcan figuras auto-similares (o recursivas). Por ejemplo, considera una figura recursiva que llamaremos *rama*. La Figura 3 muestra `rama(0,90)`, `rama(1,90)` y `rama(2,90)`.
-
----
-
-![figure3.jpg](images/figure3.jpg)
-
-**Figura 3.** (a) `rama(0,90)`, (b) `rama(1,90)`, y (c) `rama(2,90)`. 
-
----
-
-¿Puedes ver el comportamiento recursivo de esta figura? Nota que `rama(0,90)` es solo un segmento vertical (un segmento en un ángulo de 90 grados); `rama(1,90)` es `rama(0,90)` con dos segmentos inclinados en  su extremo superior. Más preciso, `rama(1,90)` es `rama(0,90)` con una  `rama(0,60)` y una `rama(0,120)` en el extremo superior. Similarmente, `rama(2,90)` es `rama(0,90)`  con dos `rama(1,90)` inclinadas en el extremo superior. Esto es,  `rama(2,90)` es:
-`rama(0,90)` con una `rama(1,60)` y una `rama(1,120)` en el extremo superior. Nota que $$60=90-30$$ y que $$120=90+30$$.
-
-De esta manera podemos expresar `rama(n,A)` como una composición de ramas con $$n$$'s más pequeñas inclinadas. El Código 1 provee una manera de expresar `rama` como una función recursiva.
-
----
-
-```
-rama(0, A) = dibuja un segmento de largo L en un ángulo A
-rama(n, A) = dibuja: rama(0,A), rama(n-1, A-30), rama(n-1, A+30)
-```
-
-**Código 1.** Función para dibujar las ramas.
-
----
-
-Nota que la definición recursiva incluye un caso base, esto es, incluye `rama(0,A)`, y una relación de recurrencia (o caso recursivo), esto es, `rama(n,A)`. Para simplificar, asumimos que  `rama(n-1,A-30)` y `rama(n-1,A+30)` se dibujan en el extremo superior de `rama(0,A)`.
-
-La Figura 4 ilustra la expansión recursiva para `rama(2,90)`. El color de cada expresión es el color del segmento que le corresponde en la figura.
-
----
-
-![figure4.jpg](images/figure4.jpg)
-
-**Figura 4.** Ilustración de `rama(2,90)`.
-
----
- 
-¿Puedes predecir cómo será la próxima iteración de la figura? Es decir, ¿qué figura producirá `rama(3,A)`?
-
----
-
----
-
-## Sesión de laboratorio
-
-En la experiencia de laboratorio de hoy implementarás  funciones recursivas para producir fractales.
-
-###Ejercicio 1: Copo de nieve
-
-Una de las figuras fractales más simples es la figura de un copo de nieve. Esta figura se forma a partir de un triángulo isósceles, sustituyendo el segmento del tercio del medio de cada lado por una "V" invertida. La medida de los lados de la "V" es igual a la medida del segmento que sustituye. Usaremos el copo de nieve para ilustrar el proceso de recursión.
-
----
-
-![figure5.png](images/figure5.png)
-
-**Figura 5.** Parte de la construcción del fractal "copo de nieve".
-
----
-
-####Instrucciones
-
-1. Carga a QtCreator el proyecto `RecursiveShapes`  haciendo doble "click" en el archivo `RecursiveShapes.pro` en el directorio `Documents/eip/Recursion-RecursiveShapes` de tu computadora. También puedes ir a `http://bitbucket.org/eip-uprrp/recursion-recursiveshapes` para descargar la carpeta `Recursion-RecursiveShapes` a tu computadora.
- 
-2. Compila y corre el programa para que veas una figura del copo de nieve construida con 3 iteraciones de la función `snowflake`. Puedes ver el código que define esta función en el archivo `snowflake.cpp` del proyecto de `Qt`.
-
-    En la función `main`, busca la línea en donde se declara y dá valor a la variable `level`. Cambia el valor de `level` a `0` y corre el programa de nuevo. Podrás ver el triángulo que representa el caso base de la recursión para el copo de nieve. Continúa cambiando el valor de la variable `level` y corriendo el programa para que veas el proceso de la recursión y de producir figuras auto-similares.
-
-
-###Ejercicio 2: Cajas autosimilares
-
-Tu tarea en este ejercicio es programar una función recursiva `boxes`, en el archivo `boxes.cpp`, que produzca las siguientes figuras. 
-
----
-
-![figure6.jpg](images/figure6.jpg)
-
-**Figura 6.** Ilustración de las figuras de cajas que debe producir tu programa.
-
----
-
-La función recursiva `boxes` incluye tres parámetros: `sideLength`, `shrinkFactor`, y `smallestLength`.
-
-* `sideLength`: un entero que determina el largo de los lados del cuadrado más grande.
-* `shrinkFactor`: un número real que determina la razón del siguiente nivel de cuadrados. Por ejemplo, si `sideLength` es `100`, y `shrinkFactor` es `0.3`, el largo de los lados del cuadrado más grande será `100` unidades, y el largo de los lados del próximo cuadrado más pequeño  será `100*.3=30` unidades. Se colocan 4 copias de ese cuadrado más pequeño dentro del cuadrado anterior, **un cuadrado en cada esquina**.
-* `smallestLength`: es un valor entero que determina el largo del lado del cuadrado más pequeño que será dibujado. Por ejemplo, en la Figura 6, `boxes(400, 0.4, 200)` solo dibuja el cuadrado con lados de largo `400`, ya que el tamaño que le seguiría sería `400 * 0.4 = 160`, que es más pequeño que `200`. Por otro lado, `boxes(400, 0.4, 75)` dibuja el cuadrado de tamaño `400` y los cuadrados de tamaño `160`, pero no los siguientes en tamaño, porque serían de tamaño `160 * 0.4 = 64`, que es menor que `75`.
-
-####Instrucciones
-
-1. Estudia la función `box` incluida en el archivo `boxes.cpp`. Esta función recibe como argumentos las coordenadas de la esquina superior izquierda, el largo de los lados y el color de una caja. La función dibuja una caja con esas especificaciones.
-
-2. Escribe un algoritmo recursivo para la función `boxes` descrita arriba. ¡Recuerda incluir el caso base! El algoritmo también debe invocar la función `box` para dibujar las cajas. 
-
-3. Implementa la función en `QtCreator`. Necesitarás proveer parámetros adicionales a tu función para que puedas controlar la posición y el color de los cuadrados. 
-
-4. Invoca la función `boxes` desde la función main en el archivo `main.cpp`. Compara tus resultados con las imágenes de la Figura 6.
-
-
----
-
----
-
-##Entrega
-
-Utiliza "Entrega" en Moodle para entregar los archivos `boxes.cpp` y `main.cpp`. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
-
-
----
-
----
-
-
-## Referencias
-
-[1] https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-6-turtle-recursion.
-
-[2] "Mandel zoom 00 mandelbrot set". Licensed under Creative Commons Attribution-Share Alike 3.0 via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Mandel_zoom_00_mandelbrot_set.jpg#mediaviewer/File:Mandel_zoom_00_mandelbrot_set.jpg
-
-[3] "Mandel zoom 04 seehorse tail". Licensed under Creative Commons Attribution-Share Alike 3.0 via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Mandel_zoom_04_seehorse_tail.jpg#mediaviewer/File:Mandel_zoom_04_seehorse_tail.jpg
-
-[4] http://www.coolmath.com/fractals/images/fractal5.gif
-
-[5] "Fractal tree (Plate b - 2)". Licensed under Public domain via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Fractal_tree_(Plate_b_-_2).jpg#mediaviewer/File:Fractal_tree_(Plate_b_-_2).jpg
-
----
-
----
-
----
-
-
-[English](#markdown-header-recursion-recursive-shapes) | [Español](#markdown-header-recursion-figuras-recursivas)
-
-#Recursion - Recursive Shapes
-
-![main1.jpg](images/main1.jpg)
-![main2.jpg](images/main2.jpg)
-![main3.png](images/main3.png)
-
-One commonly used programming technique is *recursion*. With this technique, problems are solved by solving similar problems but for smaller cases. We can construct sets of objects or tasks using *recursive rules* and *initial values*. *Recursive functions* are functions that are self-invoking, using smaller sets or elements each time, until reaching a point where an initial value is used instead of self-invoking. Fractals are an example of figures that can be created using recursion. In this laboratory experience you will practice the definition and implementation of recursive functions to draw self-similar objects (fractals). 
-
-The exercises in this laboratory experience are an adaptation of https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-6-turtle-recursion.
-
-##Objectives:
-
-1. Practice the definition and implementation of recursive functions.
-
-
-
-##Pre-Lab:
-
-Before coming to the laboratory session you should have:
-
-1. Reviewed the basic concepts related to recursive functions.
-
-2. Studied the `box` function to draw boxes, included in the `boxes.cpp` file in the `Qt` project.
-
-3. Studied the concepts and instructions related to the laboratory session.
-
-4. Taken the Pre-Lab quiz available through the course’s Moodle portal.
-
----
-
----
-
-
-##Self-similar forms
-
-![figure2.png](images/figure2.png)
-
-**Figure 2.** Fractal tree [5].
-
----
-
-One ingenious way of practicing and visualize recursion is programming functions that produce recursive figures, or fractals. For example, consider a recursive figure that we'll call *branch*. Figure 3 shows `branch(0,90)`, `branch(1,90)`, and `branch(2,90)`.
-
----
-
-![figure3.jpg](images/figure3.jpg)
-
-**Figure 3.** (a) `branch(0,90)`, (b) `branch(1,90)`, y (c) `branch(2,90)`. 
-
----
-
-Can you see the recursive behavior in this figure? Notice that `branch(0,90)` is only a vertical segment (a segment in an angle of 90 degrees); `branch(1,90)` is `branch(0,90)` with two segments inclined in its top. More precisely, `branch(1,90)` is `branch(0,90)` with a `branch(0,60)` and a `branch(0,120)` in its top. Similarly, `branch(2,90)` is `branch(0,90)` with two `branch(1,90)` inclined in the top. That is, `branch(2,90)` is:
-`branch(0,90)` with a `branch(1,60)` and a `branch(1,120)` in its top. Notice that $$60=90-30$$ and $$120=90+30$$.
-
-This way we can express `branch(n,A)` as a composition of branches with smaller inclined $$n$$'s. Code 1 provides a way of expressing `branch` as a recursive function.
-
----
-
-```
-branch(0, A) = draws a segment of length L and angle A
-branch(n, A) = draws: branch(0,A), branch(n-1,A-30), branch(n-1,A+30)
-```
-
-**Code 1.** Function to draw branches.
-
----
-
-Notice that the recursive definition includes a base case, that is, includes `branch(0,A)`, and a recurrence relation, that is, `branch(n,A)`. To simplify, we assume that `branch(n-1,A-30)` and `branch(n-1,A+30)` are drawn at the top of `branch(0,A)`.
-
-Figure 4 illustrates the recursive expansion for `branch(2,90)`. The color of each expression is the corresponding segment color in the figure.
-
----
-
-![figure4.jpg](images/figure4.jpg)
-
-**Figure 4.** Illustration for `branch(2,90)`.
-
----
- 
-Can you predict how the next iteration for the figure will look? That is, what figure will `branch(3,A)` produce?
-
----
-
----
-
-##Laboratory Session
-
-In today's laboratory experience you will implement recursive functions to produce fractals.
-
-###Exercise 1: Snowflake
-
-One of the simplest fractal figures is the snowflake. This figure is formed by an isosceles triangle, substituting the middle third segment on each side by an inverted "V". The measurements of each side of the "V" is equal to the measurements of the segment it substitutes. We will use the snowflake to illustrate the process of recursion.
-
----
-
-![figure5.png](images/figure5.png)
-
-**Figure 5.** Part of the construction of the snowflake fractal.
-
----
-
-####Instructions
-
-1. Load the project `RecursiveShapes` onto `QtCreator` by double clicking on the `RecursiveShapes.pro` file in the `Documents/eip/Recursion-RecursiveShapes` folder of your computer. You may also go to `http://bitbucket.org/eip-uprrp/recursion-recursiveshapes` to download the `Recursion-RecursiveShapes` folder to your computer.
-
-2. Compile and run the program so you see a snowflake figure constructed with 3 iterations of the `snowflake` function. You can see the code of this function in the `snowflake.cpp` file of the `Qt` project.
-
-In the `main` function, look up the line where the variable `level` is declared and given a value. Change the value of `level` to `0` and run the program. You'll be able to see the triangle that represents the recursive base case for the snowflake. Continue changing the value for `level` and running the program so you can see the recursion process and produce self-similar figures.
-
-
-###Exercise 2: Self-similar boxes
-
-In this exercise, your task is to program a recursive function `boxes`, in the file `boxes.cpp`, that produces the following figures.
-
----
-
-![figure6.jpg](images/figure6.jpg)
-
-**Figure 6.** Illustration of the box figures that your program should produce.
-
----
-
-The `boxes` recursive function includes three parameters: `sideLength`, `shrinkFactor`, and `smallestLength`.
-
-* `sideLength`: an integer that determines the length of the sides of the largest box.
-* `shrinkFactor`: a real number that determines the rate of the next level of boxes. For example, if `sideLength` is `100`, and `shrinkFactor` is `0.3`, the length of the sides of the largest box will be `100` units, and the length of the sides of the smallest box will be `100*.3=30` units. Four copies of that smaller box are placed within the previous box, **one box in each corner**.
-* `smallestLength`: is an integer that determines the length of the sides of the smallest box that will be drawn. For example, in Figure 6, `boxes(400,0.4,200)` only draws the box with sides of length `400`, since the size that will follow will be `400 * 0.4 = 160`, which is smaller than `200`. On the other hand, `boxes(400, 0.4, 75)` draws the box of size `400` and the boxes with size `160`, but not the following ones in size, since they would be of size `160 * 0.4 = 64`, which is less than `75`.
-
-####Instructions
-
-1. Study the `box` function included in the `boxes.cpp` file. This function receives as arguments the coordinates of the upper left corner, the length of the sides and the color of the box. The function draws a box with these specifications. 
-
-2. Write a recursive algorithm for the `boxes` function described above. Remember to include the base case! The algorithm should also invoke the `box` function to draw the boxes.
-
-3. Implement the function in `QtCreator`. You will need to provide additional parameters to your function so you can control the position and the color of the squares.
-
-4. Invoke the `boxes` function from the `main` function in the `main.cpp` file. Compare your results with the images in Figure 6.
-
-
-
----
-
----
-
-##Deliverables
-
-1. Use "Deliverables" in Moodle to upload the `boxes.cpp` and `main.cpp` files. Remember to use good programming techniques, include the names of the programmers involved, and to document your program.
-
-
----
-
----
-
-##References
-
-[1] https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-6-turtle-recursion.
-
-[2] "Mandel zoom 00 mandelbrot set". Licensed under Creative Commons Attribution-Share Alike 3.0 via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Mandel_zoom_00_mandelbrot_set.jpg#mediaviewer/File:Mandel_zoom_00_mandelbrot_set.jpg
-
-[3] "Mandel zoom 04 seehorse tail". Licensed under Creative Commons Attribution-Share Alike 3.0 via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Mandel_zoom_04_seehorse_tail.jpg#mediaviewer/File:Mandel_zoom_04_seehorse_tail.jpg
-
-[4] http://www.coolmath.com/fractals/images/fractal5.gif
-
-[5] "Fractal tree (Plate b - 2)". Licensed under Public domain via Wikimedia Commons - http://commons.wikimedia.org/wiki/File:Fractal_tree_(Plate_b_-_2).jpg#mediaviewer/File:Fractal_tree_(Plate_b_-_2).jpg
+## [\[English\]](README-en.md) - for README in English
+## [\[Spanish\]](README-es.md) - for README in Spanish