updated sources and README

README.md

 ##Funciones
 
 
-En matemática, una función $$f$$ es una regla que se usa para asignar a cada elemento $$x$$ de un conjunto que se llama *dominio*, uno (y solo un) elemento $$y$$ de un conjunto que se llama *campo de valores*. Por lo general, esa regla se representa como una ecuación, $$y=f(x)$$. La variable $$x$$ es el parámetro de la función y la variable $$y$$ contendrá el resultado de la función. Una función puede tener más de un parámetro pero solo un resultado. Por ejemplo, una función puede tener la forma $$y=f(x_1,x_2)$$ en donde hay dos parámetros y para cada par $$(a,b)$$ que se use como argumento de la función, la función tiene un solo valor de $$y=f(a,b)$$. El dominio de la función te dice el tipo de valor que debe tener el parámetro y el campo de valores el tipo de valor que tendrá el resultado que devuelve la función.
+En matemática, una función $f$ es una regla que se usa para asignar a cada elemento $x$ de un conjunto que se llama *dominio*, uno (y solo un) elemento $y$ de un conjunto que se llama *campo de valores*. Por lo general, esa regla se representa como una ecuación, $y=f(x)$. La variable $x$ es el parámetro de la función y la variable $y$ contendrá el resultado de la función. Una función puede tener más de un parámetro pero solo un resultado. Por ejemplo, una función puede tener la forma $y=f(x_1,x_2)$ en donde hay dos parámetros y para cada par $(a,b)$ que se use como argumento de la función, la función tiene un solo valor de $y=f(a,b)$. El dominio de la función te dice el tipo de valor que debe tener el parámetro y el campo de valores el tipo de valor que tendrá el resultado que devuelve la función.
 
 Las funciones en lenguajes de programación de computadoras son similares. Una función 
 tiene una serie de instrucciones que toman los valores asignados a los parámetros y realiza alguna tarea. En C++ y en algunos otros lenguajes de programación,  las funciones solo pueden devolver un resultado, tal y como sucede en matemáticas. La única diferencia es que una función en programación puede que no devuelva valor (en este caso la función se declara `void`). Si la función va a devolver algún valor, se hace con la instrucción `return`. Al igual que en matemática tienes que especificar el dominio y el campo de valores, en programación tienes que especificar los tipos de valores que tienen los parámetros y el resultado que devuelve la función; esto lo haces al declarar la función.
 
 Por ejemplo,
 
-```cpp
-int ejemplo(int var1, float var2, char &var3)
-```
+`int ejemplo(int var1, float var2, char &var3)`
 
 sería el encabezado de la función llamada `ejemplo`, que devuelve un valor entero. La función recibe como argumentos un valor entero (y guardará una copia en `var1`), un valor de tipo `float` (y guardará una copia en `var2`) y la referencia a una variable de tipo  `char` que se guardará en la variable de referencia `var3`. Nota que `var3` tiene el signo `&` antes del nombre de la variable. Esto indica que `var3` contendrá la referencia a un caracter.
 
 
 Si queremos guardar el valor del resultado de la función `ejemplo` en la variable `resultado` (que deberá ser de tipo entero), invocamos la función pasando argumentos de manera similar a:
 
-```cpp
-resultado = ejemplo(2, 3.5, unCar);
-```
+`resultado=ejemplo(2, 3.5, unCar);`
 
 Nota que al invocar funciones no incluyes el tipo de las variables en los argumentos. Como en la definición de la función `ejemplo` el tercer parámetro `&var3` es una variable de referencia, lo que se está enviando en el tercer argumento de la invocación es una *referencia* a la variable `unCar`. Los cambios que se hagan en la variable `var3` están cambiando el contenido de la variable `unCar`.
 
 También puedes usar el resultado de la función sin tener que guardarlo en una variable. Por ejemplo puedes imprimirlo:
 
-```cpp
-cout << "El resultado de la función ejemplo es:" << ejemplo(2, 3.5, unCar);
-```
+`cout << "El resultado de la función ejemplo es:" << ejemplo(2, 3.5, unCar);`
 
 o utilizarlo en una expresión aritmética:
 
-```
-y = 3 + ejemplo(2, 3.5, unCar);
-```
+`y=3 + ejemplo(2, 3.5, unCar);`
+
 
 
 
 
 Los siguientes prototipos de funciones tienen la misma firma:
 
-```cpp
+```
 int ejemplo(int, int) ;
 void ejemplo(int, int) ; 
 string ejemplo(int, int) ;
 
 Los siguientes prototipos de  funciones tienen firmas diferentes:
 
