소스 검색

updated sources and README

Jose Ortiz 9 년 전
부모
커밋
c21862efe1
4개의 변경된 파일119개의 추가작업 그리고 162개의 파일을 삭제
  1. 90
    75
      README.md
  2. 24
    36
      main.cpp
  3. 4
    24
      xyplotwindow.cpp
  4. 1
    27
      xyplotwindow.h

+ 90
- 75
README.md 파일 보기

@@ -56,7 +56,7 @@ Antes de llegar al laboratorio  debes:
56 56
 ##Funciones
57 57
 
58 58
 
59
-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.
59
+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.
60 60
 
61 61
 Las funciones en lenguajes de programación de computadoras son similares. Una función 
62 62
 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.
@@ -69,9 +69,7 @@ La primera oración de una función se llama el *encabezado* y su estructura es
69 69
 
70 70
 Por ejemplo,
71 71
 
72
-```cpp
73
-int ejemplo(int var1, float var2, char &var3)
74
-```
72
+`int ejemplo(int var1, float var2, char &var3)`
75 73
 
76 74
 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.
77 75
 
@@ -79,23 +77,18 @@ sería el encabezado de la función llamada `ejemplo`, que devuelve un valor ent
79 77
 
80 78
 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:
81 79
 
82
-```cpp
83
-resultado = ejemplo(2, 3.5, unCar);
84
-```
80
+`resultado=ejemplo(2, 3.5, unCar);`
85 81
 
86 82
 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`.
87 83
 
88 84
 También puedes usar el resultado de la función sin tener que guardarlo en una variable. Por ejemplo puedes imprimirlo:
89 85
 
90
-```cpp
91
-cout << "El resultado de la función ejemplo es:" << ejemplo(2, 3.5, unCar);
92
-```
86
+`cout << "El resultado de la función ejemplo es:" << ejemplo(2, 3.5, unCar);`
93 87
 
94 88
 o utilizarlo en una expresión aritmética:
95 89
 
96
-```
97
-y = 3 + ejemplo(2, 3.5, unCar);
98
-```
90
+`y=3 + ejemplo(2, 3.5, unCar);`
91
+
99 92
 
100 93
 
101 94
 
@@ -106,7 +99,7 @@ La firma de una función se compone del nombre de la función, y los tipos de pa
106 99
 
107 100
 Los siguientes prototipos de funciones tienen la misma firma:
108 101
 
109
-```cpp
102
+```
110 103
 int ejemplo(int, int) ;
111 104
 void ejemplo(int, int) ; 
112 105
 string ejemplo(int, int) ;
@@ -116,7 +109,7 @@ Nota que todas tienen el mismo nombre, `ejemplo`, y reciben la misma cantidad de
116 109
 
117 110
 Los siguientes prototipos de  funciones tienen firmas diferentes:
118 111
 
119
-```cpp
112
+```
120 113
 int ejemplo(int) ;
121 114
 int olpmeje(int) ;
122 115
 ```
@@ -124,7 +117,7 @@ Nota que a pesar de que las funciones tienen la misma cantidad de parámetros co
124 117
 
125 118
 Los siguientes prototipos de funciones son versiones sobrecargadas de la función `ejemplo`:
126 119
 
127
-```cpp
120
+```
128 121
 int ejemplo(int) ;
129 122
 void ejemplo(char) ;
130 123
 int ejemplo(int, int) ;
@@ -181,49 +174,52 @@ Se pueden asignar valores por defecto ("default") a los parámetros de las funci
181 174
 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.
182 175
 
183 176
 
177
+
178
+---
179
+
184 180
 ---
185 181
 
186 182
 ##Ecuaciones paramétricas
187 183
 
188
-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í: 
184
+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í: 
189 185
 
190 186
 $$x^2+y^2=r^2.$$
191 187
 
192 188
 
193
-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
189
+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
194 190
 
195 191
 $$x^2+y^2=4,$$
196 192
 
197
-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: 
193
+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: 
198 194
 
199 195
 $$x=r \cos(t)$$
200 196
 
201 197
 $$y=r \sin(t),$$
202 198
 
203
-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.
199
+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.
204 200
 
205 201
 
206 202
 ---
207 203
 
208 204
 ![circulo.jpg](images/circulo.jpg)
209 205
 
