Como en el libro

README-en.md

-
 # Using functions in C++ - Pretty Plots
 
 
 
 [version 2016.01.29]
 
-A good way to organize and structure computer programs is dividing them into smaller parts using functions. Each function carries out a specific task of the problem  that we are solving.
+A good way to organize and structure computer programs is dividing them into smaller parts using functions. Each function carries out a specific task of the problem that we are solving.
 
-You've seen that all programs written in C++ must contain the `main` function where the program begins. You've probably already used functions such as `pow`, `sin`, `cos`, or `sqrt` from the `cmath` library. Since in almost all of the upcoming lab activities you will continue using pre-defined functions, you need to understand how to work with them. In future exercises you will learn how to design and validate functions. In this laboratory experience you will invoke and define functions that compute the coordinates of the points of the graphs of some curves. You will also practice the implementation of arithmetic expressions in C++.
+You've seen that all programs written in C++ must contain the `main` function where the program begins. You've probably already used functions such as `pow`, `sin`, `cos`, or `sqrt` from the `cmath` library. Since in almost all of the upcoming lab activities you will continue using pre-defined functions, you need to understand how to work with them. In future exercises you will learn how to design and validate functions. In this laboratory experience you will call and define functions that compute the coordinates of the points of the graphs of some curves. You will also practice the implementation of arithmetic expressions in C++.
 
 
 ## Objectives:
 
 1. Identify the parts of a function: return type, name, list of parameters, and body.
-2. Invoke pre-defined functions by passing arguments by value ("pass by value"), and by reference ("pass by reference").
+2. Call pre-defined functions by passing arguments by value ("pass by value"), and by reference ("pass by reference").
 3. Implement a simple overloaded function.
 4. Implement a simple function that utilizes parameters by reference.
 5. Implement arithmetic expressions in C++.
 
     a. the basic elements of a function definition in C++.
 
-    b. how to invoke functions in C++.
+    b. how to call functions in C++.
 
     c. the difference between parameters that are passed by value and by reference.
 
 
 2. Studied the concepts and instructions for the laboratory session.
 
-3. Taken the Pre-Lab quiz that can be found in Moodle.
 
 ---
 
 
 ## 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.
 
 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.
 
 
-### Invoking
+### Calling
 
 
-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:
+If we want to store the value of the `example` function's result in a variable `result` (that would be of type integer), we call the function by passing arguments as follows:
 
 `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`.
+Note that as the function is called, 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:
 
 
 or use it in an arithmetic expression:
 
-`y=3 + example(2, 3.5, unCar);`
+`y = 3 + example(2, 3.5, unCar);`
 
 
 
 
 
 
-### Values by default
+### Default values
 
 Values by default can be assigned to the parameters of the functions starting from the first parameter to the right. It is not necessary to initialize all of the parameters, but the ones that are initialized should be consecutive: parameters in between two parameters cannot be left uninitialized. This allows calling the function without having to send values in the positions that correspond to the initialized parameters.
 
-**Examples of function headers and valid invocations:**
+**Examples of function headers and valid function calls:**
 
 1. **Headers:** `int example(int var1, float var2, int var3 = 10)`
 
-    **Invocations:**
+    **Calls:**
 
     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`.
 
 
 2. **Header:** `int example(int var1, float var2=5.0, int var3 = 10)`
 
-    **Invocations:**
+    **Calls:**
 
     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`.
 
     c. `example(5)` In this function call only the first parameter is given a value, and the last two parameters will be assigned  values by default. That is, `var1` will be 5, `var2` will be 5.0, and `var3` will be 10.
 
 
-**Example of a valid function header with invalid invocations:**
+**Example of a valid function header with invalid function calls:**
 
 1. **Header:** `int example(int var1, float var2=5.0, int var3 = 10)`
 
-    **Invocation:**
+    **Calls:**
 
     a. `example(5, , 10)` This function call is **invalid** because it leaves an empty space in the middle argument.
 
-    b. `example()` This function call is **invalid** because `var1` was not assigned a default value. A valid invocation to the function `example` needs at least one argument (the first).
+    b. `example()` This function call is **invalid** because `var1` was not assigned a default value. A valid call to function `example` needs at least one argument (the first).
 
 
 **Examples of invalid function headers:**
 
 ## 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),$$
 
-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/circuloAngulo01.png)
 
-**Figure 1.** Circle with center in the origin and radius $r$.
+**Figure 1.** 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, Figure 2 shows the values for $$t$$, $$(x,y)$$ for the circle with $$r=2$$.
 
 
 ---
 
 ![circulo.jpg](images/circuloPuntos01.png)
 
-**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.
 
 ---
 
 ---
 