-```cpp
+```
 int ejemplo(int) ;
 int olpmeje(int) ;
 ```
 
 Los siguientes prototipos de funciones son versiones sobrecargadas de la función `ejemplo`:
 
-```cpp
+```
 int ejemplo(int) ;
 void ejemplo(char) ;
 int ejemplo(int, int) ;
 2. `int ejemplo(int var1=1, float var2, int var3=10)` Este encabezado es inválido porque no se pueden poner parámetros sin valores en medio de parámetros con valores por defecto. En este caso  `var2` no tiene valor pero `var1` y `var3` si.
 
 
+
+---
+
 ---
 
 ##Ecuaciones paramétricas
 
-Las *ecuaciones paramétricas* nos permiten representar una cantidad como función de una o más variables independientes llamadas *parámetros*. En muchas ocasiones resulta útil representar curvas utilizando un conjunto de ecuaciones paramétricas que expresen las coordenadas de los puntos de la curva como funciones de los parámetros. Por ejemplo, en tu curso de trigonometría debes haber estudiado que la ecuación de un círculo con radio $$r$$ y centro en el origen tiene una forma así: 
+Las *ecuaciones paramétricas* nos permiten representar una cantidad como función de una o más variables independientes llamadas *parámetros*. En muchas ocasiones resulta útil representar curvas utilizando un conjunto de ecuaciones paramétricas que expresen las coordenadas de los puntos de la curva como funciones de los parámetros. Por ejemplo, en tu curso de trigonometría debes haber estudiado que la ecuación de un círculo con radio $r$ y centro en el origen tiene una forma así: 
 
 $$x^2+y^2=r^2.$$
 
 
-Los puntos $$(x,y)$$ que satisfacen esta ecuación son los puntos que forman el círculo de radio $$r$$ y centro en el origen.  Por ejemplo, el círculo con $$r=2$$ y centro en el origen tiene ecuación
+Los puntos $(x,y)$ que satisfacen esta ecuación son los puntos que forman el círculo de radio $r$ y centro en el origen.  Por ejemplo, el círculo con $r=2$ y centro en el origen tiene ecuación
 
 $$x^2+y^2=4,$$
 
-y sus puntos son los pares ordenados $$(x,y)$$ que satisfacen esa ecuación. Una forma paramétrica de expresar las coordenadas de los puntos del círculo con radio $$r$$ y centro en el origen es: 
+y sus puntos son los pares ordenados $(x,y)$ que satisfacen esa ecuación. Una forma paramétrica de expresar las coordenadas de los puntos del círculo con radio $r$ y centro en el origen es: 
 
 $$x=r \cos(t)$$
 
 $$y=r \sin(t),$$
 
-donde $$t$$ es un parámetro que corresponde a la medida (en radianes) del ángulo positivo con lado inicial que coincide con la parte positiva del eje de $$x$$, y lado terminal que contiene el punto $$(x,y)$$, como se muestra en la Figura 1.
+donde $t$ es un parámetro que corresponde a la medida (en radianes) del ángulo positivo con lado inicial que coincide con la parte positiva del eje de $x$, y lado terminal que contiene el punto $(x,y)$, como se muestra en la Figura 1.
 
 
 ---
 
 ![circulo.jpg](images/circulo.jpg)
 
-<b>Figura 1.</b> Círculo con centro en el origen y radio $$r$$.
+<b>Figura 1.</b> Círculo con centro en el origen y radio $r$.
 
 
 ---
 
-Para graficar una curva que está definida usando ecuaciones paramétricas, computamos los valores de $$x$$ y $$y$$ para un conjunto de valores del parámetro. Por ejemplo, para $$r = 2$$, algunos de los valores son
+Para graficar una curva que está definida usando ecuaciones paramétricas, computamos los valores de $x$ y $y$ para un conjunto de valores del parámetro. Por ejemplo, para $r = 2$, algunos de los valores son
 
 ---
 
-| $$t$$ | $$x$$ | $$y$$ |
+| $t$ | $x$ | $y$ |
 |-----|-----|-----|
-| $$0$$ | $$2$$ | $$0$$ |
-| $$\frac{\pi}{4}$$ | $$\frac{\sqrt{2}}{2}$$ | $$\frac{\sqrt{2}}{2}$$ |
-| $$\frac{\pi}{2}$$ | $$0$$ | $$2$$ |
+| $0$ | $2$ | $0$ |
+| $\frac{\pi}{4}$ | $\frac{\sqrt{2}}{2}$ | $\frac{\sqrt{2}}{2}$ |
+| $\frac{\pi}{2}$ | $0$ | $2$ |
 
 
-**Figura 2.** Algunas coordenadas de los puntos $$(x,y)$$ del círculo con radio $$r=2$$ y centro en el origen.
+**Figura 2.** Algunas coordenadas de los puntos $(x,y)$ del círculo con radio $r=2$ y centro en el origen.
 
 ---
 
     **Figura 3.** Gráfica de un círculo de radio 5 y centro en el origen desplegada por el programa *PrettyPlot*.
     
     ---
-    
+
+
 3. Abre el archivo `main.cpp` (en Sources).  Estudia la función `illustration` y su invocación desde la función `main`. Nota que las variables `argValue` y `argRef` están inicializadas a 0 y que la invocación a `illustration` hace un pase por valor de `argValue` y un pase por referencia de `argRef`. Nota también que a los parámetros correspondientes en `illustration` se les asigna el valor 1.
 
 4. Ejecuta el programa y observa lo que se despliega en la ventana `Application Output`. Nota la diferencia entre el contenido las variables `argValue` y `argRef` a pesar de que ambas tenían el mismo valor inicial y de que a `paramValue` y `paramRef` se les asignó el mismo valor. Explica por qué el contenido de `argValor` no cambia, mientras que el contenido de `argRef` cambia de 0 a 1.
 
 **Instrucciones**
 
-1. Estudia el código de la función `main()` del archivo `main.cpp`. La línea `XYPlotWindow wCircleR5;` crea el objeto `wCircleR5` que será la ventana en donde se dibujará una gráfica, en este caso la gráfica de un círculo de radio 5. De manera similar se crean los objetos `wCircle` y `wButterfly`. Observa el ciclo `for`. En este ciclo se genera una serie de valores para el ángulo $$t$$ y se invoca la función `circle`, pasándole el valor de $$t$$ y las referencias a $$x$$ y $$y$$. La función `circle` no devuelve valor pero, usando parámetros por referencia, calcula valores para las coordenadas $$xCoord$$ y $$yCoord$$ del círculo con centro en el origen y radio 5 y permite que la función `main` tenga esos valores en las variables `x` , `y`. 
+1. Estudia el código de la función `main()` del archivo `main.cpp`. La línea `XYPlotWindow wCircleR5;` crea el objeto `wCircleR5` que será la ventana en donde se dibujará una gráfica, en este caso la gráfica de un círculo de radio 5. De manera similar se crean los objetos `wCircle` y `wButterfly`. Observa el ciclo `for`. En este ciclo se genera una serie de valores para el ángulo $t$ y se invoca la función `circle`, pasándole el valor de $t$ y las referencias a $x$ y $y$. La función `circle` no devuelve valor pero, usando parámetros por referencia, calcula valores para las coordenadas $xCoord$ y $yCoord$ del círculo con centro en el origen y radio 5 y permite que la función `main` tenga esos valores en las variables `x` , `y`. 
 
-    Luego de la invocación, cada par ordenado $$(x,y)$$  es añadido a la gráfica del círculo por el método `AddPointToGraph(x,y)`. Luego del ciclo se invoca el método `Plot()`, que "dibuja" los puntos, y el método `show()`, que muestra la gráfica. Los *métodos* son funciones que nos permiten trabajar con los datos de los objetos. Nota que cada uno de los métodos se escribe luego de `wCircleR5`, seguido de un punto. En una experiencia de laboratorio posterior aprenderás más sobre objetos y practicarás cómo crearlos e invocar sus métodos.
 
-    La función `circle` implementada en el programa es muy restrictiva ya que siempre calcula los valores para las coordenadas $$x$$ y $$y$$ del mismo círculo: el círculo con centro en el origen y radio 5.
+    Luego de la invocación, cada par ordenado $(x,y)$  es añadido a la gráfica del círculo por el método `AddPointToGraph(x,y)`. Luego del ciclo se invoca el método `Plot()`, que "dibuja" los puntos, y el método `show()`, que muestra la gráfica. Los *métodos* son funciones que nos permiten trabajar con los datos de los objetos. Nota que cada uno de los métodos se escribe luego de `wCircleR5`, seguido de un punto. En una experiencia de laboratorio posterior aprenderás más sobre objetos y practicarás cómo crearlos e invocar sus métodos.
 
-2. Ahora crearás una función sobrecargada `circle` que reciba como argumentos el valor del ángulo $$t$$, la referencia a las variables $$x$$ y $$y$$, y el valor para el radio del círculo. Invoca desde `main()` la función sobrecargada  `circle` que acabas de implementar para calcular los valores de las coordenadas $$x$$ y $$y$$ del círculo con radio 15 y dibujar su gráfica. Grafica el círculo dentro del objeto `wCircle`. Para esto, debes invocar desde `main()` los métodos `AddPointToGraph(x,y)`, `Plot` y `show`. Recuerda que éstos deben ser precedidos por `wCircle`, por ejemplo, `wCircle.show()`.
+    La función `circle` implementada en el programa es muy restrictiva ya que siempre calcula los valores para las coordenadas $x$ y $y$ del mismo círculo: el círculo con centro en el origen y radio 5.
+
+2. Ahora crearás una función sobrecargada `circle` que reciba como argumentos el valor del ángulo $t$, la referencia a las variables $x$ y $y$, y el valor para el radio del círculo. Invoca desde `main()` la función sobrecargada  `circle` que acabas de implementar para calcular los valores de las coordenadas $x$ y $y$ del círculo con radio 15 y dibujar su gráfica. Grafica el círculo dentro del objeto `wCircle`. Para esto, debes invocar desde `main()` los métodos `AddPointToGraph(x,y)`, `Plot` y `show`. Recuerda que éstos deben ser precedidos por `wCircle`, por ejemplo, `wCircle.show()`.
 
 ###Ejercicio 3
 
 **Instrucciones**
 
 1. Ahora crearás una función para calcular las coordenadas de los puntos de la gráfica que parece una mariposa. Las ecuaciones paramétricas para las coordenadas de los puntos de la gráfica están dadas por:
-    
+
+
+
     $$x=5\cos(t) \left[ \sin^2(1.2t) + \cos^3(6t) \right]$$
     $$y= 10\sin(t) \left[ \sin^2(1.2t) +  \cos^3(6t) \right].$$
-    
-    Observa que ambas expresiones son casi iguales, excepto que una comienza con $$5\cos(t)$$ y la otra con $$10\sin(t)$$. En lugar de realizar el cómputo de $$ \sin^2(1.2t) + \cos^3(6t)$$ dos veces, puedes asignar su valor a otra variable $$q$$ y realizar el cómputo así:
-    
+
+
+    Observa que ambas expresiones son casi iguales, excepto que una comienza con $5\cos(t)$ y la otra con $10\sin(t)$. En lugar de realizar el cómputo de $ \sin^2(1.2t) + \cos^3(6t)$ dos veces, puedes asignar su valor a otra variable $q$ y realizar el cómputo así:
+
     $$q =  \sin^2(1.2t) + \cos^3(6t)$$
     $$x = 5 \cos(t)(q)$$
     $$y = 10  \sin(t)(q).$$
+
     
 2. Implementa la función `butterfly` utilizando las expresiones de arriba, invoca la función desde `main()` y observa la gráfica que resulta. Se supone que parezca una mariposa. Esta gráfica debe haber sido obtenida dentro de un objeto `XYPlotWindow` llamado `wButterfly`, invocando métodos de manera similar a como hiciste en el Ejercicio 2 para el círculo.
 
 
 ---
 
+---
 
 ##Entregas
 
 Utiliza "Entrega" en Moodle para entregar el archivo `main.cpp` que contiene las funciones que implementaste, las invocaciones y  cambios que hiciste en los ejercicios 2 y 3. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
 
+
+
+---
+
 ---
 
 ##Referencias
 
 ---
 
+---
+
 ##Functions
 
-In mathematics, a function $$f$$ is a rule that is used to assign to each element $$x$$ from a set called *domain*, one (and only one) element $$y$$ from a set called *range*. This rule is commonly represented with an equation, $$y=f(x)$$. The variable $$x$$ is the parameter of the function and the variable $$y$$ will contain the result of the function. A function can have more than one parameter, but only one result. For example, a  function can have the form $$y=f(x_1,x_2)$$ where there are two parameters, and for each pair $$(a,b)$$ that is used as an argument in the function, the function has only one value of $$y=f(a,b)$$. The domain of the function tells us the type of value that the parameter should have and the range tells us the value that the returned result will have.
+In mathematics, a function $f$ is a rule that is used to assign to each element $x$ from a set called *domain*, one (and only one) element $y$ from a set called *range*. This rule is commonly represented with an equation, $y=f(x)$. The variable $x$ is the parameter of the function and the variable $y$ will contain the result of the function. A function can have more than one parameter, but only one result. For example, a  function can have the form $y=f(x_1,x_2)$ where there are two parameters, and for each pair $(a,b)$ that is used as an argument in the function, the function has only one value of $y=f(a,b)$. The domain of the function tells us the type of value that the parameter should have and the range tells us the value that the returned result will have.
 
 Functions in programming languages are similar. A function has a series of instructions that take the assigned values as parameters and performs a certain task. In C++ and other programming languages, functions return only one result, as it happens in mathematics. The only difference is that a *programming* function could possibly not return any value (in this case the function is declared as `void`). If the function will return a value, we use the instruction `return`. As in math, you need to specify the types of values that the function's parameters and result will have; this is done when declaring the function.
 
 
 For example,
 
-```cpp
-int example(int var1, float var2, char &var3)
-```
+`int example(int var1, float var2, char &var3)`
 
 would be the header of the function called `example`, which returns an integer value. The function receives as arguments an integer value (and will store a copy in `var1`), a value of type `float` (and will store a copy in `var2`) and the reference to a variable of type `char` that will be stored in the reference variable `var3`. Note that `var3` has a & symbol before the name of the variable. This indicates that `var3` will contain the reference to a character.
 
 
 If we want to store the value of the `example` function's result in a variable `result` (that would be of type integer), we invoke the function by passing arguments as follows:
 
-```cpp
-result = example(2, 3.5, unCar);
-```
+`result=example(2, 3.5, unCar);`
 
 Note that as the function is invoked, you don't include the type of the variables in the arguments. As in the definition for the function `example`, the third parameter `&var3` is a reference variable; what is being sent to the third argument when invoking the function is a *reference* to the variable `unCar`. Any changes that are made on the variable `var3` will change the contents of the variable `unCar`.
 
 You can also use the function's result without having to store it in a variable. For example you could print it:
 
-```cpp
-cout << "The result of the function example is:" << example(2, 3.5, unCar);
-```
+`cout << "The result of the function example is:" << example(2, 3.5, unCar);`
 
 or use it in an arithmetic expression:
 
-```cpp
-y = 3 + example(2, 3.5, unCar);
-```
+`y=3 + example(2, 3.5, unCar);`
+
+
+
 
 
 ###Overloaded functions
 
 The following function prototypes have the same signature:
 
-```cpp
+```
 int example(int, int) ;
 void example(int, int) ; 
 string example(int, int) ;
 
 The following function prototypes have different signatures:
 
-```cpp
+```
 int example(int) ;
 int elpmaxe(int) ;
 ```
 
 The following function prototypes are overloaded versions of the function `example`:
 