210
-<b>Figura 1.</b> Círculo con centro en el origen y radio $$r$$.
206
+<b>Figura 1.</b> Círculo con centro en el origen y radio $r$.
211 207
 
212 208
 
213 209
 ---
214 210
 
215
-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
211
+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
216 212
 
217 213
 ---
218 214
 
219
-| $$t$$ | $$x$$ | $$y$$ |
215
+| $t$ | $x$ | $y$ |
220 216
 |-----|-----|-----|
221
-| $$0$$ | $$2$$ | $$0$$ |
222
-| $$\frac{\pi}{4}$$ | $$\frac{\sqrt{2}}{2}$$ | $$\frac{\sqrt{2}}{2}$$ |
223
-| $$\frac{\pi}{2}$$ | $$0$$ | $$2$$ |
217
+| $0$ | $2$ | $0$ |
218
+| $\frac{\pi}{4}$ | $\frac{\sqrt{2}}{2}$ | $\frac{\sqrt{2}}{2}$ |
219
+| $\frac{\pi}{2}$ | $0$ | $2$ |
224 220
 
225 221
 
226
-**Figura 2.** Algunas coordenadas de los puntos $$(x,y)$$ del círculo con radio $$r=2$$ y centro en el origen.
222
+**Figura 2.** Algunas coordenadas de los puntos $(x,y)$ del círculo con radio $r=2$ y centro en el origen.
227 223
 
228 224
 ---
229 225
 
@@ -250,7 +246,8 @@ En este ejercicio estudiarás la diferencia entre pase por valor y pase por refe
250 246
     **Figura 3.** Gráfica de un círculo de radio 5 y centro en el origen desplegada por el programa *PrettyPlot*.
251 247
     
252 248
     ---
253
-    
249
+
250
+
254 251
 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.
255 252
 
256 253
 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.
@@ -261,13 +258,14 @@ En este ejercicio practicarás la creación de una función sobrecargada.
261 258
 
262 259
 **Instrucciones**
263 260
 
264
-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`. 
261
+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`. 
265 262
 
266
-    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.
267 263
 
268
-    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.
264
+    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.
269 265
 
270
-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()`.
266
+    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.
267
+
268
+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()`.
271 269
 
272 270
 ###Ejercicio 3
273 271
 
@@ -276,15 +274,19 @@ En este ejercicio implantarás otra función para calcular las coordenadas de lo
276 274
 **Instrucciones**
277 275
 
278 276
 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:
279
-    
277
+
278
+
279
+
280 280
     $$x=5\cos(t) \left[ \sin^2(1.2t) + \cos^3(6t) \right]$$
281 281
     $$y= 10\sin(t) \left[ \sin^2(1.2t) +  \cos^3(6t) \right].$$
282
-    
283
-    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í:
284
-    
282
+
283
+
284
+    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í:
285
+
285 286
     $$q =  \sin^2(1.2t) + \cos^3(6t)$$
286 287
     $$x = 5 \cos(t)(q)$$
287 288
     $$y = 10  \sin(t)(q).$$
289
+
288 290
     
289 291
 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.
290 292
 
@@ -293,11 +295,16 @@ En [3] puedes encontrar otras ecuaciones paramétricas de otras curvas interesan
293 295
 
294 296
 ---
295 297
 
298
+---
296 299
 
297 300
 ##Entregas
298 301
 
299 302
 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.
300 303
 
304
+
305
+
306
+---
307
+
301 308
 ---
302 309
 
303 310
 ##Referencias
@@ -363,9 +370,11 @@ Before you get to the laboratory you should have:
363 370
 
364 371
 ---
365 372
 
373
+---
374
+
366 375
 ##Functions
367 376
 
368
-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.
377
+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.
369 378
 
370 379
 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.
371 380
 
@@ -377,9 +386,7 @@ The first sentence of a function is called the *header* and its structure is as
377 386
 
378 387
 For example,
379 388
 
380
-```cpp
381
-int example(int var1, float var2, char &var3)
382
-```
389
+`int example(int var1, float var2, char &var3)`
383 390
 
384 391
 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.
385 392
 
@@ -389,23 +396,20 @@ would be the header of the function called `example`, which returns an integer v
389 396
 
390 397
 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:
391 398
 
392
-```cpp
393
-result = example(2, 3.5, unCar);
394
-```
399
+`result=example(2, 3.5, unCar);`
395 400
 