+
+!INCLUDE "../../eip-diagnostic/DVD/en/diag-dvd-01.html"
+<br>
+
+!INCLUDE "../../eip-diagnostic/DVD/en/diag-dvd-03.html"
+<br>
+
+!INCLUDE "../../eip-diagnostic/DVD/en/diag-dvd-11.html"
+<br>
+
+!INCLUDE "../../eip-diagnostic/DVD/en/diag-dvd-12.html"
+<br>
+
+
+---
+
+---
+
+
 ## Laboratory session:
 
 In the introduction to the topic of functions you saw that in mathematics and in some programming languages, a function cannot return more than one result. In this laboratory experience's exercises you will practice how to use reference variables to obtain various results from a function.
 
 **Instructions**
 
-1. Load the project `prettyPlot` in Qt by double clicking on the file `prettyPlot.pro` in the folder `Documents/eip/Functions-PrettyPlots` of your computer. You may also go to `http://bitbucket.org/eip-uprrp/functions-prettyplots` to download the folder `Functions-PrettyPlots` to your computer.
+1. Download the folder`Functions-PrettyPlots` from `Bitbucket` using the terminal, moving to the `Documents/eip` directory, and writing the command `git clone http://bitbucket.org/eip-uprrp/functions-prettyplots`.
 
-2. Configure the project and execute the program by clicking on the green arrow in the menu on the left side of the Qt Creator screen. The program should show a window similar to the one in Figure 3.
+2. Load the project `prettyPlot` in Qt Creator by double clicking on the file `prettyPlot.pro` in the folder `Documents/eip/functions-prettyplots` of your computer.
+
+3. Configure the project and execute the program by clicking on the green arrow in the menu on the left side of the Qt Creator screen. The program should show a window similar to the one in Figure 3.
 
     ---
 
 
     ---
 
-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. 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.
 
         void illustration(int paramValue, int &paramRef) {
             paramValue = 1;
                  << "The content of paramRef is: " << paramRef << endl;
         }
 
-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.
+5. 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.
 
 ### Exercise 2
 
 
 **Instructions**
 
-1. Study the code in the `main()` function in the file `main.cpp`.
+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$$ are generated and the function `circle` is called, 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.
 
         XYPlotWindow wCircleR5;
         XYPlotWindow wCircle;
         double increment = 0.01;
         int argValue=0, argRef=0;
 
-        // invoke the function illustration to view the contents of variables
+        // call the function illustration to view the contents of variables
         // by value and by reference
 
             illustration(argValue,argRef);
         // repeat for several values of the angle 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
+            // call circle with the angle t and reference variables x, y as arguments
             circle(t,x,y);
 
             // add the point (x,y) to the graph of the circle
             wCircleR5.AddPointToGraph(x,y);
 
-    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 called, 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. Call 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 call 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
 
 
     $$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)$$
 
 
     $$y = 10  \sin(t)(q).$$
 