-```cpp
+```
 int example(int) ;
 void example(char) ;
 int example(int, int) ;
 **Examples of function headers and valid invocations:**
 
 1. **Headers:** `int example(int var1, float var2, int var3 = 10)` Here `var3` is initialized to 10.
-    
+
     **Invocations:**
 
     a. `example(5, 3.3, 12)` This function call assigns the value 5 to `var1`, the value 3.3 to `var2`, and the value of 12 to `var3`.
 Here `var2` is initialized to 5 and `var3` to 10.
 
     **Invocations:**
-    
+
+
     a. `example(5, 3.3, 12)` This function call assigns the value 5 to `var1`, the value 3.3 to `var2`, and the value 12 to `var3`.
 
     b. `example(5, 3.3)` In this function call only the first two parameters are given values, and the value for the last parameter is the value by default. That is, the value for `var1` within the function will be 5, that of `var2` will be 3.3, and `var3` will be 10.
 
 **Example of a valid function header with invalid invocations:**
 1. **Header:** `int example(int var1, float var2=5.0, int var3 = 10)` 
-    
+
+
     **Invocation:**
 
     a. `example(5, , 10)` This function call is **invalid** because it leaves an empty space in the middle argument.
 2. `int example(int var1=1, float var2, int var3=10)` This header is invalid because you can't place parameters without values between other parameters with default values. In this case, `var2` doesn't have a default value but `var1` and `var3` do.
 
 