396 401
 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`.
397 402
 
398 403
 You can also use the function's result without having to store it in a variable. For example you could print it:
399 404
 
400
-```cpp
401
-cout << "The result of the function example is:" << example(2, 3.5, unCar);
402
-```
405
+`cout << "The result of the function example is:" << example(2, 3.5, unCar);`
403 406
 
404 407
 or use it in an arithmetic expression:
405 408
 
406
-```cpp
407
-y = 3 + example(2, 3.5, unCar);
408
-```
409
+`y=3 + example(2, 3.5, unCar);`
410
+
411
+
412
+
409 413
 
410 414
 
411 415
 ###Overloaded functions
@@ -416,7 +420,7 @@ The signature of a function is composed of the name of the function, and the typ
416 420
 
417 421
 The following function prototypes have the same signature:
418 422
 
419
-```cpp
423
+```
420 424
 int example(int, int) ;
421 425
 void example(int, int) ; 
422 426
 string example(int, int) ;
@@ -427,7 +431,7 @@ Note that each has the same name, `example`, and receives the same amount of par
427 431
 
428 432
 The following function prototypes have different signatures:
429 433
 
430
-```cpp
434
+```
431 435
 int example(int) ;
432 436
 int elpmaxe(int) ;
433 437
 ```
@@ -436,7 +440,7 @@ Note that even though the functions have the same amount of parameters with the
436 440
 
437 441
 The following function prototypes are overloaded versions of the function `example`:
438 442
 
439
-```cpp
443
+```
440 444
 int example(int) ;
441 445
 void example(char) ;
442 446
 int example(int, int) ;
@@ -457,7 +461,7 @@ Values by default can be assigned to the parameters of the functions starting fr
457 461
 **Examples of function headers and valid invocations:**
458 462
 
459 463
 1. **Headers:** `int example(int var1, float var2, int var3 = 10)` Here `var3` is initialized to 10.
460
-    
464
+
461 465
     **Invocations:**
462 466
 
463 467
     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`.
@@ -468,7 +472,8 @@ Values by default can be assigned to the parameters of the functions starting fr
468 472
 Here `var2` is initialized to 5 and `var3` to 10.
469 473
 
470 474
     **Invocations:**
471
-    
475
+
476
+
472 477
     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`.
473 478
 
474 479
     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.
@@ -478,7 +483,8 @@ Here `var2` is initialized to 5 and `var3` to 10.
478 483
 
479 484
 **Example of a valid function header with invalid invocations:**
480 485
 1. **Header:** `int example(int var1, float var2=5.0, int var3 = 10)` 
481
-    
486
+
487
+
482 488
     **Invocation:**
483 489
 
484 490
     a. `example(5, , 10)` This function call is **invalid** because it leaves an empty space in the middle argument.
@@ -493,50 +499,54 @@ Here `var2` is initialized to 5 and `var3` to 10.
493 499
 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.
494 500
 
495 501
 
502
+---
496 503
 
497 504
 ---
498 505
 
499 506
 ## Parametric equations
500 507
 
501
-*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:
508
+*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:
509
+
502 510
 
503 511
 $$x^2+y^2=r^2.$$
504 512
 
505
-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
513
+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
514
+
506 515
 
507 516
 $$x^2+y^2=4,$$
508 517
 
509
-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:
518
+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:
519
+
510 520
 
511 521
 $$x=r \cos(t)$$
512 522
 
513
-$$y=r \sin(t)$$,
523
+$$y=r \sin(t),$$
514 524
 
515
-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.
525
+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.
516 526
 
517 527
 
518 528
 ---
519 529
 
520 530
 ![circulo.jpg](images/circulo.jpg)
521 531
 
522
-<b>Figure 1.</b> Circle with center in the origin and radius $$r$$.
532
+<b>Figure 1.</b> Circle with center in the origin and radius $r$.
523 533
 
524 534
 
525 535
 ---
526 536
 
527
-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
537
+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
528 538
 
529 539
 
530 540
 ---
531 541
 
532
-| $$t$$ | $$x$$ | $$y$$ |
542
+| $t$ | $x$ | $y$ |
533 543
 |-----|-----|-----|