-2. Implement the function `butterfly` using the expressions above, invoke the function in `main()` and observe the resulting graph. It is supposed to look like a butterfly. This graph should have been obtained with a `XYPlotWindow` object called `wButterfly`, invoking method functions similar to how you did in Exercise 2 for the circle.
+2. Implement the function `butterfly` using the expressions above, call the function in `main()` and observe the resulting graph. It is supposed to look like a butterfly. This graph should have been obtained with a `XYPlotWindow` object called `wButterfly`, invoking method functions similar to how you did in Exercise 2 for the circle.
 
 In [2] and [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.
+Use "Deliverables" in Moodle to hand in the file `main.cpp` 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.
 
 
 ---
 
 [2] http://paulbourke.net/geometry/butterfly/
 
-[3] http://en.wikipedia.org/wiki/Parametric_equation
+[3] http://en.wikipedia.org/wiki/Parametric_equation

README-es.md

-
 # Utilizando funciones en C++ - Gráficas Bonitas
 
 
 
 ## 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 pueden devolver a lo sumo 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.
 
 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:
 
-`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`.
 
 
 o utilizarlo en una expresión aritmética:
 
-`y=3 + ejemplo(2, 3.5, unCar);`
+`y = 3 + ejemplo(2, 3.5, unCar);`
 
 
 
 
 1. **Encabezado:** `int ejemplo(int var1, float var2, int var3 = 10)`
 
-     **Invocaciones:**
+   **Invocaciones:**
 
     a. `ejemplo(5, 3.3, 12)` Esta invocación asigna el valor 5 a `var1`, el valor 3.3 a `var2`, y el valor 12 a `var3`.
 
     b. `ejemplo(5, 3.3)`  Esta invocación envía valores para los primeros dos parámetros y el valor del último parámetro será el valor por defecto asignado en el encabezado. Esto es, los valores de las variables en la función serán: `var1` tendrá 5, `var2` tendrá 3.3, y `var3` tendrá 10.
 
-
 2. **Encabezado:** `int ejemplo(int var1, float var2=5.0, int var3 = 10)`
 
-    **Invocaciones:**
+   **Invocaciones:**
 
     a. `ejemplo(5, 3.3, 12)` Esta invocación asigna el valor 5 a `var1`, el valor 3.3 a `var2`, y el valor 12 a  `var3`.
 
 
     a. `ejemplo(5, ,10)` Esta invocación  es **inválida** porque   deja espacio vacío en el argumento del medio.
 
-    b. `ejemplo()` Esta invocación es **inválida** ya que `var1` no estaba inicializada y no recibe ningún valor en la invocación.
+    b. `ejemplo()` Esta invocación es **inválida** ya que `var1` no estaba inicializada y no recibe ningún valor en la invocación. Una invocación válida para la función `ejemplo` necesita al menos un argumento (el primero).
 
 **Ejemplos de encabezados de funciones inválidos:**
 
 
 ## 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/circuloAngulo01.png)
 
-**Figura 1.** Círculo con centro en el origen y radio $r$.
+**Figura 1.** 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, la Figura 2 resalta los valores de $t$, $(x,y)$ para el círculo con $r = 2$.
+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, la Figura 2 resalta los valores de $$t$$, $$(x,y)$$ para el círculo con $$r = 2$$.
 
 ---
 
 
 ![circulo.jpg](images/circuloPuntos01.png)
 
-**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.
 
 ---
 
 
 
 !INCLUDE "../../eip-diagnostic/DVD/es/diag-dvd-01.html"
+<br>
 
 !INCLUDE "../../eip-diagnostic/DVD/es/diag-dvd-03.html"
+<br>
 
 !INCLUDE "../../eip-diagnostic/DVD/es/diag-dvd-11.html"
+<br>
 
 !INCLUDE "../../eip-diagnostic/DVD/es/diag-dvd-12.html"
+<br>
 
 ---
 
 
 1. Descarga la carpeta `Functions-PrettyPlots` de `Bitbucket` usando un terminal, moviéndote al directorio `Documents/eip`,  y escribiendo el comando `git clone http://bitbucket.org/eip-uprrp/functions-prettyplots`.
 
-2. Carga a Qt Creator el proyecto `prettyPlot`  haciendo doble "click" en el archivo `prettyPlot.pro` que se encuentra en la carpeta `Documents/eip/Functions-PrettyPlots` de tu computadora.
+2. Carga a Qt Creator el proyecto `prettyPlot`  haciendo doble "click" en el archivo `prettyPlot.pro` que se encuentra en la carpeta `Documents/eip/functions-prettyplots` de tu computadora.
 
 3. Configura el proyecto y ejecuta el programa marcando la flecha verde en el menú de la izquierda de la interface de Qt Creator. El programa debe mostrar una ventana parecida a la Figura 3.
 
+   ---
 
-    ---
-
-    ![Figura3.png](images/Figura3.png)
+   ![Figura3.png](images/Figura3.png)
 
-    **Figura 3.** Gráfica de un círculo de radio 5 y centro en el origen desplegada por el programa *PrettyPlot*.
+   **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. 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.
 
         void illustration(int paramValue, int &paramRef) {
             paramValue = 1;
                  << "The content of paramRef is: " << paramRef << endl;
         }
 
-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.
+5. 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 `argValue` no cambia, mientras que el contenido de `argRef` cambia de 0 a 1.
 
 ### Ejercicio 2
 
 
 **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`.
 
         XYPlotWindow wCircleR5;
         XYPlotWindow wCircle;
         double increment = 0.01;
         int argValue=0, argRef=0;
 
-        // invoke the function illustration to view the contents of variables
-        // by value and by reference
+        // invoca la función illustration para ver los contenidos de la variable
+        // por valor y por referencia.
 
             illustration(argValue,argRef);
-            cout << endl << "The content of argValue is: " << argValue << endl
-                 << "The content of argRef is: " << argRef << endl;
+            cout << endl << "El contenido de argValue es: " << argValue << endl
+                 << "El contenido de argRef es: " << argRef << endl;
 
-        // repeat for several values of the angle t
+        // repite por varios valores para el ángulo 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
+            // invoca circle con el ángulo t y las variables de referencia x, y como argumentos
             circle(t,x,y);
 
-            // add the point (x,y) to the graph of the circle
+            // añade el punto (x,y) a la gráfica del círculo
             wCircleR5.AddPointToGraph(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.
+    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.
+    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()`.
+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
 
 
     $$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)$$
 
 [2] http://paulbourke.net/geometry/butterfly/
 
 [3] http://en.wikipedia.org/wiki/Parametric_equation
-
----
-
----
-
----
-