+---
 
 ---
 
 ## Parametric equations
 
-*Parametric equations* allow us to represent a quantity as a function of one or more independent variables called *parameters*. In many occasions it is useful to represent curves using a set of parametric equations that express the coordinates of the points of the curve as functions of the parameters. For example, in your trigonometry course you should have studied that the equation of the circle of radius $$r$$ and centered at the origin has the following form:
+*Parametric equations* allow us to represent a quantity as a function of one or more independent variables called *parameters*. In many occasions it is useful to represent curves using a set of parametric equations that express the coordinates of the points of the curve as functions of the parameters. For example, in your trigonometry course you should have studied that the equation of the circle of radius $r$ and centered at the origin has the following form:
+
 
 $$x^2+y^2=r^2.$$
 
-The points $$(x,y)$$ that satisfy this equation are the points that form the circle of radius $$r$$ and center at the origin. For example, the circle with $$r=2$$ and center at the origin has equation
+The points $(x,y)$ that satisfy this equation are the points that form the circle of radius $r$ and center at the origin. For example, the circle with $r=2$ and center at the origin has equation
+
 
 $$x^2+y^2=4,$$
 
-and its points are the ordered pairs $$(x,y)$$ that satisfy this equation. A parametric representation of the coordinates of the points in the circle of radius $$r$$ and center at the origin is:
+and its points are the ordered pairs $(x,y)$ that satisfy this equation. A parametric representation of the coordinates of the points in the circle of radius $r$ and center at the origin is:
+
 
 $$x=r \cos(t)$$
 