534
-| $$0$$ | $$2$$ | $$0$$ |
535
-| $$\frac{\pi}{4}$$ | $$\frac{\sqrt{2}}{2}$$ | $$\frac{\sqrt{2}}{2}$$ |
536
-| $$\frac{\pi}{2}$$ | $$0$$ | $$2$$ |
544
+| $0$ | $2$ | $0$ |
545
+| $\frac{\pi}{4}$ | $\frac{\sqrt{2}}{2}$ | $\frac{\sqrt{2}}{2}$ |
546
+| $\frac{\pi}{2}$ | $0$ | $2$ |
537 547
 
538 548
 
539
-**Figure 2.** Some coordinates for the points $$(x,y)$$ for the circle with radius $$r=2$$ and center in the origin.
549
+**Figure 2.** Some coordinates for the points $(x,y)$ for the circle with radius $r=2$ and center in the origin.
540 550
 
541 551
 ---
542 552
 
@@ -563,7 +573,7 @@ In this exercise you will study the difference between pass by value and pass by
563 573
     **Figure 3.**  Graph of a circle with radius 5 and center in the origin displayed by the program *PrettyPlot*.
564 574
     
565 575
     ---
566
-    
576
+
567 577
 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.
568 578
 
569 579
 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.
@@ -574,13 +584,13 @@ In this exercise you will practice the creation of an overloaded function.
574 584
 
575 585
 **Instructions**
576 586
 
577
-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.
587
+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.
578 588
 
579
-    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.
589
+    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.
580 590
 
581
-    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.
591
+    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.
582 592
 
583
-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()`.
593
+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()`.
584 594
 
585 595
 ###Exercise 3
586 596
 
@@ -589,11 +599,12 @@ In this exercise you will implement another function to calculate the coordinate
589 599
 **Instructions**
590 600
 
591 601
 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:
592
-    
602
+
603
+
593 604
     $$x=5\cos(t) \left[ \sin^2(1.2t) + \cos^3(6t) \right]$$
594 605
     $$y= 10\sin(t) \left[ \sin^2(1.2t) +  \cos^3(6t) \right].$$
595 606
 
596
-    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:
607
+    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:
597 608
 
598 609
     $$q =  \sin^2(1.2t) + \cos^3(6t)$$
599 610
     $$x = 5 \cos(t)(q)$$
@@ -604,11 +615,15 @@ In this exercise you will implement another function to calculate the coordinate
604 615
 In [3] you can find other parametric equations from other interesting curves.
605 616
 
606 617
 ---
618
+---
607 619
 
608 620
 ##Deliverables
609 621
 
610 622
 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.
611 623
 
624
+
625
+---
626
+
612 627
 ---
613 628
 
614 629
 ##References
@@ -617,4 +632,4 @@ Use "Deliverables" in Moodle to hand in the file `main()` that contains the func
617 632
 
618 633
 [2] http://paulbourke.net/geometry/butterfly/
619 634
 
620
-[3] http://en.wikipedia.org/wiki/Parametric_equation
635
+[3] http://en.wikipedia.org/wiki/Parametric_equation

+ 24
- 36
main.cpp 파일 보기

@@ -7,17 +7,12 @@
7 7
 #include <QApplication>
8 8
 using namespace std;
9 9
 
10
-/// \fn void illustration(int paramValue, int &paramRef)
11
-/// \~English
12
-/// \brief This function is to illustrate the difference between
13
-/// pass by value and pass by reference
14
-/// \param paramValue parameter passed by value
15
-/// \param paramRef parameter passed by reference
16
-/// \~Spanish
17
-/// \brief  Esta funcion es para ilustrar la differencia entre
18
-/// variables pasadas por referencia y pasadas por valor
19
-/// \param paramValue parametro pasado por valor
20
-/// \param paramRef parametro pasado por referencia
10
+//**********************************************************
11
+// This function is to illustrate the difference between   *
12
+// pass by value and pass by reference                     *
13
+//**********************************************************
14
+
15
+
21 16
 void illustration(int paramValue, int &paramRef)
22 17
 {
23 18
     paramValue=1;
@@ -26,32 +21,33 @@ void illustration(int paramValue, int &paramRef)
26 21
          << "The content of paramRef is: " << paramRef << endl;
27 22
 }
28 23
 