-$$y=r \sin(t)$$,
+$$y=r \sin(t),$$
 
-where $$t$$ is a parameter that corresponds to the measure (in radians) of the positive angle  with initial side that coincides with the positive part of the $$x$$-axis and terminal side that contains the point $$(x,y)$$, as it is illustrated in Figure 1.
+where $t$ is a parameter that corresponds to the measure (in radians) of the positive angle  with initial side that coincides with the positive part of the $x$-axis and terminal side that contains the point $(x,y)$, as it is illustrated in Figure 1.
 
 
 ---
 
 ![circulo.jpg](images/circulo.jpg)
 
-<b>Figure 1.</b> Circle with center in the origin and radius $$r$$.
+<b>Figure 1.</b> Circle with center in the origin and radius $r$.
 
 
 ---
 
-To plot a curve that is described  by parametric equations, we compute the $$x$$ and $$y$$ values for a set of values of the parameter. For example, for $$r=2$$, some of the values are
+To plot a curve that is described  by parametric equations, we compute the $x$ and $y$ values for a set of values of the parameter. For example, for $r=2$, some of the values are
 
 
 ---
 
-| $$t$$ | $$x$$ | $$y$$ |
+| $t$ | $x$ | $y$ |
 |-----|-----|-----|
-| $$0$$ | $$2$$ | $$0$$ |
-| $$\frac{\pi}{4}$$ | $$\frac{\sqrt{2}}{2}$$ | $$\frac{\sqrt{2}}{2}$$ |
-| $$\frac{\pi}{2}$$ | $$0$$ | $$2$$ |
+| $0$ | $2$ | $0$ |
+| $\frac{\pi}{4}$ | $\frac{\sqrt{2}}{2}$ | $\frac{\sqrt{2}}{2}$ |
+| $\frac{\pi}{2}$ | $0$ | $2$ |
 
 
-**Figure 2.** Some coordinates for the points $$(x,y)$$ for the circle with radius $$r=2$$ and center in the origin.
+**Figure 2.** Some coordinates for the points $(x,y)$ for the circle with radius $r=2$ and center in the origin.
 
 ---
 
     **Figure 3.**  Graph of a circle with radius 5 and center in the origin displayed by the program *PrettyPlot*.
     
     ---