29
-/// \fn void circle(double p, double &xCoord, double &yCoord)
30
-/// \~English
31
-/// \brief Function to draw a circle
32
-/// \~Spanish
33
-/// \brief Funcion para dibujar un circulo
24
+//************************************
25
+// Functions circle                  *
26
+//************************************
27
+
34 28
 void circle(double p, double &xCoord, double &yCoord)
35 29
 {
36 30
     xCoord = 5 * cos(p);
37 31
     yCoord = 5 * sin(p);
38 32
 }
39 33
 
40
-//Overloaded Funcion circle /  Funcion circulo sobre cargada
34
+//Overloaded Funcion circle
41 35
 
42
-// YOUR CODE HERE / TU CODIGO AQUI
36
+// YOUR CODE HERE
43 37
 
44 38
 
45
-///************************************
46
-///Function butterfly                *
47
-///************************************
39
+//************************************
40
+// Function butterfly                *
41
+//************************************
48 42
 
49
-// YOUR CODE HERE / TU CODIGO AQUI
43
+// YOUR CODE HERE
50 44
 
51 45
 
52 46
 //***************
53 47
 // Function main *
54 48
 //***************
49
+
50
+
55 51
 int main(int argc, char *argv[])
56 52
 {
57 53
     QApplication a(argc, argv);
@@ -67,7 +63,7 @@ int main(int argc, char *argv[])
67 63
     int argValue=0, argRef=0;
68 64
 
69 65
     // invoke the function illustration to view the contents of variables by value and by reference
70
-    // invoca la funcion ilustracion para ver los contenidos de variables por valor y por referencia
66
+
71 67
         illustration(argValue,argRef);
72 68
         cout << endl << "The content of argValue is: " << argValue << endl
73 69
              << "The content of argRef is: " << argRef << endl;
@@ -75,48 +71,40 @@ int main(int argc, char *argv[])
75 71
 
76 72
 
77 73
     // repeat for several values of the angle t
78
-    // repite para varios valores de el angulo t
79 74
     for (double t = 0; t < 16*M_PI; t = t + increment)
80 75
     {
81 76
         
82 77
         // invoke circle with the angle t and reference variables x, y as arguments
83
-        // invke circle con el angulo t y variables por referencia x, y como argumentos
84 78
         circle(t,x,y);
85 79
         
86 80
         // add the point (x,y) to the graph of the circle
87
-        // anade el punto (x,y) a la grafica de el circulo
88 81
         wCircleR5.AddPointToGraph(x,y);
89 82
         
90 83
         
91 84
         // invoke circle with the radius r, the angle t and reference variables x, y as arguments
92
-        // invoca circulo con el radio r, el angulo t y variables x, y como argumentos
93 85
       
94
-        // YOUR CODE HERE / TU CODIGO AQUI
86
+        // YOUR CODE HERE
95 87
         
96 88
         // add the point (x,y) to the graph of the circle
97
-        // anade el punto (x,y) to la grafica de el circulo
98 89
        
99
-        // YOUR CODE HERE / TU CODIGO AQUI
90
+        // YOUR CODE HERE
100 91
 
101 92
         
102 93
         // invoke butterfly with the angle t and reference variables x, y as arguments
103
-        // invoca butterfly con el angulo t y variables referencia x, y como argumentos
104 94
       
105
-        // YOUR CODE HERE / TU CODIGO AQUI
95
+        // YOUR CODE HERE
106 96
 
107 97
         // add the point (x,y) to the graph of the butterfly
108
-        // anade el punto (x,y) a la grafica de la mariposa
109 98
        
110
-        // YOUR CODE HERE / TU CODIGO AQUI
99
+        // YOUR CODE HERE
111 100
     }
112 101
 
113 102
     // After all the points have been added, plot and show the graphs
114
-    // Despues que todos los puntos sean anadidos, enseña las graficas.
115 103
     
116 104
     wCircleR5.Plot();
117 105
     wCircleR5.show();
118 106
     
119
-    // YOUR CODE HERE / TU CODIGO AQUI.
107
+    // YOUR CODE HERE
120 108
     
121 109
 
122 110
     return a.exec();

+ 4
- 24
xyplotwindow.cpp 파일 보기

@@ -3,11 +3,6 @@
3 3
 #include "qcustomplot.h"
4 4
 #include <cmath>
5 5
 
6
-/// \fn XYPlotWindow::XYPlotWindow(QWidget *parent)
7
-/// \~English
8
-/// \brief Constructor
9
-/// \~Spanish
10
-/// \brief Constructor
11 6
 XYPlotWindow::XYPlotWindow(QWidget *parent) :
12 7
     QMainWindow(parent),
13 8
     ui(new Ui::XYPlotWindow)
@@ -15,25 +10,15 @@ XYPlotWindow::XYPlotWindow(QWidget *parent) :
15 10
     ui->setupUi(this);
16 11
 }
17 12
 
18
-/// \fn void XYPlotWindow::AddPointToGraph(double x, double y)
19
-/// \~English
20
-/// \brief Adds a coordinate (x,y) to the XX and YY vectors.
21
-/// \param x value of the coordinate (x,y) to be added to vector XX.
22
-/// \param y value of the coordinate (x,y) to be added to vector YY.
23
-/// \~Spanish
24
-/// \brief Anade una coordenada (x,y) a los vectores XX y YY.
25
-/// \param x valor de la coordenada (x,y) a ser anadido al vector XX.
26
-/// \param y valor de la coordenada (x,y) a ser anadido al vector YY.
13
+
14
+// Añade la x y y a sus respectivos vectores.
27 15
 void XYPlotWindow::AddPointToGraph(double x, double y) {
28 16
         XX.push_back(x);
29 17
         YY.push_back(y);
30 18
 }
31 19
 
32
-/// \fn void XYPlotWindow::Plot()
33
-/// \~English
34
-/// \brief Plots the coordinates inserted in the vectors XX and YY.
35
-/// \~Spanish
36
-/// \brief Grafica las coordenadas insertadas en los vectores XX y YY.
20
+// Esta función invoca los métodos apropiados de customPlot para que
21
+// se grafiquen los puntos.
37 22
 void XYPlotWindow::Plot() {
38 23
     ui->customPlot->xAxis->setLabel("x");
39 24
     ui->customPlot->yAxis->setLabel("y");
@@ -45,11 +30,6 @@ void XYPlotWindow::Plot() {
45 30
     myCurve->setData(XX,YY);
46 31
 }
47 32
 
48
-/// \fn XYPlotWindow::~XYPlotWindow()
49
-/// \~English
50
-/// \brief Destructor
51
-/// \~Spanish
52
-/// \brief Destructor
53 33
 XYPlotWindow::~XYPlotWindow()
54 34
 {
55 35
     delete ui;

+ 1
- 27
xyplotwindow.h 파일 보기

@@ -13,36 +13,10 @@ class XYPlotWindow : public QMainWindow
13 13
     Q_OBJECT
14 14
 
15 15
 public:
16
-    /// \fn XYPlotWindow::XYPlotWindow(QWidget *parent)
17
-    /// \~English
18
-    /// \brief Constructor
19
-    /// \~Spanish
20
-    /// \brief Constructor
21 16
     explicit XYPlotWindow(QWidget *parent = 0);
22
-
23
-    /// \fn XYPlotWindow::~XYPlotWindow()
24
-    /// \~English
25
-    /// \brief Destructor
26
-    /// \~Spanish
27
-    /// \brief Destructor
17
+    //void setupgraph();
28 18
     ~XYPlotWindow();
29
-
30
-    /// \fn void XYPlotWindow::AddPointToGraph(double x, double y)
31
-    /// \~English
32
-    /// \brief Adds a coordinate (x,y) to the XX and YY vectors.
33
-    /// \param x value of the coordinate (x,y) to be added to vector XX.
34
-    /// \param y value of the coordinate (x,y) to be added to vector YY.
35
-    /// \~Spanish
36
-    /// \brief Anade una coordenada (x,y) a los vectores XX y YY.
37
-    /// \param x valor de la coordenada (x,y) a ser anadido al vector XX.
38
-    /// \param y valor de la coordenada (x,y) a ser anadido al vector YY.
39 19
     void AddPointToGraph(double x, double y);
40
-
41
-    /// \fn void XYPlotWindow::Plot()
42
-    /// \~English
43
-    /// \brief Plots the coordinates inserted in the vectors XX and YY.
44
-    /// \~Spanish
45
-    /// \brief Grafica las coordenadas insertadas en los vectores XX y YY.
46 20
     void Plot();
47 21
 
48 22