-    
+
 3. Open the file `main.cpp` (in Sources). Study the `illustration` function and how to call it from the `main` function. Note that the variables `argValue` and `argRef`are initialized to 0 and that the function call for `illustration` makes a pass by value of `argValue` and a pass by reference of `argRef`. Also note that the corresponding parameters in `illustration` are assigned a value of 1.
 
 4. Execute the program and observe what is displayed in the window `Application Output`. Notice the difference between the content of the variables `argValue` and `argRef` despite the fact that both had the same initial value, and that `paramValue` and `paramRef` were assigned the same value. Explain why the content of `argValor` does not change, while the content of `argRef` changes from 0 to 1.
 
 **Instructions**
 
-1. Study the code in the `main()` function in the file `main.cpp`. The line `XYPlotWindow wCircleR5;` creates a `wCircleR5` object that will be the window where the graph will be drawn, in this case the graph of a circle of radius 5. In a similar way, the objects `wCircle` and `wButterfly` are created. Observe the `for` cycle. In this cycle a series of values for the angle $$t$$ is generated and the function `circle` is invoked, passing the value for $$t$$ and the references to $$x$$ and $$y$$. The `circle` function does not return a value, but using parameters by reference, it calculates the values for the coordinates $$xCoord$$ and $$yCoord$$ for the circle with center in the origin and radius 5, and allows the `main` function  to have these values in the `x` , `y` variables.
+1. Study the code in the `main()` function in the file `main.cpp`. The line `XYPlotWindow wCircleR5;` creates a `wCircleR5` object that will be the window where the graph will be drawn, in this case the graph of a circle of radius 5. In a similar way, the objects `wCircle` and `wButterfly` are created. Observe the `for` cycle. In this cycle a series of values for the angle $t$ is generated and the function `circle` is invoked, passing the value for $t$ and the references to $x$ and $y$. The `circle` function does not return a value, but using parameters by reference, it calculates the values for the coordinates $xCoord$ and $yCoord$ for the circle with center in the origin and radius 5, and allows the `main` function  to have these values in the `x` , `y` variables.
 
-    After the function call, each ordered pair $$(x,y)$$ is added to the circle’s graph by the member function `AddPointToGraph(x,y)`. After the cycle, the member function `Plot()` is invoked, which draws the points, and the member function `show()`, which displays the graph. The *members functions* are functions that allow use to work with and object’s data. Notice that each one of the member functions is written after `wCircleR5`, followed by a period. In an upcoming laboratory experience you will learn more about objects, and practice how to create them and invoke their method functions.
+    After the function call, each ordered pair $(x,y)$ is added to the circle’s graph by the member function `AddPointToGraph(x,y)`. After the cycle, the member function `Plot()` is invoked, which draws the points, and the member function `show()`, which displays the graph. The *members functions* are functions that allow use to work with and object’s data. Notice that each one of the member functions is written after `wCircleR5`, followed by a period. In an upcoming laboratory experience you will learn more about objects, and practice how to create them and invoke their method functions.
 
-    The `circle` function implemented in the program is very restrictive since it always calculates the values for the coordinates $$x$$ and $$y$$ of the same circle: the circle with center in the origin and radius 5.
+    The `circle` function implemented in the program is very restrictive since it always calculates the values for the coordinates $x$ and $y$ of the same circle: the circle with center in the origin and radius 5.
 
-2. Now you will create an overloaded function `circle` that receives as arguments the value of the angle $$t$$, the reference to the variables $$x$$ and $$y$$, and the value for the radius of the circle. Invoke the overloaded function `circle` that you just implemented from `main()` to calculate the values of the coordinates $$x$$ and $$y$$ for the circle with radius 15 and draw its graph. Graph the circle within the `wCircle` object. To do this, you must invoke the method functions `AddPointToGraph(x,y)`, `Plot` and `show` from `main()`. Remember that these should be preceded by `wCircle`, for example, `wCircle.show()`.
+2. Now you will create an overloaded function `circle` that receives as arguments the value of the angle $t$, the reference to the variables $x$ and $y$, and the value for the radius of the circle. Invoke the overloaded function `circle` that you just implemented from `main()` to calculate the values of the coordinates $x$ and $y$ for the circle with radius 15 and draw its graph. Graph the circle within the `wCircle` object. To do this, you must invoke the method functions `AddPointToGraph(x,y)`, `Plot` and `show` from `main()`. Remember that these should be preceded by `wCircle`, for example, `wCircle.show()`.
 
 ###Exercise 3
 
 **Instructions**
 
 1. Now you will create a function to calculate the coordinates of the points of a graph that resembles a butterfly. The parametric equations for the coordinates of the points in the graph are given by:
-    
+
+
     $$x=5\cos(t) \left[ \sin^2(1.2t) + \cos^3(6t) \right]$$
     $$y= 10\sin(t) \left[ \sin^2(1.2t) +  \cos^3(6t) \right].$$
 
-    Observe that both expressions are almost the same, except that one starts with $$5\cos(t)$$ and the other with $$10\sin(t)$$. Instead of doing the calculation for $$ \sin^2(1.2t) + \cos^3(6t)$$ twice, you can assign its value to another variable $$q$$ and calculate it as such:
+    Observe that both expressions are almost the same, except that one starts with $5\cos(t)$ and the other with $10\sin(t)$. Instead of doing the calculation for $ \sin^2(1.2t) + \cos^3(6t)$ twice, you can assign its value to another variable $q$ and calculate it as such:
 
     $$q =  \sin^2(1.2t) + \cos^3(6t)$$
     $$x = 5 \cos(t)(q)$$
 In [3] you can find other parametric equations from other interesting curves.
 
 ---
+---
 
 ##Deliverables
 
 Use "Deliverables" in Moodle to hand in the file `main()` that contains the functions you implemented, the function calls and changes you made in exercises 2 and 3. Remember to use good programming techniques, include the name of the programmers involved and document your program.
 
+
+---
+
 ---
 
 ##References
 
 [2] http://paulbourke.net/geometry/butterfly/
 
-[3] http://en.wikipedia.org/wiki/Parametric_equation
+[3] http://en.wikipedia.org/wiki/Parametric_equation

main.cpp

 #include <QApplication>
 using namespace std;
 
-/// \fn void illustration(int paramValue, int &paramRef)
-/// \~English
-/// \brief This function is to illustrate the difference between
-/// pass by value and pass by reference
-/// \param paramValue parameter passed by value
-/// \param paramRef parameter passed by reference
-/// \~Spanish
-/// \brief  Esta funcion es para ilustrar la differencia entre
-/// variables pasadas por referencia y pasadas por valor
-/// \param paramValue parametro pasado por valor
-/// \param paramRef parametro pasado por referencia
+//**********************************************************
+// This function is to illustrate the difference between   *
+// pass by value and pass by reference                     *
+//**********************************************************
+
+
 void illustration(int paramValue, int &paramRef)
 {
     paramValue=1;
          << "The content of paramRef is: " << paramRef << endl;
 }
 
-/// \fn void circle(double p, double &xCoord, double &yCoord)
-/// \~English
-/// \brief Function to draw a circle
-/// \~Spanish
-/// \brief Funcion para dibujar un circulo
+//************************************
+// Functions circle                  *
+//************************************
+
 void circle(double p, double &xCoord, double &yCoord)
 {
     xCoord = 5 * cos(p);
     yCoord = 5 * sin(p);
 }
 
-//Overloaded Funcion circle /  Funcion circulo sobre cargada
+//Overloaded Funcion circle
 
-// YOUR CODE HERE / TU CODIGO AQUI
+// YOUR CODE HERE
 
 
-///************************************
-///Function butterfly                *
-///************************************
+//************************************
+// Function butterfly                *
+//************************************
 
-// YOUR CODE HERE / TU CODIGO AQUI
+// YOUR CODE HERE
 
 
 //***************
 // Function main *
 //***************
+
+
 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
     int argValue=0, argRef=0;
 
     // invoke the function illustration to view the contents of variables by value and by reference
-    // invoca la funcion ilustracion para ver los contenidos de variables por valor y por referencia
+
         illustration(argValue,argRef);
         cout << endl << "The content of argValue is: " << argValue << endl
              << "The content of argRef is: " << argRef << endl;
 
 
     // repeat for several values of the angle t
-    // repite para varios valores de el angulo t
     for (double t = 0; t < 16*M_PI; t = t + increment)
     {
         
         // invoke circle with the angle t and reference variables x, y as arguments
-        // invke circle con el angulo t y variables por referencia x, y como argumentos
         circle(t,x,y);
         
         // add the point (x,y) to the graph of the circle
-        // anade el punto (x,y) a la grafica de el circulo
         wCircleR5.AddPointToGraph(x,y);
         
         
         // invoke circle with the radius r, the angle t and reference variables x, y as arguments
-        // invoca circulo con el radio r, el angulo t y variables x, y como argumentos
       
-        // YOUR CODE HERE / TU CODIGO AQUI
+        // YOUR CODE HERE
         
         // add the point (x,y) to the graph of the circle
-        // anade el punto (x,y) to la grafica de el circulo
        
-        // YOUR CODE HERE / TU CODIGO AQUI
+        // YOUR CODE HERE
 
         
         // invoke butterfly with the angle t and reference variables x, y as arguments
-        // invoca butterfly con el angulo t y variables referencia x, y como argumentos
       
-        // YOUR CODE HERE / TU CODIGO AQUI
+        // YOUR CODE HERE
 
         // add the point (x,y) to the graph of the butterfly
-        // anade el punto (x,y) a la grafica de la mariposa
        
-        // YOUR CODE HERE / TU CODIGO AQUI
+        // YOUR CODE HERE
     }
 
     // After all the points have been added, plot and show the graphs
-    // Despues que todos los puntos sean anadidos, enseña las graficas.
     
     wCircleR5.Plot();
     wCircleR5.show();
     
-    // YOUR CODE HERE / TU CODIGO AQUI.
+    // YOUR CODE HERE
     
 
     return a.exec();

xyplotwindow.cpp

 #include "qcustomplot.h"
 #include <cmath>
 
-/// \fn XYPlotWindow::XYPlotWindow(QWidget *parent)
-/// \~English
-/// \brief Constructor
-/// \~Spanish
-/// \brief Constructor
 XYPlotWindow::XYPlotWindow(QWidget *parent) :
     QMainWindow(parent),
     ui(new Ui::XYPlotWindow)
     ui->setupUi(this);
 }
 
-/// \fn void XYPlotWindow::AddPointToGraph(double x, double y)
-/// \~English
-/// \brief Adds a coordinate (x,y) to the XX and YY vectors.
-/// \param x value of the coordinate (x,y) to be added to vector XX.
-/// \param y value of the coordinate (x,y) to be added to vector YY.
-/// \~Spanish
-/// \brief Anade una coordenada (x,y) a los vectores XX y YY.
-/// \param x valor de la coordenada (x,y) a ser anadido al vector XX.
-/// \param y valor de la coordenada (x,y) a ser anadido al vector YY.
+
+// Añade la x y y a sus respectivos vectores.
 void XYPlotWindow::AddPointToGraph(double x, double y) {
         XX.push_back(x);
         YY.push_back(y);
 }
 
-/// \fn void XYPlotWindow::Plot()
-/// \~English
-/// \brief Plots the coordinates inserted in the vectors XX and YY.
-/// \~Spanish
-/// \brief Grafica las coordenadas insertadas en los vectores XX y YY.
+// Esta función invoca los métodos apropiados de customPlot para que
+// se grafiquen los puntos.
 void XYPlotWindow::Plot() {
     ui->customPlot->xAxis->setLabel("x");
     ui->customPlot->yAxis->setLabel("y");
     myCurve->setData(XX,YY);
 }
 
-/// \fn XYPlotWindow::~XYPlotWindow()
-/// \~English
-/// \brief Destructor
-/// \~Spanish
-/// \brief Destructor
 XYPlotWindow::~XYPlotWindow()
 {
     delete ui;

xyplotwindow.h

     Q_OBJECT
 
 public:
-    /// \fn XYPlotWindow::XYPlotWindow(QWidget *parent)
-    /// \~English
-    /// \brief Constructor
-    /// \~Spanish
-    /// \brief Constructor
     explicit XYPlotWindow(QWidget *parent = 0);
-
-    /// \fn XYPlotWindow::~XYPlotWindow()
-    /// \~English
-    /// \brief Destructor
-    /// \~Spanish
-    /// \brief Destructor
+    //void setupgraph();
     ~XYPlotWindow();
-
-    /// \fn void XYPlotWindow::AddPointToGraph(double x, double y)
-    /// \~English
-    /// \brief Adds a coordinate (x,y) to the XX and YY vectors.
-    /// \param x value of the coordinate (x,y) to be added to vector XX.
-    /// \param y value of the coordinate (x,y) to be added to vector YY.
-    /// \~Spanish
-    /// \brief Anade una coordenada (x,y) a los vectores XX y YY.
-    /// \param x valor de la coordenada (x,y) a ser anadido al vector XX.
-    /// \param y valor de la coordenada (x,y) a ser anadido al vector YY.
     void AddPointToGraph(double x, double y);
-
-    /// \fn void XYPlotWindow::Plot()
-    /// \~English
-    /// \brief Plots the coordinates inserted in the vectors XX and YY.
-    /// \~Spanish
-    /// \brief Grafica las coordenadas insertadas en los vectores XX y YY.
     void Plot();