Tutorial de C++

Códigos de Programas
en el lenguaje C++
Efraı́n Soto Apolinar

Códigos de Programas
en el lenguaje C++
Compilados por
Efraı́n Soto Apolinar ÿ
PISIS
Monterrey, N.L., México. 2007

Índice
1 Introducción 7
1.1 Conceptos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.1 Conceptos de programación . . . . . . . . . . . . . . . . . 8
1.1.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Sintaxis del lenguaje C++ . . . . . . . . . . . . . . . . . . . . . . 11
1.2.1 Palabras reservadas . . . . . . . . . . . . . . . . . . . . . 11
1.2.2 Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2.3 Tipos de constantes . . . . . . . . . . . . . . . . . . . . . 12
1.2.4 Caracteres especiales . . . . . . . . . . . . . . . . . . . . . 12
1.2.5 Declaración de variables . . . . . . . . . . . . . . . . . . . 12
1.2.6 Asignación . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.2.7 Operaciones matemáticas . . . . . . . . . . . . . . . . . . 14
1.2.8 Comparaciones . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.9 Ciclos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.2.10 Ejemplos de control de flujo . . . . . . . . . . . . . . . . . 17
Códigos Este material NO está listo para su publicación. Efraı́n Soto A.

Prohibida la reproducción sin permiso previo del autor.
en C++
4
1.2.11 Operaciones lógicas . . . . . . . . . . . . . . . . . . . . . . 21
1.3 Funciones en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.3.1 Funciones predefinidas . . . . . . . . . . . . . . . . . . . . 22
1.3.2 Funciones definidas por el usuario . . . . . . . . . . . . . 23
1.4 Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2 Códigos 31
2.1 Mis primeros programas . . . . . . . . . . . . . . . . . . . . . . . 32
2.2 Programas con funciones . . . . . . . . . . . . . . . . . . . . . . . 38
2.3 Funciones cin, cout . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.4 if, for, while and the like... . . . . . . . . . . . . . . . . . . . . . . 46
2.5 Mis tareas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
2.5.1 Simulación 1 . . . . . . . . . . . . . . . . . . . . . . . . . 60
2.5.2 Cálculo analı́tico . . . . . . . . . . . . . . . . . . . . . . . 64
2.5.3 Simulación 2 . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.5.4 Simulación 3 . . . . . . . . . . . . . . . . . . . . . . . . . 68
2.5.5 Simulación 4 . . . . . . . . . . . . . . . . . . . . . . . . . 70
2.5.6 Simulacion 5 . . . . . . . . . . . . . . . . . . . . . . . . . 72
2.5.7 Simulacion 6 . . . . . . . . . . . . . . . . . . . . . . . . . 74
2.5.8 Simulacion 7 . . . . . . . . . . . . . . . . . . . . . . . . . 78
2.5.9 Simulacion 8 . . . . . . . . . . . . . . . . . . . . . . . . . 80
2.5.10 Simulación de la distribución binomial . . . . . . . . . . . 84
2.5.11 Introducción a la dinámica de poblaciones . . . . . . . . . 87
2.6 Proyectos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
2.6.1 Regresión lineal . . . . . . . . . . . . . . . . . . . . . . . . 89
2.6.2 Regresión cuadrática . . . . . . . . . . . . . . . . . . . . . 91
2.7 Librerı́a Estadı́stica . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Efraı́n Soto A. Este material NO está listo para su publicación. Códigos

en C++
5
2.8 Implementación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
2.8.1 Ejemplos de uso . . . . . . . . . . . . . . . . . . . . . . . 139
2.8.1.1 funiforme(total, archivo) . . . . . . . . . . . . . 139
2.8.1.2 funiforme(total, archivo, A, B) . . . . . . . . . . 140
2.8.1.3 fnormal(total, archivo) . . . . . . . . . . . . . . 142
2.8.1.4 fnormal(total, archivo, media, SD) . . . . . . . . 143
2.8.1.5 fexponencial(total, lambda, archivo) . . . . . . . 144
2.8.1.6 fgeometrica(total, p, archivo) . . . . . . . . . . . 145
2.8.1.7 fpoisson(total, alpha, archivo) . . . . . . . . . . 145
2.8.1.8 fweibull(total, archivo, c, k) . . . . . . . . . . . . 146
2.8.1.9 frayleigh(total, archivo, media) . . . . . . . . . . 147
2.8.1.10 histograma(archivo, intervalos) . . . . . . . . . . 148
2.8.1.11 PchiUniforme(archivo, No Int) . . . . . . . . . . 154
2.8.1.12 PchiNormal(archivo, No Int) . . . . . . . . . . . 156
2.8.1.13 PchiExponencial(archivo, Num Int, lambda) . . 157
2.8.1.14 PchiWeibull(Archivo, Num Int, C, K) . . . . . . 159
2.8.1.15 PchiRayleigh(archivo, Num Int, media) . . . . . 161
2.8.1.16 RL(archivo) . . . . . . . . . . . . . . . . . . . . 162
2.8.1.17 RC(archivo) . . . . . . . . . . . . . . . . . . . . 163
2.8.2 Otras funciones . . . . . . . . . . . . . . . . . . . . . . . . 165
2.8.2.1 uniforme() . . . . . . . . . . . . . . . . . . . . . 165
2.8.2.2 uniforme(a,b) . . . . . . . . . . . . . . . . . . . . 166
2.8.2.3 weibull(c,k) . . . . . . . . . . . . . . . . . . . . . 167
2.8.2.4 rayleigh(media) . . . . . . . . . . . . . . . . . . 168
2.8.2.5 normal() . . . . . . . . . . . . . . . . . . . . . . 169
2.8.2.6 normal(media, desviacionStd) . . . . . . . . . . 170
2.8.2.7 exponencial(lambda) . . . . . . . . . . . . . . . . 171

en C++
2.8.2.8 geometrica(p) . . . . . . . . . . . . . . . . . . . 172
2.8.2.9 poisson(alpha) . . . . . . . . . . . . . . . . . . . 173
2.8.2.10 media(archivo), desviacionStd(archivo) . . . . . 174
2.8.3 Simulación del recurso eólico . . . . . . . . . . . . . . . . 176
2.8.3.1 Energı́a extraida del viento . . . . . . . . . . . . 176
2.8.4 Distribución del viento . . . . . . . . . . . . . . . . . . . . 178
2.8.4.1 Distribución Weibull . . . . . . . . . . . . . . . . 178
2.8.4.2 Distribución Rayleigh . . . . . . . . . . . . . . . 179
2.8.4.3 Distribución de energı́a . . . . . . . . . . . . . . 180
2.8.4.4 Anemómetros digitales . . . . . . . . . . . . . . 180
2.8.4.5 Predicción del recurso eólico . . . . . . . . . . . 180
2.8.5 Un caso especı́fico . . . . . . . . . . . . . . . . . . . . . . 181
2.8.6 Implementación . . . . . . . . . . . . . . . . . . . . . . . . 181
2.8.7 Resultados de la simulación . . . . . . . . . . . . . . . . . 186
2.9 Esqueletos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
2.10 Lecciones aprendidas . . . . . . . . . . . . . . . . . . . . . . . . . 193
3 End matter 195
3.1 Fuentes bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . 196
3.2 Términos de uso . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
3.3 Créditos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
3.4 Simbologı́a utilizada . . . . . . . . . . . . . . . . . . . . . . . . . 200

Introducción
1

en C++
8 Introducción
1.1 Conceptos básicos

En este apartado se dan algunos conceptos que necesitas conocer para poder
aprovechar la lectura de este material.
Se presentan diversas secciones con contenidos igual de importantes. Los primeros

tienen que ver con las bases de programación y después se incluyen los que
conciernen al lenguaje C++ .
1.1.1 Conceptos de programación
Los conceptos que debes entender para iniciarte en el arte de la programación

son:
Definición 1.1.1.
Algoritmo
Una sucesión ordenada de instrucciones para resolver un problema o una tarea.
Puedes pensar en un algoritmo como si se tratara de una receta. Es el procedi-
miento que se debe realizar para resolver un problema especı́fico.
Definición 1.1.2.
Compilador
Es el programa de computadora que traduce las instrucciones que nosotros le
damos en un lenguaje especı́fico.
Definición 1.1.3.
Programa fuente
Es el código que tú vas a escribir. En este texto encontrarás el programa fuente
para resolver muchos problemas. El programa fuente también se conoce como
código fuente.
Definición 1.1.4.
Código
Es un conjunto de instrucciones en algún lenguaje de alto nivel. En este material
solamente encontrarás código en C++ .
El código no necesariamente es un programa completo, puede tratarse solamente
de una parte del programa.

en C++
1.1 Conceptos básicos 9
Definición 1.1.5.
Sintaxis
Son las reglas de acuerdo a las cuales debes escribir el programa fuente. Cada
lenguaje de programación tiene su sintaxis. Puedes imaginar que la sintaxis son
las reglas de gramática de ese lenguaje.
Definición 1.1.6.
Compilar
Indicar a la computadora que verifique que el programa fuente no contenga
errores. Esta tarea siempre la realizará un software (el compilador).
Definición 1.1.7.
Correr (un programa)
Ordenar a la computadora que ejecute las instrucciones indicadas por el código
de un programa. Evidementemente, un programa en C++ debe correrse en un
compilador de ese lenguaje. (Yo utilizo el Dev-C++ , que es gratuito.)
Nota 1.1.1. Algunas veces el compilador no encontrará errores, pero existe la

posibilidad de que sı́ existan. Por ejemplo, en el caso de que tú hayas cometido
el error de escribir un + en lugar de un *, el compilador no se da cuenta,
porque no sabe realmente qué debe hacer el programa. En otras palabras, las
computadoras todavı́a no pueden leer tu mente.
Definición 1.1.8.
Mensaje de error
Es un mensaje que el compilador te dará cuando encuentre errores en el pro-
grama fuente. Estos mensajes te ayudan a corregir el código.
Definición 1.1.9.
Error de sintáxis
Ocurre cuando el código no está completamente escrito de acuerdo a las reglas de
sintaxis del mismo. Por ejemplo, si escribes, Go To en lugar de GOTO, cometiste
un error de sintaxis (de acuerdo a la sintáxis del lenguaje GWBasic).

en C++
10 Introducción
Definición 1.1.10.
Errores lógicos
Los que comete el programador cuando traduce el algoritmo al lenguaje C++ .
El programa realmente no hace lo que el algoritmo indica. Tal vez no tenga
errores de sintáxis... simplemente no realiza la tarea que debe realizar. Cuidado
con esto.
1.1.2 Variables
Identificador
Es el nombre que el programador asigna a un valor dentro de un programa. En
C++ , un identificador debe empezar con una letra o el sı́mbolo: ’ ’ y los demás
caracteres deben ser letras, dı́gitos o el sı́mbolo ’ ’.
Variable
Es una herramienta de programación utilizada para asignar valores (no nece-
sariamente numéricos) a letras o cadenas de letras. Las variables se clasifican
de acuerdo al tipo de valor que almacenan.
Constante
Es un valor que no cambia durante la ejecución del programa. Una constante
puede ser de cualquiera de los tipos de datos definidos en C++ .

en C++
1.2 Sintaxis del lenguaje C++ 11
1.2 Sintaxis del lenguaje C++

1.2.1 Palabras reservadas
En C++ , las siguientes son consideradas reservadas: !

asm do inline return typedef
auto double int short typeid
bool dynamic cast log signed typename
break else long sizeof union
case enum mutable static unsigned
char explicit namespace static cast using
catch extern new struct virtual
class false operator switch void
const float private template volatile
const cast for protected this while
continue friend public throw
default goto register true
delete if reinterpret cast try
esto significa que no se permite utilizar alguna de las palabras que se enlistaron
antes como un identificador. !
1.2.2 Tipos de datos
En C++ hay varios tipos de datos que podemos definir para las variables y
constantes que utilicemos en nuestros programas.
!
Variable Rango Precisión Ejemplo
short −32 767 a 32 767 No Aplica 23
int −2 147 483 647 a 2 147 483 647 No Aplica −4
unsigned int −2 147 483 647 a 2 147 483 647 No Aplica 4
float 10−38 a 1038 7 dı́gitos 3.1416
double 10−308 a 10308 15 dı́gitos 3.141592654
long double 10−4932 a 104932 19 dı́gitos 2.718281828
char No aplica No aplica ’a’
string No aplica No aplica ’Hola Amigo.’
bool False/True No aplica False
Tipos de datos.

en C++
12 Introducción
Decidir cómo definir una variable depende del uso que se le va a dar. Cuando
vayas a definir una variable trata de pensar en qué le va a pasar durante la
ejecución del programa.
1.2.3 Tipos de constantes
Una variable, por definición, puede cambiar de valor durante la ejecución de

un programa. Por el contrario una constante no cambia de valor durante la
ejecución del programa.
Bueno, muchos se preguntan, “si nunca cambia de valor, para qué utilizar un
identificador y utilizar más memoria...” Ok. Acepto el argumento. Sin embargo,
algunas veces un valor constante aparece en muchas partes del código de un
programa, por ejemplo, la tasa de cambio.
Si cambia de un dı́a para otro este valor, es una buena idea definirlo como
constante, y cambiar su valor... porque si nos decidimos cambiar todos los
lugares donde aparezca esta constante, existe la posibilidad de que omitamos uno
o varios cambios. Además, existe también la posibilidad de que otra constante
tenga el mismo valor y eso pueda ocasionar más errores todavı́a.
Cuando una variable del tipo bool toma el valor true, este resultado no es
i una cadena de caracteres, es decir, no es una variable del tipo string. De
manera que si quieres engañar al compilador o a la computadora asignando a una
constante del tipo bool la cadena ’true’, al compilar te dará el correspondiente
mensaje de error.
1.2.4 Caracteres especiales
! En C++ se definen los siguientes caracteres especiales.
Caracter especial Constante

Salto de lı́nea ’\n’
Tabulación ’\t’
Nulo ’\0’
Diagonal inversa \\
Caracteres especiales.
1.2.5 Declaración de variables
En C++ , estas obligado a declarar cualquier variable antes de poder utilizarla.

La sintaxis para declarar una variable es la siguiente:

en C++
Tipo_de_variable variable1;
También puedes declarar dos o más variables al mismo tiempo separándolas por
comas:
Tipo_de_variable variable1, variable2, variable3;
Igual, podemos declarar una constante, anteponiendo la palabra const a la

declaración.
Ejemplos: o
int contador, dia, mes, edad; // Variables tipo int (entero)
double promedio, precio, masa, volumen; // con punto decimal
char nombre[15], apellido_m[15], apellido_p[15]; // Cadenas
const double e = 2.718281828; // Constante tipo double
1.2.6 Asignación
En C++ , para hacer una asignación de un valor al identificador de una varia-

ble, necesariamente debemos escribir primero (i.e., a la izquierda) el valor del
identificador que almacenará el valor y a la derecha el valor o una expresión
matemática correctamente codificada en C++ . Como es costumbre, en medio
debemos escribir el sı́mbolo ’=’.
La sintáxis es la siguiente:
variable = expresion;
Ejemplos: o
total = total + incremento;
edad = year_actual - year_de_nac;
area = 3.1416 * radio * radio;
importe = precio_unitario * no_articulos;
aceleracion = (v_f - v_i) / t;

en C++
14 Introducción
También podemos asignar un valor a un identificador a la hora de declarar la

variable. Hay dos formas igualmente aceptables para hacer esto. La sintaxis es
la siguiente:
Tipo\_de\_variable variable1 = valor\_1, variable2 = valor\_2, var3 = valor\_3;\\

Tipo\_de\_variable variable4 (valor\_4), variable5 (valor\_5), var6 (valor\_6);
o Ejemplos:
int contador= 1, factor_de_conversion = 12;

double alpha(0.32), delta_Cu(375.23);
char respuesta = ’c’;
1.2.7 Operaciones matemáticas
En C++ están definidas las operaciones aritméticas básicas: +, −, ×, ÷.
Para la suma y la resta usamos los signos + y −, respectivamente. Para la

multiplicación usamos el sı́mbolo ’*’ y para la división, el sı́mbolo: /.
Es importante utilizar signos de agrupación para definir correctamente las opera-

ciones.
Por ejemplo, supongamos que tenemos que realizar el siguiente cálculo:

√
−b + b2 − 4 ac
x1 =
2a
o En C++ esta misma expresión se codifica como sigue:
x_1 = (- b + sqrt(b * b - 4 * a * c))/(2 * a);
La función sqrt() está definida en una librerı́a de C++ (math.h)1 .
En el caso de la fórmula:
1 2
yf = a t + v0 t + yi
2
o se codifica como:
1 Más sobre funciones y librerı́as en los siguientes temas.

en C++
y_f = a * t * t / 2 + v_0 * t + y_i;
En la programación es muy común utilizar la operación incremento. Es decir,

incrementamos el valor de una variable en 1, digamos un contador.
Debido a esto, en C++ hay varias operaciones matemáticas unitarias, en el sen-

tido que se realizan con solamente una variable, no dos, en cuyo caso serı́an
binarias. o
Ejemplo: Equivalente a:
contador++; contador = contador + 1;
reg −−; reg = reg − 1
decenas += 10; decenas = decenas + 10;
p Neto −= desc; p Neto = p Neto − desc;
factor *= celcuis; factor = factor * celcius;
residuo %= divisor; residuo = residuo % divisor;
mejor *= calif1 + calif2; mejor = mejor * (calif1 + calif2);
Operaciones unitarias
1.2.8 Comparaciones
En la mayoria de los programas se requiere hacer comparaciones para controlar

el flujo del procedimiento.
En seguida se muestra la tabla que contiene los tipos de comparaciones. !

Sı́mbolo En En Ejemplo Equivalente
Matemático Español C++ Práctico a
= Igual a == x == 0 x=0
6= Distinto a != x != 0 x 6= 1
< Menor a < x < 0 x<0
≤ Menor o igual a <= x <= 0 x≤0
> Mayor a > x > 0 x>0
≥ Mayor o igual a >= x >= 0 x≥0
Operadores de Comparación
Las instrucciones que nos ayudan a realizar operaciones de comparación (booleanas)
son las siguientes:
If then else
if (Expresión Booleana){
// Aquı́ van las instrucciones que

en C++
16 Introducción
// debe realizar en caso de que la

// expresión Booleana sea verdadera
}
else{
// Aquı́ van las instrucciones que
// debe realizar en caso de que la
// expresión Booleana sea falsa
1.2.9 Ciclos
While
while (Expresión Booleana){

// Algo debe ocurrir aquı́
// Varias veces para que el ciclo
// cumpla con su función...
} // Este ciclo no requiere punto y coma al final...
do...while
do{
} while (Expresión Booleana);

// Nota el punto y coma al final...
for
for (incialización ; Expresión booleana ; Incremento){

}
// Este ciclo tampoco requiere punto y coma al final...

en C++
1.2.10 Ejemplos de control de flujo
if...then...else
1 #include <stdio.h>
2 #include <iostream>
3
4 using namespace std;

5 int main(void){
6 char respuesta;
7 cout << "\n\n¿Te gusta el rock? [S/N] ";
8 cin >> respuesta;
9 if (respuesta == ’S’){
10 // dice que sı́...
11 cout << "\n\nQue bien,";
12 cout << "\nIgual a mi...";
13 }
14 else{
15 // dice que no...
16 cout << "\n\nBueno, creo que hay mejor musica...";
17 cout << "\nPor ejemplo, el Jazz...";
18 }
19 cout << "\n\n\n";
20 system ("PAUSE");
21 return 0;
22 }
for
3

5 int main(void){
6 int total = 0,cuadrado;
7 cout << "\n\nCuántos cuadrados deseas calcular?";
8 cin >> total;
9 for (int i = 0 ; i <= total ; i++){
10 cuadrado = i * i;
11 cout << "\nEl cuadrado de " <> total;
9 while (i <= total){
12 i++;
13 }
14 cout << "\n\n\n";
16 return 0;
17 }
do...while
3

5 int main(void){
6 int total = 0, i = 0, cuadrado;
8 cin >> total;
9 do{
12 i++;
13 }while (i <= total);
14 cout << "\n\n\n";
16 return 0;
17 }
switch
3

5 int main(void){

en C++
6 int calificacion;
7 cout << "\n\nQue calificacion obtuviste en tu examen? ";
8 cout << "\n(Introduce un numero entero) ";
9 cin >> calificacion;
10 switch (calificacion){
11 case 0:
12 cout << "\nCero!!!";
13 break;
14 case 1:
15 cout << "\n¿Por qué?";
16 break;
17 case 2:
18 cout << "\nQué te pasó?";
19 break;
20 case 3:
21 cout << "\nAy, no me digas!";
22 break;
23 case 4:
24 cout << "\nCaramba!!!!";
25 break;
26 case 5:
27 cout << "\nPor qué no estudiaste?";
28 break;
29 case 6:
30 cout << "\nDebes echarle más ganas...";
31 break;
32 case 7:
33 cout << "\nPasaste de panzaso";
34 break;
35 case 8:
36 cout << "\nQue bien...";
37 break;
38 case 9:
39 cout << "\nMuy bien...";
40 break;
41 case 10:
42 cout << "\nFelicidades!!!";
43 break;
44 default:
45 cout << "\nTe pedı́ tu calificación,";
46 cout << "\nno tu edad!!!\n";
47 }
48 cout << "\n\n\n";
50 return 0;
51 }
• Un ejemplo donde se generan las tablas de multiplicar:

en C++
20 Introducción
3

5 int main(void){
6 int i, j, k;
7 // Empiezan las tablas de multiplicar...
8 for (i = 1; i <= 12; i++){
9 cout << "Tabla del " << i << "\n";
10 for (j = 1 ; j <= 12 ; j++){
11 k = i * j;
12 cout << i << " x " << j << " = " << k << "\n";
13 }
14 cout <<"\n\n\n";
15 // Termino una tabla... voy con la siguiente...
16 }
17 cout << "\n\n\n";
19 return 0;
20 }
• El siguiente genera las tablas de multiplicar, pero el usuario decide hasta

cuál. Se utiliza un ciclo for infinito para que el usuario pueda ingresar un
número entero positivo. En caso de que ingrese un número negativo o cero, el
programa envı́a un mensaje de error y le permite volver a ingresar el valor de
la última tabla a imprimir.
3

5 int main(void){
6 int i, j, k;
7 int total;
8 for (;;){ // for infinito
9 cout << "\n\nCuantas tablas desea que se impriman? ";
10 cin >> total;
11 if (total <= 0){
12 cout << "\n\nError en argumento...";
13 cout << "\nDebe introducir un numero entero positivo...";
14 }
15 else{
16 // salir del for infinito...
17 break;
18 }
19 } // end for infinito...
20 cout << "\n\n\n"; // un poco de espacio

en C++
21 // Empiezan las tablas de multiplicar...

22 for (i = 1; i <= total; i++){
23 cout << "Tabla del " << i << "\n";
24 for (j = 1 ; j <= 12 ; j++){
25 k = i * j;
26 cout << i << " x " << j << " = " << k << "\n";
27 }
28 cout <<"\n\n\n";
29 // Termino una tabla... voy con la siguiente...
30 }
31 cout << "\n\n\n";
33 return 0;
34 }
1.2.11 Operaciones lógicas
A las operaciones lógicas también se les conocen en programación como opera-

ciones booleanas.
AND: Se codifica con la instrucción: &&.

Ejemplo:
if ((x != 0) && (divisor == 3))

{
// Aquı́ va a ocurrir algo...
}
//...
OR: Se codifica con la instrucción: ||.

Ejemplo:
{if ((x > 0) || (divisor > 3))

{
// Aquı́ va a ocurrir otra cosa...
}
...

en C++
22 Introducción
1.3 Funciones en C++

1.3.1 Funciones predefinidas
En C++ el truco de programar consiste en “desmenuzar” cada problema com-

plejo en sus partes más elementales idependientes una de la otra. Es como si un
ser pluricelular lo separaras en sus celulas y trabajaras con cada una de ellas.
Cuando las juntes, todas van a trabajar como si fueran un ser completo, cada
una realizando su tarea, sin preocuparse de las otras partes.
En seguida se muestra una lista de las funciones predefinidas en C++ .
Nombre Descripción Argumento Retorno Librerı́a

sqrt raı́z cuadrada double double math.h
pow potencia double double math.h
abs valor absoluto int int math.h
labs valor absoluto long long stdlib.h
fabs valor absoluto doule double math.h
ceil cielo doule double math.h
floor piso doule double math.h
exp exp(x) doule double math.h
log ln(x) doule double math.h
log10 log10 (x) doule double math.h
Funciones predefinidas en C++
Las funciones trigonométricas e hiperbólicas están definidas en la librerı́a math.h.
Nombre Descripción Argumento Retorno

acos arco coseno double double
asin arco seno double double
atan arco tangente double double
cos coseno double double
cosh coseno hiperbólico double double
sin seno double double
sinh seno hiperbólico double double
tan tangente double double
tanh tangente hiperbólico double double
Funciones trigonométricas en C++
Las funciones se invocan escribiendo primero el nombre de la función y después,

entre paréntesis, los argumentos que requiera la misma.

en C++
1.3 Funciones en C++ 23
La sintaxis es la siguiente.
Funcion (Argumento 1,Argumento 2,· · · ,Argumento n);
Ejemplo:
pi = 3.1416;
radio = sqrt(area /pi);
edad = abs(year de nac - year actual);
base = 5;
exponente = 3;
potencia = pow(base,exponente);
1.3.2 Funciones definidas por el usuario
El programador de C++ puede crear sus propias funciones.
Primero indicamos qué tipo de valor nos devolverá. Después indicamos el nom-
bre de la función. Inmediatamente después se encierra entre paréntesis los ar-
gumentos de la función, los cuales deben ir precedidos del tipo de dato que le
corresponde a cada uno.
Finalmente, entre corchetes debemos incluir las instrucciones que debe realizar
la función sobre la información que se le entregue.
Recuerda que debes definir la función como si se tratara de otra variable. Es

decir, debes definirla antes de hacer uso de ella en el cuerpo del programa.
La sintaxis es la siguiente:
Tipo devuelto Nombre funcion(Tipo 1 Arg 1,Tipo 2 Arg 2, · · · ,Tipo n Arg n)

{// Aquı́ se incluyen las instrucciones de lo que debe
// realizar la función sobre los argumentos...
Ejemplo:

en C++
24 Introducción
// Esta función calcula el p porciento de una cantidad C.

double porcentaje(double porciento,double cantidad)
{
double resultado; // defino una variable para almacenar ahı́ el resultado...
resultado = porciento * cantidad / 100;
return resultado;
// la instrucción return devuelve el valor a la función que lo llamó...
// generalmente, a la función main()
}
La misma función anterior pudo definirse de la siguiente manera:
// Esta función calcula el p porciento de una cantidad C.

double porcentaje(double porciento,double cantidad)
{
return (porciento * cantidad / 100);
}
• Funciones que he necesitado...
1 /* Nombre del archivo: prueba.cpp

2 Descripción:
3 Este programa ayuda en la revisión de funciones
4 definidas por el usuario...
5 ----------------------------------------------------
6 ----------------------------------------------------
7 Autor: Efraı́n Soto Apolinar
8 Email: efrain@yalma.fime.uanl.mx
9 Fecha de última Modificación: 24 de enero de 2008
10 Lenguaje de Programación: C++
11 Compilador: Dev - C++ Versión 4.9.9.2.
12 ----------------------------------------------------
13 ----------------------------------------------------
14 */
15 #include <iostream> // Funciones básicas para input/output
16 #include <stdlib.h> // para usar la función rand()
17 #include <math.h> // funciones matemáticas (sin (double))
18 #include <conio.h> // para usar: getche, getch
19 #include <ctime> // double difftime(time_t time2, time_t time1);
20
21 int errores; // variable global

22 int factorial(int n);
23 int permuta(int n, int k);
24 int potencia(int e);
25

en C++

27 int main(void)
28 {
29 char respuesta;
30 int n,total;
31 int i,j,k; // contadores
32 double pBin, pBer; // probabilidades
33 clock_t tiempo1,tiempo2;
34
35 cout << "\nEste programa sirve para verificar que";

36 cout << "\nlas funciones definidas más abajo (en el código)";
37 cout << "\nsean correctas......";
38 //
39 for (;;)
40 {tiempo1 = clock()/CLOCKS_PER_SEC;
41 cout << "\n\nPrimero verificamos que la función ";
42 cout << "\nfactorial no tenga errores: ";
43 cout << "\n\n\nIngresa un número natural";
44 cout << "para calcular su factorial ";
45 cin >> n;
46 cout << "\n\n\nEl factorial de " << n << " es: " << factorial(n);
47
48 cout << "\n\nAhora verificamos que la función ";

49 cout << "\nsubfactorial no tenga errores: ";
50 cout << "\n\n\nIngresa un número natural n";
51 cout << "\npara calcular las permutaciones ";
52 cin >> n;
53 cout << "\n\n\nIngresa un número natural k";
54 cout << "\npara las permutaciones ";
55 cin >> k;
56 cout << "\n\n\nEl resultado de combinar " << k;
57 cout << " de entre " << n << " es: " << permuta(n,k);
58
59 cout << "\n\nFinalmente verificamos que la función ";

60 cout << "\npotencia no tenga errores: ";
61 cout << "\n\n\nIngresa un número natural n";
62 cout << "\npara calcular 2ˆn: ";
63 cin >> n;
64 cout << "\n\n\nEl resultado de elevar 2ˆ" << n;
65 cout << " es: " << potencia(n);
66
67 cout << "\n\nFinalmente verificamos el valor de ";

68 cout << "\nCLOCKS_PER_SECOND: ";
69 cout << CLOCKS_PER_SEC << endl;
70 cout << "\nTiempo 1 (inicio): " << tiempo1;
71 tiempo2 = clock()/CLOCKS_PER_SEC;
72 cout << "\nTiempo 2 (actual): " << tiempo2;
73
74 cout << "\n\nTotal de errores: " << errores;

75 //

en C++
26 Introducción
76 cout << "\n\n\nPresione < S > para salir...";

77 respuesta = getche();
78 if ((respuesta == ’S’)||(respuesta == ’s’))
79 {
80 break; // Salir del ciclo for inicial...
81 }
82 cout <<"\n\n\n";
83 }
84 return 0;
85 }
86 /**************************************
87 Declaro la función factorial...
88 ***************************************/
89 int factorial(int n)
90 {
91 int fi,i;
92 fi = i = 1;
93 while (i<=n)
94 {
95 fi *=i;
96 if (fi <= 0){ // por si se rebasa la memoria...
97 cout << "\n\n\nEl hecho de que sea computadora ";
98 cout << "\nno implica que haga milagros...\n";
99 cout << "\nLo siento, se rebasó la memoria...";
100 fi = 1;
101 errores++;
102 break;
103 }
104 i++;
105 }
106 return fi;
107 }
108 /**************************************
109 Declaro la función permuta...
110 ***************************************/
111 int permuta(int n, int k)
112 {
113 int p,subfactorial,i;
114 i = n - k + 1; // n - k + 1 para calcular el subfactorial
115 // el subfactorial es el numerador de la fórmula para
116 // calcular las combinaciones n en k
117 //C(n,k) = (n-k+1)(n-k+2)...(n) / k!
118 subfactorial = 1; // reinicio el subfactorial
119 while (i<=n){
120 subfactorial *=i;
121 i++;
122 }
123 p = subfactorial / factorial(k);
124 // p siempre es entero...
125 return p;

en C++
126 }
127 /**************************************
128 Declaro la función potencia...
129 ***************************************/
130 int potencia(int e)
131 {// para calcular la potencia 2ê
132 int i,potencia; // contador y resultado
133 potencia = 1;
134 for (i=1; i <= e; i++)
135 {
136 potencia *=2;
137 }
138 return potencia;
139 }

en C++
28 Introducción
1.4 Clases
Yo me imagino las clases como tipos de datos que defino por comodidad.
Por ejemplo, si necesito trabajar con números complejos, mejor defino un nuevo
tipo de variable con una clase. ası́, podré definir números complejos como si se
tratara de un tipo de variable que ya estuviera definido en C++ .
La idea es que además de declarar tipos de datos también podré definir funciones
y realizar operaciones con ellos, por ejemplo, sumarlos, multiplicarlos, etc.
1 /*
2 Este programa crea una clase
3 que se llama número complejo
4 */
5 #include <iostream> // Funciones para input/output
6 #include <cstdlib> //
7

9 class complejo{
10 public:
11 double real; // parte real del número complejo.
12 double imaginary; // parte imaginaria del # complejo
13 };
14 int main(void){
15 // defino una instancia de mi clase
16 // se trata de un número complejo
17 complejo z1;
18 z1.real = 3.14159; // parte real
19 z1.imaginary = 2.717281828; // parte imaginaria
20 cout << "\n\n\n";
21
22 cout << "\n\nParte real de z1 es z1.real = "

23 << z1.real;
24 cout << "\n\nParte compleja de z1 es z1.imaginary = "
25 << z1.imaginary;
26 cout << "\n\n";
27 system("PAUSE");
28 return 0;
29 }
El siguiente código muestra funciones pertenecientes a una clase.
1 /*
2 Este programa crea una clase
3 que se llama número complejo.

en C++
1.4 Clases 29
4 Se muestra además el uso de funciones

5 definidas para las clases.
6 */
7 #include <iostream> // Funciones para input/output
8 #include <cstdlib> //
10 class complejo{
11 public:
12 // para asignar la parte real
13 void DefinirReal(double r);
14 // para asignar la parte imaginaria
15 void DefinirImaginario(double i);
16 // para leer la parte real
17 double LeerReal(void);
18 // para leer la parte imaginaria
19 double LeerImaginario(void);
20 private:
21 double real; // parte real
22 double imaginary; // parte imaginaria
23 };
24 int main(void){
25 // defino una instancia de mi clase
26 complejo z1;
27 z1.DefinirReal(3.14159);
28 z1.DefinirImaginario(2.717281828);
29 cout << "\n\n\n";
30
31 cout << "\n\nEste programa muestra el uso de

32 funciones de clase.";
33 cout << "\n\nParte real de z1 se obiente con
34 z1.LeerReal(); = " << z1.LeerReal();
35 cout << "\n\nParte compleja de z1 se obtiene con
36 z1.LeerImaginario(); = " << z1.LeerImaginario();
37 cout << "\n\n";
38 system("PAUSE");
39 return 0;
40 }
41 // Ahora defino las funciones de la clase.
42
43 // para asignar la parte real

44 void complejo::DefinirReal(double r){
45 real = r;
46 }
47
48 // para asignar la parte imaginaria

49 void complejo::DefinirImaginario(double i){
50 imaginary = i;
51 }
52
53 // para leer la parte real

en C++
30 Introducción
54 double complejo::LeerReal(void){
55 return(real);
56 }
57
58 // para leer la parte imaginaria

59 double complejo::LeerImaginario(void){
60 return(imaginary);
61 }
Debes notar que en el primer código se han definido las variables real e imaginary
como variables públicas, pero en el segundo ejemplo se han definido como vari-
ables privadas. De esta forma, no se puede tener acceso a ellas, salvo a través
de las funciones que se definen en la clase.
En este ejemplo se trata de las funciones: LeerImaginario(), LeerReal(),

DefinirImaginario(double i), y DefinirReal(double r).
Observa también que las funciones de clase se definen con el siguiente código:
1 tipod clase::nombreFuncion(tipoa argumento){

2 // Instrucciones de la función...
3 .
4 .
5 .
6 }
• tipod indica el tipo de valor que devolverá la función.

• clase es el nombre de la clase a la que pertenece la función.
• nombreFuncion es el nombre de la función.

• tipoa es el tipo de variable que tendrá el argumento.
• argumento es el identificador de la variable que será el argumento de la
función.

en C++
Códigos
2

en C++
32 Códigos
2.1 Mis primeros programas

En este apartado se muestra el código de algunos programas básicos.
• Estructura básica del programa.
1 /* Nombre del archivo: ProgramTemplate

2 Template - Esta es una estructura de base
3 para escribir programas en C++
4 ----------------------------------
5 ----------------------------------
6 Nombre del Archivo: ProgramTemplate
7 Autor: Tu Nombre va aquı́...
8 Email: tu.cuenta@tubuzon.mail.com
9 Descripción: Estructura para programa
10 Fecha de última Modificación: 17 de Noviembre del 2007
11 ----------------------------------
12 ----------------------------------
13 ∗/
15 #include <math.h> // funciones matemáticas
17 int main(int nNumberofArgs, char* pszArgs[])
18 {
19 // El código del programa C++ debe estar encerrado entre llaves {}
20 // después del la instrucción "main"
21 // (Bueno, en realidad se trata de una función...)
22 // La siguiente instrucción: system("PAUSE");
23 // permite que el usuario haya leı́do la información

24 // que se obtuvo como resultado de la ejecución del programa...
25 system("PAUSE");
26 return 0;
27 }

en C++
2.1 Mis primeros programas 33
• Las reglas básicas del lenguaje C++ .
#include <stdio.h>
int main()
{
printf("\n Los paréntesis siempre aparecen en pares!");
printf("\n Los comentarios en una lı́nea se indican con //");
printf("\n O bien, se inician don /*");
printf("\n y se terminan con */");
printf("\n cuando abarcan varias lı́neas...");
printf("\n Las instrucciones terminan con un punto y coma (;)");
printf("\n Los espacios son opcionales");
printf("\n Puedes dejar lı́neas en blanco entre el código");
printf("\n para hacerlo más legible");
printf("\n Debe contener la función main()");
printf("\n C++ usa mayormente minúsculas.");
printf("\n En C++ las letras mayúsculas y las minúsculas");
printf("\n no dan los mismos resultados en las instrucciones...");
return(0);
}
• Calcula el área de un triángulo.
3 int main(void)
4 {
5 double area, base, altura;
6 string unidad;
7 cout << "¿Qué unidad de medida usarás? ";
8 cin >> unidad;
9 cout << "¿Cuántos " << unidad <<
10 "mide la base del triángulo? ";
11 cin >> base;
12 cout << "¿Cuántos " << unidad <<
13 "mide la altura del triángulo? ";
14 cin >> altura;
15 area = base*altura/2;
16 cout << "El área del triángulo es: "
17 << area << unidad << " cuadrados.";
18 system("PAUSE");
19 return 0;
20 }

en C++
34 Códigos
• Una tonelada métrica equivale a 35,273.92 onzas. Escribe un programa

que lea el peso de un paquete de cereal en onzas y la salida sea el peso en
toneladas métricas ası́ como el número de cajas que se requieren para que pesen
una tonelada métrica. El programa debe permitir al usuario realizar el cálculo
tantas veces como lo desee.1
1 /*
2 Nombre del Archivo: proyecto1.cpp
3 Descripción: En el encabezado...
4 Fecha de última Modificación: 18 de Noviembre del 2007 */
7 int main(void)
8 {
9 double pesoOnzas, pesoTon, n;
10 double coef=35273.92;
11 char respuesta = ’c’;
12 for (;;)
13 {
14 cout << "¿Cuál es el peso de un paquete en onzas?: ";
15 cin >> pesoOnzas;
16 pesoTon = pesoOnzas / coef;
17 n = coef / pesoTon;
18 cout << "Un paquete pesa " << pesoTon << " Toneladas Métricas.\n\n";
19 cout << "Se requieren " << n << "cajas de cereal\n";
20 cout << "para que pesen una Tonelada Métrica,\n";
21 cout << "dado que 1 TM = 35,273.92 onzas.\n\n";
22 cout << "Presione < S > para salir o < C > para continuar....";
23 cin >> respuesta;
25 { break; // Salir del ciclo...
26 }
27 cout <<"\n\n\n";
28 }
29 return 0; // Le indico que devuelva cero la función "main()"
30 }
1 A partir de este programa se omiten el autor y el correo electrónico del mismo. En todos
los casos se trata del autor de este material.

en C++
• Un laboratorio de investigación ha concluido que el azucar X, un endulzante

artificial dietético, causará la muerte de ratones de laboratorio. Un paciente
desea conocer cuánto refresco de cola endulzado con el azucar X puede tomar
sin morir. Escribe un programa para encontrar la respuesta. La entrada es la
cantidad (en gramos) de azucar X requerida para matar a un ratón, el peso del
ratón y el peso del paciente. Para asegurar la integridad del paciente, indica el
peso a cual el paciente dejará de controlar su dieta, en lugar de su peso actual.
Suponga que el refresco de cola contiene un décimo de porciento de azúcar X.
El programa debe repetirse tantas veces como el usuario requiera.
1 /* Nombre del Archivo: proyecto2.cpp

5 int main(void)
6 {
7 double pesoPac, pesoRat, dosisRat, dosisPac;
8 double ratio=0.001;
10 for (;;) {
11 cout << "¿Cuál es el peso del ratón? [gr]: ";
12 cin >> pesoRat;
13 cout << "¿Cuál es la dosis mortal para el ratón?: ";
14 cin >> dosisRat;
15 cout << "¿Cuál es el peso deseado del paciente? [kg]: ";
16 cin >> pesoPac;
17 // Cálculos...
18 dosisPac= 1000*dosisRat * pesoPac / pesoRat; // dosis de pura azucar X
19 dosisPac = dosisPac / ratio; // dosis de refresco...
20 cout << "El paciente no debe exceder de " << dosisPac <<
21 " gramos de refresco endulzado con Azucar X, \n";
22 cout << "para que su integridad fı́sica esté a salvo. \n";
27 }
28 cout <<"\n\n\n";
29 }
30 return 0; // Le indico que devuelva cero la función "main()"
31 }

en C++
36 Códigos
• Los trabajadores de una compañı́a en particular han ganado un 7.6% de

incremento retroactivo a seis meses. Escribe un programa que toma el salario
promedio anual como entrada y da como salida el pago retroactivo al empleado,
el nuevo salario anual y el nuevo salario mensual. Usa la declaración de variable
con el modificador const para expresar el aumento en el salario. El programa
debe permitir realizar el cálculo tantas veces como se requiera.
1 /* Nombre del Archivo: proyecto3.cpp

2 Descripción: Ver el encabezado...
6 int main(void)
7 {
8 double salarioInicial, salarioFinal, salarioMensual, retro;
9 double aumento=0.076;
10 int meses;
12 for (;;)
13 { cout << "¿Cuál es el salario anual inicial del trabajador [en pesos]? ";
14 cin >> salarioInicial;
15 cout << "¿Cuántos meses se aplican de retroactivo [n<=6]? ";
16 cin >> meses;
17 retro = meses * aumento * salarioInicial;
18 salarioFinal = salarioInicial * (1 + aumento);
19 salarioMensual = salarioFinal/12;
20 cout << "El monto del retroactivo es de: " << retro << " pesos.\n\n";
21 cout << "El nuevo salario anual es de: " << salarioFinal << " pesos,\n";
22 cout << "y equivale a: " << salarioMensual << " pesos mensuales.\n\n";
27 }
28 cout <<"\n\n\n";
29 }
30 return 0;
31 }

en C++
• Elaborar un programa que calcule el factorial de un número entero positivo.
1 /* Nombre del Archivo: factorial.cpp

2 Autor: Efraı́n Soto Apolinar.
3 Email: efra.soto.a@gmail.com
8 int main(void)
9 {
10 int i,n,factorial;
12 for ( ; ; ){
13 cout << "Este programa calcula el valor del factorial \n";
14 cout << "de un número entero positivo\n";
15 cout << "Introduzca el valor de n: ";
16 cin >> n;
17 factorial=1;
18 for (i = 1; i <= n ;i++)
19 { factorial *=i;}
20 cout << "El factorial del número " << n << " es: " << factorial << "\n\n\n";
24 {
25 break; // Salir del ciclo...
26 }
27 cout <<"\n\n\n";
28 }
29 return 0;
30 }
31

en C++
38 Códigos
2.2 Programas con funciones

En los siguientes ejemplos, los códigos incluyen programas que hacen llamadas
a funciones que se definen en los mismos.
• Generar un programa donde se defina una función que calcule el factorial de

un número natural dado.
0
1 /* Nombre del archivo: proyecto4.cpp

2 Nombre del Archivo: proyecto4.cpp
4 Fecha de última Modificación: 01 de Diciembre del 2007 */
7 int main(void)
8 { int f,n,i;
9 int factorial(int n); // Declaro la función antes de usarla...
11 for ( ; ;)
12 { cout << "Ingresa el número natural para el cual \n";
13 cout << "deseas calcular el factorial. ";
14 cin >> n;
15 f = factorial(n); // Aquı́ llamo la función factorial...
16 cout << " \n\n\n"; cout << "El factorial del número " << n << " es:
17 " << f << " \n\n\n";
21 { cout <<"\n\n\n\n";
22 break; }
23 }
24 return 0;
25 }
26 // Declaro la función factorial...

27 int factorial(int n)
28 { int fi,i;
29 fi = i = 1;
30 while (i<=n)
31 {
32 fi *=i;
33 i++;
34 }
35 return fi;
36 }

en C++
2.3 Funciones cin, cout 39
2.3 Funciones cin, cout

En esta sección se enumeran programas sencillos que servirán de ejemplo para
otros ejercicios.
• Calcular el promedio. o
1 /* Nombre del archivo: UnoUno.cpp
2 Descripción:
3 Escribir un programa que calcule la media real de 3
4 números enteros dados por el usuario.
5 Fecha de última Modificación: 03 de enero del 2008
6 ----------------------------------
7 ----------------------------------
8 */
11 int main(void){
12 int a,b,c;
13 double promedio;
14 cout << "\nEscribe el primer número entero: ";
15 cin >> a;
16 cout << "\nEscribe el segundo número entero: ";
17 cin >> b;
18 cout << "\nEscribe el tercer número entero: ";
19 cin >> c;
20 promedio = double(a + b + c)/3.0;
21 cout << "\nEl promedio de estos valores es: "
22 << promedio << endl;
23 system("PAUSE");
24 return 0;
25 }
• Calcular la suma de dos números. o

1 /* Nombre del archivo: UnoDos.cpp
2 Descripción:
3 Escribir un programa que calcule la suma de 2
4 números enteros dados por el usuario.
6 ----------------------------------
7 ----------------------------------
8 */
11 int main(void){

en C++
40 Códigos
12 int a,b;
13 cout << "\nEscribe el primer número entero: ";
14 cin >> a;
15 cout << "\nEscribe el segundo número entero: ";
16 cin >> b;
17 cout << (a + b) << endl;
18 system("PAUSE");
19 return 0;
20 }
o • Calcular la diferencia de dos números.
1 /* Nombre del archivo: UnoTres.Cpp

2 Descripción:
3 Escribir un programa que pida dos números y
4 muestre la diferencia de ambos.
6 ----------------------------------
7 ----------------------------------
8 */
11 int main(void){
12 int a,b;
13 cout << "\nEscribe el minuendo: ";
14 cin >> a;
15 cout << "\nEscribe el sustraendo: ";
16 cin >> b;
17 cout << (a - b) << endl;
18
19 system("PAUSE");
20 return 0;
21 }
o • Intercambiar el valor de dos variables.
1 /* Nombre del archivo: UnoCuatro.cpp

2 Descripción:
3 Dados dos números que introducirá el usuario,
4 escribir un programa que intercambie sus valores.
6 ----------------------------------
7 ----------------------------------
8 */

en C++
11 int main(void){
12 double a,b,temp;
13 cout << "\nEscribe el primer valor: ";
14 cin >> a;
15 cout << "\nEscribe el segundo valor: ";
16 cin >> b;
17 temp = a;
18 a = b;
19 b = temp;
20 cout << "\nLos valores intercambiados de orden son: "
21 << a << " y " << b << endl;
22 system("PAUSE");
23 return 0;
24 }
• Insertar un dato tipo string. o

1 /* Nombre del archivo: UnoCinco.cpp
2 Descripción:
3 Escribir un programa que pida el nombre y el apellido
4 paterno de una persona y lo muestre en pantalla de la
5 forma apellido paterno, nombre.
7 ----------------------------------
8 ----------------------------------
9 */
12 int main(void){
13 char nombre[15], aPaterno[15], aMaterno[15];
14 cout << "Escribe tu nombre: ";
15 gets(nombre);
16 cout << "\nEscribe tu apellido paterno: ";
17 gets(aPaterno);
18 cout << "\nEscribe tu apellido materno: ";
19 gets(aMaterno);
20 cout << "\n\nTu nombre es: \n" << aPaterno << " "
21 << aMaterno << ", " << nombre << "\n";
22 system("PAUSE");
23 return 0;
24 }
• Convertir grados sexagesimales a radianes. o

1 /* Nombre del archivo: UnoSeis.cpp
2 Descripción:

en C++
42 Códigos
3 Escribir un programa que acepte el valor de un ángulo

4 medido en grados sexagesimales e imprima su valor en
5 radianes.
6 Nota: Utiliza Pi = 3.141592654
8 ----------------------------------
9 ----------------------------------
10 */
13 int main(void){
14 const double pi = 3.141592654;
15 double grados, rad;
16 cout << "\nEscribe la medida del ángulo en grados
17 sexagesimales: ";
18 cin >> grados;
19 rad = grados * pi / 180;
20 cout << "\nLa medida del ángulo en radianes es: "
21 << rad << endl;
22 system("PAUSE");
23 return 0;
24 }
o • Calcular el volumen de una esfera.
1 /* Nombre del archivo: UnoSiete.cpp

2 Descripción:
3 El volumen de una esfera puede calcularse con
4 V = 4 * Pi * rˆ3 / 3.
5 Escribir un programa que solicite el radio de
6 una esfera e imprima su volumen.
7

9 ----------------------------------
10 ----------------------------------
11 */
14 int main(void){
15 double r, volumen;
16 const double pi = 3.141592654;
17 cout << "\nEscribe el radio de la esfera: ";
18 cin >> r;
19 volumen = 4 * pi * r * r * r / 3;
20 cout << "\nEl volumen de esa esfera es: "
21 << volumen << endl;
22 system("PAUSE");
23 return 0;

en C++
24 }
• Calcular área del cı́rculo y perı́metro de circunferencia. o

1 /* Nombre del archivo: UnoOcho.cpp
2 Descripción:
3 El área de un cı́rculo es :
4 A = Pi * rˆ2
5 La longitud de la circunferencia es:
6 P = 2 * Pi * r
7 Escribir un programa que solicite el radio de un
8 cı́rculo e imprima en pantalla su perı́metro y su área.
9

11 ----------------------------------
12 ----------------------------------
13 */
16 int main(void){
17 double r, perimetro, area;
18 const double pi = 3.141592654;
19 cout << "\nEscribe el radio del cı́rculo: ";
20 cin >> r;
21 perimetro = 2 * pi * r;
22 area = pi * r * r;
23 cout << "\nEl area del cı́rculo es: " << area;
24 cout << "\nEl perimetro de la circunferenca es: "
25 << perimetro << endl;
26 system("PAUSE");
27 return 0;
28 }
• Realizar cálculos relacionados con un viaje. o

1 /* Nombre del archivo: UnoNueve.cpp
2 Descripción:
3 Escribir un programa que pida el total de kilómetros
4 recorridos, el precio de la gasolina (por litro),
5 el dinero de gasolina gastado en el viaje (en pesos)
6 y el tiempo que se ha tardado (en horas y minutos)
7 en ese viaje.
8 Calcular, además:
9 - Consumo de gasolina por cada 100 Km
10 - Consumo de gasolina por cada Km
11 - Velocidad media

en C++
44 Códigos
12

14 ----------------------------------
15 ----------------------------------
16 */
19 int main(void){
20 int KmR, Hrs, Min;
21 double PrecioGas, ImporteGas, Tiempo, VelKmH, VelMS;
22 double ConsumoGasPC, ConsumoGasP, ConsumoGasLC, ConsumoGasL;
23 cout << "\nEscribe la distancia recorrida en kilómetros: ";
24 cin >> KmR;
25 cout << "\nEscribe el precio de un litro de gasolina: ";
26 cin >> PrecioGas;
27 cout << "\nEscribe el importe gastado en gasolina: ";
28 cin >> ImporteGas;
29 cout << "\n\nEscribe el tiempo que tardó el viaje. ";
30 cout << "\nPrimero indica los minutos y después
31 los segundos... ";
32 cout << "\nHoras: ";
33 cin >> Hrs;
34 cout << "\nMinutos: ";
35 cin >> Min;
36 // Aquuı́ van los cálculos...
37 Tiempo = Hrs + Min / 60; // Tiempo en formato double...
38 VelKmH = KmR / Tiempo;
39 VelMS = VelKmH * 1000 / 3600;
40 ConsumoGasL = ImporteGas / PrecioGas;
41 ConsumoGasP = ConsumoGasL * PrecioGas;
42 ConsumoGasLC =ConsumoGasL * 100;
43 ConsumoGasPC =ConsumoGasP * 100;
44 cout << "\n\nLa velocidad promedio de ese viaje es: \n"
45 << VelKmH << " Kilómetros por hora " ;
46 cout << "\no bien...";
47 cout << "\n\nLa velocidad promedio de ese viaje es: \n"
48 << VelMS << " metros por segundo" ;
49 cout << "\nSe consumieron: " << ConsumoGasL
50 << " litros de gasolina por cada kilómetro recorrido" ;
51 cout << "\nSe consumieron: " << ConsumoGasLC
52 << " litros de gasolina por cada cien kilómetros" ;
53 cout << "\n\no bien...";
54 cout << "\nSe consumieron: " << ConsumoGasP
55 << " pesos de gasolina por cada kilómetro recorrido" ;
56 cout << "\nSe consumieron: " << ConsumoGasPC
57 << " pesos de gasolina por cada cien kilómetros" << endl;
58 system("PAUSE");
59 return 0;
60 }

en C++
• Calcular pendiente y ecuación de una recta.

o
1 /* Nombre del archivo: UnoDiez.cpp
2 Descripción:
3 Escribir un programa que encuentre la ecuación de
4 la recta que pasa por los dos puntos dados por el
5 usuario A(x_a, y_a), y B(x_b, y_b).
6 Indicar además sus intersecciones con los ejes
7 coordenados.
8

10 ----------------------------------
11 ----------------------------------
12 */
15 int main(void){
16 int x_a, x_b, y_a, y_b, Dx, Dy, b;
17 double m;
18 cout << "\nEste programa calcula la pendiente de una recta ";
19 cout << "\na partir de las coordenadas de dos puntos
20 por los cuales pasa... ";
21 cout << "\nEscriba las coordenadas de acuerdo a como
22 se piden: ";
23 cout << "\nCoordenada ’x’ del punto A: ";
24 cin >> x_a;
25 cout << "\nCoordenada ’y’ del punto A: ";
26 cin >> y_a;
27 cout << "\nCoordenada ’x’ del punto B: ";
28 cin >> x_b;
29 cout << "\nCoordenada ’y’ del punto B: ";
30 cin >> y_b;
31 // Cálculos...
32 Dx = x_b - x_a;
33 Dy = y_b - y_a;
34 m = Dy / Dx;
35 b = Dx * y_a - Dy * x_a;
36 cout << "\nLa pendiente de la recta que pasa por esos dos
37 puntos es: " << m;
38 cout << "\ny su ecuación es: \n\n" << Dy << "x + " << -Dx
39 << "y +" << b << "= 0.";
40 cout << endl;
41 system("PAUSE");
42 return 0;
43 }

en C++
46 Códigos
2.4 if, for, while and the like...

Las operaciones booleanas (comparaciones) y los ciclos nos permiten controlar
el flujo del programa.
o • Decidir si el usuario es mayor de edad.
1 /*
2 Nombre del archivo: DosUno.cpp
3 Descripción:
4 Escribir un programa que solicite la edad del usuario
5 y decida si es o no mayor de edad.
6 Considera a una persona mayor de edad si tiene al menos
7 18 años cumplidos.
8

10 ----------------------------------
11 ----------------------------------
12 */
13 #include <iostream> // Funciones básicas input/output
15 int main(void){
16 int edad;
17 cout << "\nEste programa decide si el usuario es mayor
18 de edad o no ";
19 cout << "\na partir de su edad... ";
20 cout << "\n\n¿Cuál es tu edad? ";
21 cin >> edad;
22 if (edad > 17) {
23 cout << "\n\nEl usuario es mayor de edad \n";
24 }
25 else{
26 cout << "\n\nEl usuario es menor de edad \n";
27 }
28 system("PAUSE");
29 return 0;
30 }
o • Indicar el nombre del mes a partir de un número.
1 /* Nombre del archivo: DosDos.cpp

2 Descripción:
3 Escribir un programa que pida un número del 1 al 12
4 (inclusive) e imprima a qué mes del año corresponde
5 ese valor.
6

en C++
2.4 if, for, while and the like... 47

8 ----------------------------------
9 ----------------------------------
10 */
13 int main(void){
14 int mes;
15 cout << "\nEste programa imprime el nombre del mes ";
16 cout << "\na partir del número que le corresponde... ";
17 cout << "\nIndique el número del mes ";
18 cin >> mes;
19 cout << endl;
20 if (mes == 1){
21 cout << "El mes " << mes << " corresponde a Enero.";
22 }
23 if (mes == 2){
24 cout << "El mes " << mes << " corresponde a Febrero.";
25 }
26 if (mes == 3){
27 cout << "El mes " << mes << " corresponde a Marzo.";
28 }
29 if (mes == 4){
30 cout << "El mes " << mes << " corresponde a Abril.";
31 }
32 if (mes == 5){
33 cout << "El mes " << mes << " corresponde a Mayo.";
34 }
35 if (mes == 6){
36 cout << "El mes " << mes << " corresponde a Junio.";
37 }
38 if (mes == 7){
39 cout << "El mes " << mes << " corresponde a Julio.";
40 }
41 if (mes == 8){
42 cout << "El mes " << mes << " corresponde a Agosto.";
43 }
44 if (mes == 9){
45 cout << "El mes " << mes << " corresponde a Septiembre.";
46 }
47 if (mes == 10){
48 cout << "El mes " << mes << " corresponde a Octubre.";
49 }
50 if (mes == 11){
51 cout << "El mes " << mes << " corresponde a Noviembre.";
52 }
53 if (mes == 12){
54 cout << "El mes " << mes << " corresponde a Diciembre.";
55 }
56 // por si el usuario es medio güey...

en C++
48 Códigos
57 if ((mes > 12) || (mes < 1)){

58 cout << "El mes " << mes << " no existe." ;
59 }
60 cout << endl;
61 system("PAUSE");
62 return 0;
63 }
• El mismo programa que el anterior, pero ahora utilizando la sentencia switch

o
1 /**************************************************
2 Nombre del Archivo: DosDosSwitch.cpp
5 Descripción:
6 Escribir un programa que pida un número del 1 al 12
7 (inclusive) e imprima a qué mes del año corresponde
8 ese valor.
9
10 Fecha de última Modificación: 23 de marzo de 2008

11 *****************************************************/
14 int main(void){
15 int mes;
16 cout << "\nEste programa imprime el nombre del mes ";
17 cout << "\na partir del número que le corresponde... ";
18 cout << "\nIndique el número del mes ";
19 cin >> mes;
20 switch (mes){
21 case 1:
22 cout << "\nEl mes " << mes << " corresponde a Enero.\n" ;
23 break;
24 case 2:
25 cout << "\nEl mes " << mes << " corresponde a Febrero.\n" ;
26 break;
27 case 3:
28 cout << "\nEl mes " << mes << " corresponde a Marzo.\n" ;
29 break;
30 case 4:
31 cout << "\nEl mes " << mes << " corresponde a Abril.\n" ;
32 break;
33 case 5:
34 cout << "\nEl mes " << mes << " corresponde a Mayo.\n" ;
35 break;
36 case 6:
37 cout << "\nEl mes " << mes << " corresponde a Junio.\n" ;

en C++
38 break;
39 case 7:
40 cout << "\nEl mes " << mes << " corresponde a Julio.\n" ;
41 break;
42 case 8:
43 cout << "\nEl mes " << mes << " corresponde a Agosto.\n" ;
44 break;
45 case 9:
46 cout << "\nEl mes " << mes << " corresponde a Septiembre.\n" ;
47 break;
48 case 10:
49 cout << "\nEl mes " << mes << " corresponde a Octubreo.\n" ;
50 break;
51 case 11:
52 cout << "\nEl mes " << mes << " corresponde a Noviembre.\n" ;
53 break;
54 case 12:
55 cout << "\nEl mes " << mes << " corresponde a Diciembre.\n" ;
56 break;
57 default:
58 // Error en argumento...
59 cout << "\nEl mes " << mes << " no existe.\n" ;
60 } // end switch
61 cout << "\n\n\n";
62 system("PAUSE");
63 return 0;
64 }
• Calcular una potencia. o

1 /* Nombre del archivo: DosTres.cpp
2 Descripción:
3 Calcular a elevado a la potencia b.
4
5 Fecha de última Modificación: 05 Enero 2008

6 ----------------------------------
7 ----------------------------------
8 */
11 int main(void){
12 int i, exponente, base;
13 double potencia;
14 cout << "\nEste programa calcula la potencia de un número ";
15 cout << "\nsiendo la base y el exponente números enteros ";
16 cout << "\nIngresa el valor de la base: ";
17 cin >> base;
18 cout << "\nIngresa el valor del exponente: ";

en C++
50 Códigos
19 cin >> exponente;

20 potencia = 1;
21 if (exponente == 0){
22 potencia = 1;
23 }
24 if (exponente > 0){
25 for (i=1 ; i<=exponente ; i++){
26 potencia *= base;
27 }
28 }
29 if (exponente < 0){
30 for (i=-1 ; i>=exponente ; i--){
31 potencia /= double(base);
32 // la instrucción double(var)
33 // convierte un entero a tipo double...
34 }
35 }
36 cout << "\nEl resultado de elevar el número: " << base
37 << " a la potencia " << exponente << " es: " << potencia
38 << endl;
39 system("PAUSE");
40 return 0;
41 }
o • Pedir dos números y su suma.
1 /***************************************************
2 Nombre del archivo: DosCuatro.cpp
3 Descripción:
4 Escribir un programa que pida dos números a, b
5 y después solicite la suma de ambos.
6 En caso de que la suma sea incorrecta indicarlo y dar
7 oportunidad para que escriba de nuevo el resultado.
8

10 ****************************************************/
13 int main(void){
14 int a,b,suma;
15 char respuesta;
16 cout << "\nEste pide dos números enteros ";
17 cout << "\ny solicita su suma ";
18 cout << "\nEn caso de error te permite volver a intentar.";
19 cout << "\nIntroduce el primer número entero: ";
20 cin >> a;
21 cout << "\nIntroduce el segundo número entero: ";
22 cin >> b;

en C++
23 for (;;){
24 cout << "\nIntroduce la suma de los números: ";
25 cin >> suma;
26 if (suma == (a+b)){
27 cout << "\nCorrecto!!!\n\n ";
28 break;
29 // sale del ciclo for
30 }
31 else{
32 cout << "\nIncorrecto!!!";
33 }
34 cout << "Presione < S > para salir o < C > para
35 continuar...";
37 if ((respuesta == ’S’)||(respuesta == ’s’)){
39 }
40 cout <<"\n\n\n";
41 }
42 system("PAUSE");
43 return 0;
44 }
• Pedir dos números y un operador para realizar el cálculo. o

1 /* Nombre del archivo: DosCinco.cpp
2 Descripción:
3 Escribir un programa que solicite al usuario dos
4 números y una operación y mostrar el resultado
5 de esa operación con esos dos números.
6

8 ----------------------------------
9 ----------------------------------
10 */
13 int main(void){
14 double a,b,resultado;
15 char operacion;
16 cout << "\nEste pide dos números enteros ";
17 cout << "\ny solicita un operador ";
18 cout << "\nDespués te muestra el resultado... ";
19 cout << "\nIntroduce el primer número entero: ";
20 cin >> a;
21 cout << "\nIntroduce el segundo número entero: ";
22 cin >> b;
23 cout << "\nIntroduce el operador: ";

en C++
52 Códigos
24 cin >> operacion;

25 if (operacion == ’+’){
26 resultado = a + b;
27 }
28 if (operacion == ’-’){
29 resultado = a - b;
30 }
31 if (operacion == ’*’){
32 resultado = a * b;
33 }
34 if (operacion == ’/’){
35 resultado = a / b;
36 }
37 cout << endl << "\t" << a << " " << operacion
38 << " " << b << " = " << resultado << endl;
39 system("PAUSE");
40 return 0;
41 }
o • Calcular el valor absoluto de un número.
1 /* Nombre del archivo: DosSeis.cpp

2 ----------------------------------
3 ----------------------------------
4 Nombre del Archivo: DosSeis.cpp
7 Descripción:
8 Escribir un programa que calcule el valor absoluto
9 de un número introducido por el usuario.
10

12 ----------------------------------
13 ----------------------------------
14 */
17 int main(void){
18 double a, absa;
19 cout << "\nEste pide un número real ";
20 cout << "\ny calcula su valor absoluto ";
21 cout << "\nIntroduce un número real: ";
22 cin >> a;
23 if (a>=0){
24 absa = a;
25 }
26 else{
27 absa = -a;

en C++
28 }
29 cout << "\nEl valor absoluto del número real: " << a
30 << " es: " << "\t" << absa << endl;
31 system("PAUSE");
32 return 0;
33 }
• Calcular el área de un triángulo a partir de la medida de sus lados2 . o

1 /* Nombre del archivo: DosSiete.cpp
2 Descripción:
3 Escribir un programa que calcule el área de un
4 triángulo conocidos las longitudes de sus tres lados.
5 Sugerencia: Aplica la fórmula de Herón:
6 A = sqrt(p*(p-a)*(p-b)*(p-c))
7 donde:
8 a,b,c son las longitudes de los lados del triángulo, y
9 p es el semiperı́metro del triángulo, es decir,
10 p = (a + b + c) / 2
11

13 ----------------------------------
14 ----------------------------------
15 */
17 #include <math.h> // Funciones matemáticas
19 int main(void){
20 double a,b,c,p,area;
21 cout << "\nEste programa calcula el área de un ";
22 cout << "\ntriángulo a partir de la medida de sus lados.";
23 cout << "\nIntroduce la medida del primer lado: ";
24 cin >> a;
25 cout << "\nIntroduce la medida del segundo lado: ";
26 cin >> b;
27 cout << "\nIntroduce la medida del tercer lado: ";
28 cin >> c;
29 if (((a + b) > c) && ((b + c) > a) && ((a + c) > b)){
30 // verifico que cumpla la desigualdad del triángulo...
31 // la suma de dos lados siempre es mayor al tercero...
32 p = (a + b + c)/2; // Semiperı́metro
33 area = sqrt(p*(p-a)*(p-b)*(p-c));
34 cout << "\nEl área de el triángulo es:" << area
35 << endl;
36 }
37 else{
2 Observe se aplica la desigualdad del triángulo en la condición If.

en C++
54 Códigos
38 // por ejemplo, si ingresó:

39 // primer lado = 100, segundo lado = 1, tercer lado = 1
40 cout << "\nEs imposible construir un triángulo ";
41 cout << "\ncon esas longitudes para sus lados. "
42 // i.e., pareces güey!!!
43 << endl;
44 }
45 system("PAUSE");
46 return 0;
47 }
o • Calcular la distancia de un punto a una recta.
1 /* Nombre del archivo: DosOcho.cpp

2 Descripción:
3 Escribir un programa que calcule la distancia
4 desde el punto P(x_0, y_0) a la recta
5 Ax+By+C=0.
6

8 ----------------------------------
9 ----------------------------------
10 */
12 #include <math.h> // Funciones matemáticas
14 int main(void){
15 double A,B,C,x_0,y_0,d;
16 cout << "\nEste programa calcula la distancia desde el ";
17 cout << "\npunto P(x_0, y_0) hasta la recta: Ax + By + C = 0";
18 cout << "\nIntroduce el coeficiente A: ";
19 cin >> A;
20 cout << "\nIntroduce el coeficiente B: ";
21 cin >> B;
22 cout << "\nIntroduce el coeficiente C: ";
23 cin >> C;
24 cout << "\nIntroduce la coordenada x_0 del punto P: ";
25 cin >> x_0;
26 cout << "\nIntroduce la coordenada y_0 del punto P: ";
27 cin >> y_0;
28 d = fabs(A*x_0 + B*y_0 + C)/sqrt(A*A + B*B);
29 cout << "\nLa distancia desde el punto P(" << x_0
30 << " , " << y_0 << "), es:" << d << endl;
31 system("PAUSE");
32 return 0;
33 }

en C++
• Decidir si un número entero positivo dado es par o impar.

o
1 /* Nombre del archivo: DosNueve.cpp
2 Descripción:
3 Escribir un programa que determine si el número
4 positivo introducido por el usuario es par o impar.
5

7 ----------------------------------
8 ----------------------------------
9 */
12 int main(void){
13 int ent,residuo;
14 char respuesta;
15 cout << "\nEste programa pide un número entero positivo";
16 cout << "\ny decide si es par o impar...";
17 for (;;){
18 cout << "\nIntroduce un número entero positivo:";
19 cin >> ent;
20 // Encuentro el residuo de la división por 2
21 // para saber si es par o impar...
22 residuo = ent % 2;
23 if (ent <= 0) {
24 cout << "\nSolo acepto números enteros positivos."
25 << endl;
26 }
27 else{
28 if (residuo == 0){
29 cout << "\nEl número es par." << endl;
30 }
31 else{
32 cout << "\nEl número es impar." << endl;
33 }
34 }
35 cout << "\nPresione < S > para salir...";
39 }
40 cout <<"\n\n\n";
41 }
42 return 0;
43 }
• Convertir temperaturas de la escala Farenheit a la escala centı́grada. o

en C++
56 Códigos
1 /* Nombre del archivo: DosDiez.cpp

2 Descripción:
3 Escribir un programa que convierta una temperatura
4 dada por el usuario en grados Farenheit a grados
5 Celsius.
6 El usuario debe poder realizar el cálculo tantas
7 veces como lo desee.
8
9 Fecha de última Modificación: 05 enero de 2008

10 ----------------------------------
11 ----------------------------------
12 */
15 int main(void){
16 double C, F;
17 char respuesta;
18 cout << "\nEste programa convierte una temperatura ";
19 cout << "\nde la escala Farenheit a Centı́grada...";
20 for (;;){
21 cout << "\nIntroduce la temperatura en escala Farenheit: ";
22 cin >> F;
23 C = (F - 32) / 1.8;
24 cout << endl << F << " grados Farenheit equivalen a " << C
25 << " grados Centı́grados" << endl ;
26 //
27 cout << "Presione < S > para salir...";
31 }
32 cout <<"\n\n\n";
33 }
34 return 0;
35 }
o • Encontrar el mayor de 3 números enteros dados.
1 /* Nombre del archivo: DosOnce.cpp

2 Descripción:
3 Escribir un programa que lea tres números e imprima el mayor
4 valor de los 3.
5

7 ----------------------------------
8 ----------------------------------
9 */

en C++
12 int main(void){
13 int a,b,c,max;
14 char respuesta;
15 cout << "\nEste programa pide tres números enteros";
16 cout << "\ne indica el mayor de los tres.";
17 //
18 for (;;){
19 cout << "\nIntroduce el primer número ";
20 cin >> a;
21 cout << "\nIntroduce el segundo número ";
22 cin >> b;
23 cout << "\nIntroduce el tercer número ";
24 cin >> c;
25 if (a > b){
26 max = a;
27 }
28 else{
29 max = b;
30 }
31 if (c > max){
32 max = c;
33 }
34 cout << "\nEl mayor de los números es: " << max << endl;
35 //
40 }
41 cout <<"\n\n\n";
42 }
43 return 0;
44 }
• Encontrar el mayor y el menor de 3 números enteros dados. o

1 /* Nombre del archivo: DosDoce.cpp
2 Descripción:
3 Escribir un programa que lea tres números enteros e
4 indique el mayor de los 3 y el menor de los 3.
5

7 ----------------------------------
8 ----------------------------------
9 */

en C++
58 Códigos

12 int main(void){
13 int a,b,c,min,max;
14 char respuesta;
15 cout << "\nEste programa pide tres números enteros,";
16 cout << "\nindica el mayor de los tres y ";
17 cout << "\nel menor de los tres...";
18 //
19 for (;;){
20 cout << "\nIntroduce el primer número ";
21 cin >> a;
22 cout << "\nIntroduce el segundo número ";
23 cin >> b;
24 cout << "\nIntroduce el tercer número ";
25 cin >> c;
26 if (a > b){
27 max = a;
28 min = b;
29 }
30 else{
31 max = b;
32 min = a;
33 }
34 if (c > max){
35 max = c;
36 }
37 if (c < min){
38 min = c;
39 }
40 cout << "\nEl menor de los números es: " << min << endl;
41 cout << "\ny el mayor de los números es: " << max << endl;
42 //
47 }
48 cout <<"\n\n\n";
49 }
50 return 0;
51 }
o • Identificar el mayor y el menor de una lista de números.
1 /* Nombre del archivo: DosTrece.cpp

2 Descripción:
3 Escribir un programa que lea una lista de números
4 positivos y escriba el valor máximo y el valor

en C++
5 mı́nimo. La lista finalizará cuando se introduzca el

6 número cero (0).
7

9 ----------------------------------
10 ----------------------------------
11 */
14 int main(void){
15 double inicial, actual, max, min;
16 char respuesta;
17 cout << "\nEste programa pide números positivos,";
18 cout << "\nindica el mayor de todos y ";
19 cout << "\nel menor de ellos..." << endl;
20 cout << "\nPara terminar de ingresar los números";
21 cout << "\nintroduce el número 0" << endl;
22 //
23 for (;;){
24 cout << "\nIntroduce el primer número positivo: ";
25 cin >> actual;
26 min = actual; // Asigno valor inicial min
27 max = actual; // Asigno valor inicial max
28 while (actual !=0){ // mientras no presione cero...
29 if (actual > max){
30 max = actual;
31 }
32 if (actual < min){
33 min = actual;
34 }
35 cout << "\nIntroduce otro número positivo: ";
36 cin >> actual;
37 }
38 cout << "\nEl mayor de todos los números introducidos es: "
39 << max << endl;
40 cout << "\nEl menor de todos los números introducidos es: "
41 << min << endl;
42 //
43 cout << "Presione < S > para salir o < C > para continuar...";
47 }
48 cout <<"\n\n\n";
49 }
50 return 0;
51 }

en C++
60 Códigos
2.5 Mis tareas

En esta sección encontrarás el código de las tareas que voy entregando en mis
clases de Simulación de Sistemas.
2.5.1 Simulación 1
Se lanza un alfiler de longitud L a una mesa que tiene dibujadas lı́neas paralelas
equidistantes separadas a L unidades una de la otra. Calcular la probabilidad
de que el alfiler toque lı́nea.
Consideraciones
Se realizaron las siguientes suposiciones:
1. La longitud del alfiler es 1.

2. El alfiler siempre cae dentro de la mesa.
3. La distancia (medida verticalmente) de una recta a la cabeza del alfiler es
una variable aleatoria que presenta distribución uniforme.
4. El ángulo que forma el alfiler con las rectas dibujadas sobre la mesa es una
variable aleatoria que presenta distribución uniforme.
Con base en estas suposiciones, podemos definir como x la distancia (medida

verticalmente) de una recta a la cabeza del alfiler, y θ como el ángulo que forma
una de las rectas dibujadas sobre la mesa y el alfiler.
1
ì+1
x θ
ì
0
Ahora definimos y como la posición de la punta del alfiler (el extremo opuesto
a la cabeza del alfiler).
Dado que el alfiler mide 1, la coordenada y puede calcularse con:
y = x + sin (2 π θ)

en C++
2.5 Mis tareas 61
donde π = 3.141592654 · · · , es la constante geométrica3 , y θ es el ángulo como

se definió anteriormente.
El alfiler tocará lı́nea siempre y cuando se cumpla alguna de las siguientes condi-
ciones:
i. y > 1, ó
ii. y < 0
Geométricamente, de la figura podemos ver que en estos casos, la punta del

alfiler estará fuera del área encerrada por las lı́neas paralelas ì y ì+1 .
Simulación por computadora
En seguida se muestra el código del programa que simula este experimento.
/* Nombre del archivo: simulacion01.cpp

Descripción:
Este programa simula el siguiente experimento:
Se lanza un alfiler de longitud L a una mesa
que tiene dibujadas lı́neas paralelas equidistantes
separadas a L unidades una de la otra.
El usuario debe ingresar el número total de
experimentos (entero) que se deben realizar,
entendiendo por experimento la simulación de un
lanzamiento del alfiler sobre la mesa.
El resultado indica la probabilidad de que el
alfiler toque una de las lı́neas dibujadas sobre la
mesa.
----------------------------------------------------
----------------------------------------------------
Autor: Efraı́n Soto Apolinar
Email: efrain@yalma.fime.uanl.mx
Fecha de última Modificación: 24 de enero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
----------------------------------------------------
----------------------------------------------------
*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <math.h> // funciones matemáticas (sin (double))
#include <conio.h> // para usar: getche, getch
using namespace std;
int main(void)
3 Al multiplicar θ por 2 π convertimos la variable aleatoria θ, cuyos valores van desde 0
hasta 1 a radianes. Se trata de un simple mapeo uno a uno.

en C++
62 Códigos
{
char respuesta;
int si, no, i, j, total;
double p, x, y, a;
const double pi = 3.141592654;
/*
x --> representa la distancia de una recta
paralela de referencia
al punto donde cayó la cabeza del alfiler.
y = x + sin (2 * pi * a)
a --> es el ángulo que forma el alfiler con
las rectas paralelas dibujadas sobre
la mesa
si --> es el número de veces que el alfiler
toca lı́nea
no --> es el número de veces que el alfiler
NO toca lı́nea
p --> es la probabilidad de que toque...
total --> es el número de experimentos que
realizará el programa...
*/
cout << "\nEste programa calcula la probabilidad de que";
cout << "\nal lanzar un alfiler de una longitud dada ";
cout << "\nsobre una mesa que tiene dibujadas lı́neas ";
cout << "\nparalelas separadas por una distancia igual ";
cout << "\na la longitud del alfiler, toque lı́nea... ";
//
for (;;)
{
cout << "\n\n\nIngrese el número de experimentos: ";
cin >> total;
si = no = 0;
p = 0;
for (i = 1 ; i <= total ; i++)
{ // realizo los experimentos
x = double(rand()) / double(RAND_MAX);
a = double(rand()) / double(RAND_MAX);
y = x + sin(2*pi*a);
if ((y < 0) || (y > 1))
{si++;}
else
{no++;}
} // end del ciclo for ()
p = double(si) / double(total);
cout << "\n\n\nDe los " << total << " experimentos ";
cout << si << " tocaron lı́nea, \nmientras que " << no ;
cout << " no tocaron lı́nea.\n";
cout << "\nDe aquı́ que la probabilidad de que el alfiler";
cout << "\ntoque lı́nea es: " << p;
cout << "\n\n\n";

en C++
2.5 Mis tareas 63
//
cout << "Presione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’))
{
break; // Salir del ciclo for inicial...
}
cout <<"\n\n\n";
}
return 0;
}
Como los resultados generados con este programa son aleatorios, los resultados
varı́an ligeramente.
En la siguiente tabla se muestran algunos resultados obtenidos con el mismo.
No. Experimentos Probabilidad

100 0.66
200 0.62
300 0.613333
400 0.63
500 0.644
600 0.646667
700 0.624173
800 0.64
900 0.647778
1 000 0.623
10 000 0.6437
106 0.636592
108 0.636612
De hecho, aún si se dan los mismos valores al programa, éste arrojará diferentes
resultados cada vez, dado que los valores que van tomando las variables x (que
representa la distancia desde la recta ì a la cabeza del alfiler) y θ (que representa
el ángulo que forma el alfiler con cualquiera de las lı́neas dibujadas sobre la mesa)
son variables aleatorias con distribución contı́nua.
Esto se puede verificar realizando los cálculos de nuevo con el programa ali-
mentándolo con los mismos valores.

en C++
64 Códigos
2.5.2 Cálculo analı́tico
Para hacer el cálculo analı́tico podemos definir las siguientes coordenadas: Sea
d la distancia del centro del alfiler a la recta más cercana.
Sea ` esta recta, y sea α como el menor ángulo formado entre ` y el alfiler. De
aquı́ se deduce que:
1 π
0≤d≤ , y 0≤α≤
2 2
También es claro que el alfiler tocará la recta ` si la hipotenusa del triángulo es
menor a 0.5, es decir:
d 1
<
sin α 2
Entonces, al lanzar el alfiler, las coordenadas (d, α) tienen distribución uniforme
en los intervalos antes definidos, que se pueden representar mediante el siguiente
rectángulo:
1
2
π
2
La probabilidad de que el alfiler toque lı́nea es igual a la fracción del área del
1
rectángulo que yace debajo de la gráfica de la función: d = sin α.
2
El área del rectángulo es: π/4 y el área debajo de la gráfica de la función en
cuestión es:
Zπ/2
1 1
sin α dα =
2 2
0
y ası́ obtenemos:
1
p(A) = π2 = 2 ≈ 0.6366197724
π
4
Ası́ que la simulación codificada en C++ es correcta.

en C++
2.5 Mis tareas 65
Desarrollar una simulación por computadora que simule experimentos de

Bernoulli. El programa debe repetir los intentos hasta que se supere un valor
fijo p de éxito, definido por el usuario. Este mismo experimento debe realizarse
con el método binomial. Se debe ir calculando el valor de la probabilidad bino-
mial P (n, k) para k = 0, 1, 2 · · · i, hasta que se rebase el valor de p.
El programa debe indicar al usuario cuántos intentos de Bernoulli se requierieron
para superar el valor de p y cuántas iteraciones binomiales se requirieron para
alcanzar el mismo objetivo.
Se elaboró un programa que requiere de la siguiente información:
3 Máximo de intentos de Bernoulli, que corresponde al número máximo de

experimentos de Bernoulli que se simularán.
3 El valor de la probabilidad de éxito, que corresponde al valor de p del

evento a simular.
El código en el lenguaje C++ se enlista en seguida.

Descripción:
Este programa simula experimentos de Bernoulli
y probabilidad binomial.
----------------------------------------------------
----------------------------------------------------
efra.soto.a@gmail.com
Webpage: http://yalma.fime.uanl.mx/˜efrain/
Fecha de última Modificación: 03 de febrero de 2008
----------------------------------------------------
----------------------------------------------------
*/
#include <math.h> // funciones matemáticas (pow (double))
#include <ctime> // clock_t = clock();
int errores; // variable global...

en C++
66 Códigos
int factorial(int n);

int permuta(int n, int k);
//
int main(void){
char respuesta;
int i, j, kBer, kBin, n;
double p, q, prob, x;
//
cout << "\nEste programa simula experimentos binomiales";
cout << "\ny repeticiones de experimentos de Bernoulli...";
//
//
//
for (;;){
errores = 0;
kBer = 0;
kBin = 0;
cout << "\n\n\nMáximo de intentos de Bernoulli: ";
cin >> n;
if((n < 0) || (n > 20)) {
cout << "\nn debe estar entre 1 y 20 (inclusive)...";
cout << "\n\n";
continue;
}
for (;;) { // para que pueda ingresar el valor de p...
cout << "\nIngrese el valor de la probabilidad de éxito: ";
cin >> p;
if ((p < 0) || (p > 1)) {
cout << "\np está entre cero y uno (inclusive)...";
cout << "\n\n\n";
continue;
}
q = 1 - p; // probabilidad de fracaso...
break;
} // termina el for...
//
//
//
// realizo el cálculo de acuerdo a Bernoulli...
for (i=1 ; i <= n ; i++) {

x = double(rand()) / double(RAND_MAX); // genero x
if (p >= x){
kBer++;
} // endif
} // end for
//
//
// realizo el cálculo por Binomial...

en C++
2.5 Mis tareas 67
x = double(rand())/ double(RAND_MAX); // genero x

prob = 0; // inicio la probabilidad acumulada de Bernoulli
kBin = 0; // inicio el número de intentos...
for(;;){ // for infinito...
prob += double(permuta(n,kBin)) * pow(p,double(kBin))
* pow(q,double(n-kBin));
if (prob >= x) {
break;
}
kBin++;
}
//
// Muestro los resultados...
cout << "\n\n\nIntentos con Bernoulli: " << kBer;
cout << "\n\nIntentos con Binomial: " << kBin;
cout << "\n\n\nTotal de errores: " << errores;
//
cout << "\n\n\nPresione < S > para salir...";
if ((respuesta == ’S’)||(respuesta == ’s’)){
}
cout << "\n\n\n";
}
return 0;
}
/**************************************
Declaro la función factorial...
***************************************/
int factorial(int n){
long fi,i;
fi = i = 1;
while (i <= n){
fi *=i;
if (fi <= 0){ // por si se pasa la memoria...
cout << "\nLo siento, se rebasó la memoria...";
fi = 1;
errores++;
break;
}
i++;
}
return fi;
}
/**************************************
Declaro la función permuta...
***************************************/
int permuta(int n, int k){
int perm,subfactorial,i;
i = n - k + 1; // n - k + 1 para calcular el subfactorial

en C++
68 Códigos
subfactorial = 1; // reinicio el subfactorial

while (i <= n){
subfactorial *= i;
i++;
}
perm = subfactorial / factorial(k);
return perm;
}
Desarrollar un programa por computadora que simule experimentos con dis-

tribución de Poisson. El programa debe repetir los intentos hasta que se supere
un valor fijo p de éxito, definido por el usuario.
El programa debe indicar al usuario cuántos intentos del experimento se re-
quierieron para superar el valor de p.
Se elaboró un programa que requiere de la siguiente información:
3 Valor de Lambda, que corresponde al promedio de la muestra.

3 El valor de la probabilidad de éxito, que corresponde al valor de p del
evento a simular.

Descripción:
Este programa simula experimentos con distribución de Poisson
y probabilidad binomial.
----------------------------------------------------
----------------------------------------------------
----------------------------------------------------
----------------------------------------------------
*/

en C++
2.5 Mis tareas 69
#include <math.h> // funciones matemáticas (pow (double))


int factorial(int n);
int permuta(int n, int k);
//
int main(void){
char respuesta;
int i, k;
double p, prob, x, lambda;
//
cout << "\nEste programa simula experimentos con";
cout << "\ndistribucion de Poisson...";
//
//
//
for (;;){
errores = 0;
cout << "\n\n\nValor de Lambda (Promedio): ";
cin >> lambda;
if((lambda < 0)) {
cout << "\nLambda debe ser un valor positivo...\n\n";
continue;
}
for (;;) { // para que pueda ingresar el valor de p...
cout << "\nIngrese el valor de la probabilidad de éxito: ";
cin >> p;
if ((p < 0) || (p > 1)) {
cout << "\np está entre cero y uno (inclusive)...";
cout << "\n\n\n";
continue;
}
break;
} // termina el for...
//
//
// realizo el cálculo de la probabilidad...
srand(unsigned(time(0)));// Semilla para el aleatorio...
x = double(rand())/ double(RAND_MAX); // genero x

prob = 0; // inicio la probabilidad acumulada
for(i = 0 ; prob <= x ; i++){
prob += exp(-lambda) * pow(lambda,i) / factorial(i);
//
}

en C++
70 Códigos
//
cout << "\n\n\nIntentos con Poisson: " << i-1;
cout << "\n\n\nTotal de errores: " << errores;
//
}
cout << "\n\n\n";
}
return 0;
}
/**************************************
***************************************/
long fi,i;
fi = i = 1;
while (i <= n){
fi *=i;
fi = 1;
errores++;
break;
}
i++;
}
return fi;
}
Desarrollar un programa por computadora que simule el lanzamiento de dos

dados.
El programa debe permitir al usuario indicar cuántos experimentos realizar y si
desea o no ver los resultados de cada experimento.
El programa debe imprimir en pantalla el promedio de la suma de todos los
experimentos realizados.

en C++
2.5 Mis tareas 71
Descripción:
Este programa simula el lanzamiento de dos dados...
----------------------------------------------------
----------------------------------------------------
----------------------------------------------------
----------------------------------------------------
*/

int main(void){
char respuesta,resp;
int i, x, y, n; // variables aleatorias...
int suma;
double promedio;
//
cout << "\nEste programa simula el lanzamiento";
cout << "\nde dos dados...";
//
//
//
for (;;){
// realizo el cálculo de la probabilidad...
cout << "\n\n\n¿Cuántos lanzamientos deseas simular? ";
cin >> n;
cout << "\n\n\n¿Deseas ver los resultados? ";
cin >> resp;
suma = 0; // reinicio la suma de resultados...
if ((resp == ’S’)||(resp == ’s’)){
cout << "\n\nSimulación ";
cout << "\t\tDADO 1: ";
cout << "\tDADO 2: ";
cout << "\tSUMA: \n";
}
for (i = 1 ; i <= n ; i++ ){
//
x = (rand() % 6) + 1;
y = (rand() % 6) + 1;
//

en C++
72 Códigos
suma += x+y;
if ((resp == ’S’)||(resp == ’s’)){
cout << "\t" << i << "\t";
cout << "\t " << x << "\t";
cout << "\t " << y << "\t";
cout << "\t " << x+y << "\n\n";
}
}
promedio = double(suma) / double(i-1);
cout << "\n\n\n Suma Promedio: " << promedio;
//
}
cout << "\n\n\n";
}
return 0;
}
2.5.6 Simulacion 5
Elaborar un programa para simular experimentos con distribución de Poisson.

La variable de dominio tiene una distribución exponencial y se compara con
la distribución de Poisson con dominio en una variable aleatoria que presenta
distribución uniforme.

Descripción:
Este programa simula experimentos con distribución de Poisson
cuya variable de dominio tiene una distribución exponencial
y compararla con la distribución de Poisson con dominio en
una variable aleatoria con distribución uniforme.
----------------------------------------------------
----------------------------------------------------
----------------------------------------------------
----------------------------------------------------

en C++
2.5 Mis tareas 73
*/
#include <iostream> // Funciones básicas input/output
#include <stdlib.h> // para la función rand()
#include <math.h> // funciones matemáticas
#include <conio.h> // para usar getche, getch
#include <ctime> // clock();

int factorial(int n); // función...

int main(void){
char respuesta;
int i, ipe, ip;
double prob, probe, u, lambda, x;
//
for (;;){
cout << "\nEste programa simula experimentos con";
cout << "\ndistribucion de Poisson a partir de una";
cout << "\nvariable aleatoria con distribución exponencial...";
//
//
// Con distribución Poisson - Exponencial
probe = 0; // inicio la probabilidad acumulada
for(i = 0 ; probe <= 1 ; i++){ // calculo la probabilidad...
u = double(rand())/ double(RAND_MAX); // genero x
x = - log(1 - u) / u; //
probe += exp(-x) * pow(x,i) / factorial(i);
ipe = i;
}
//
// Ahora realizo el cálculo con distribución uniforme...
prob = 0; // inicio la probabilidad acumulada
for(i = 0 ; prob <= 1 ; i++){
prob += exp(-lambda) * pow(lambda,i) / factorial(i);
//
}
//
cout << "\n\n\nIntentos con poisson exponencial: " << ipe;
cout << "\n\n\nIntentos con poisson uniforme: " << i;

}
cout << "\n\n\n";
}

en C++
74 Códigos
return 0;
}
/**************************************
***************************************/
long fi,i;
fi = i = 1;
while (i <= n){
fi *=i;
fi = 1;
errores++;
break;
}
i++;
}
return fi;
}
2.5.7 Simulacion 6
Elaborar un programa para simular la transformación inversa de la distribución

normal, esto es, a partir del valor de u = Φ(x) calcula de manera aproximada
x. El usuario indica el valor u que está en el intervalo (0,1)

Descripción:
Este programa simula transformación inversa de la
distribución normal, esto es, a partir del valor de
u = Phi(x) calcula de manera aproximada x.
El usuario indica el valor u que está en el
intervalo (0,1)
----------------------------------------------------
----------------------------------------------------
----------------------------------------------------
----------------------------------------------------
*/

en C++
2.5 Mis tareas 75

#include <stdlib.h> // para usar rand()
#include <ctime> // clock();

double rfactorial(int n); // función...
double normal(double x); // función...
double intnormal(double x);
const double pi = 3.141592653589; // global

int main(void){
char respuesta;
double x, xa, u, approx, approxa;
double step, error, errorx;
int j, total, cont, z;
char signo;
// para los dı́gitos...
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(8);
//
for (;;){
cout << "\nEste programa simula la generación de números";
cout << "\ncon distribucion normal a partir de un";
cout << "\nvalor dado por el usuario entre cero y uno...";
for (;;){
cout << "\n\n\ningresa un valor entre cero y 1: ";
cin >> u;
if (u < 0 && u > 1){
cout << "\nError en argumento...";
cout << "\n\n";
continue;
}
break;
} // end for para pedir u
//
x = 0; // valor inicial supuesto (media)
z = 0;
if (u < 0.01){
step = u / 2;
}
else{
step = 0.25;
}
for (;;){
//
xa = x;

en C++
76 Códigos
approx = normal(x);
// Decido si incremento o decremento x

while (approx < u){
x += step;
approx = normal(x);
z++;
}
step /= 1.5;
while (approx > u){
x -= step;
approx = normal(x);
z++;
}
step /= 1.5;
if (approx < 0.0001 && fabs(x) > 3.999){
x = u / 2;
approx = normal(u);
}
// calculo el error relativo para x

if (fabs(xa - x) < 0.0001){
// Criterio para salir del ciclo...
cout << "\tu = " << u << "\tApprox = "
<< intnormal(x) << "\t x = " << x;
break;
}
} // end for que hace las iteraciones...

//
break; // Salir...
}
cout << "\n\n\n";
} // end for infinito...
return 0; // Salir...
}
/**************************************
Declaro la función normal...
***************************************/
double normal(double x){
double u = 0;
double un, ua, temp;
int i;
if (x < -4){
return 0;
}

en C++
2.5 Mis tareas 77
if (x > 4){
return 1;
}
for (i = 0 ; i < 40 ; i++){
ua = u;
u += pow(-0.5 * x * x,i) * rfactorial(i) / (2*i+1);
un = u;
} // endfor
if (x < 0 ){
u = 0.5 - u * x / sqrt(2*pi);
}
else{
u = 0.5 + u * x / sqrt(2*pi);
}
return u;
}
/**************************************
Declaro la función normal...
***************************************/
double intnormal(double x){
double u = 0;
double ua, up, ac;
double xi, step;
// xi es la iteracion actual
// step es el tamaño del paso...
int i;
step = 0.00000001; // El paso es 1 / 10ˆ7
xi = 0; // empieza a integrar desde cero...
while (xi <= fabs(x)){
u += exp(- xi * xi / 2) * step;
xi += step;
} // endfor
u = u / sqrt(2 * pi) + 0.5;
if (x < 0 ){
return (u - 0.5);
}
else{
return u;
}
}
/**************************************
Declaro la función rfactorial...
***************************************/
double rfactorial(int n){
double fi, i;
int j;
fi = i = 1.0;

en C++
78 Códigos
j = 1;
//
while (j <= n){
fi /=i;
i = i + 1;
j++;
}
return fi;
}
2.5.8 Simulacion 7
Programar un generador de números pseudoaleatorios con distribución normal

por el método de aceptación - rechazo.

Este programa simula la generación de números
aleatorios con distribución normal
por el método de aceptación - rechazo.
----------------------------------
----------------------------------
Email: efra.soto.a@gmail.com
efrain@yalma.fime.uanl.mx
Fecha de última Modificación: 01 de marzo de 2008
----------------------------------
----------------------------------
*/
#include <cstdio> //
#include <cstdlib> //
// Defino las funciones que voy a usar...

double f(double y);
double g(double y);
//
int main(void){
int i, total;
char respuesta;
double x, y, z, u;
// el valor de c = 1.315489247, se calculó con:
// const double c = sqrt(2 * 2.718281828 / 3.141592653);

en C++
2.5 Mis tareas 79
const double c = 1.315489247;

//
for (;;){ // for infinito...
cout << "\nEste programa simula la generacion de numeros";
cout << "\ncon distribucion normal con el metodo de ";
cout << "\naceptacion y rechazo...";
cout << "\n\nCuantos numeros desea generar... ";
cin >> total;
cout << "\n\n\n"; // un poco de espacio...
for (i = 1; i<= total ; i++){
x = double(rand()) / double(RAND_MAX); // aleatorio
z = double(rand()) / double(RAND_MAX); // aleatorio
if (z < 0.5){ // genero el valor de y
y = log(2 * z);
}
else{
y = - log(2 - 2 * z);
}
// x es el valor a comparar...
// y es el argumento de las funciones...
u = f(y) / (c * g(y));
if (u >= x){
// aceptar el valor...
cout << "\n" <\t" << y;
}
}
}
cout << "\n\n\n";
return 0;
}
/*************************************
Defino la función f(y)
**************************************/
double f(double y){
return 0.39894228 * exp(- y * y / 2) ;
// el factor
// 0.39894228 = 1 / sqrt(2 * 3.141592653);
}
/*************************************
Defino la función g(y)
**************************************/
double g(double y){
return exp(-fabs(y)) / 2;

en C++
80 Códigos
2.5.9 Simulacion 8
Elaborar un programa para simular un movimiento browniano
• Puede encontrar un PDF con una animación de los resultados generados por
este programa en: http://yalma.fime.uanl.mx/~efrain/project.html

Este programa simula un movimiento browniano.
----------------------------------
----------------------------------
----------------------------------
----------------------------------
*/
#include <fstream> // para grabar los datos generados...
//
const double PI = 3.141592653;
double step;
// función para generar los números pseudoaleatorios

// con distribución normal...
double dnormal(double media, double sigma);
double dnormal(void);
// Función para generar un número pseudoaleatorio

// con distribución uniforme en el intervalo (0,1)
double uniforme(void);

int main(void){
char respuesta, semilla;
double t, tiempo; // escala de tiempo.
double xn, x = 0; // posición de la partı́cula.
double media, sigma; // parámetros de dist. Normal.

en C++
2.5 Mis tareas 81
int i = 0;
//
cout << "\nEste programa simula un ";
cout << "movimiento browniano ";
cout << "\n\nTiempo en segundos a simular: ";
cin >> tiempo;
for (;;){
cout << "\nIntervalo entre dos posiciones consecutivas
(seg): ";
cin >> step;
if (step <= 0){
cout << "\n\nEl intervalo debe ser positivo...";
cout << "\nPreferentemente menor a un segundo.";
cout << "\nValor sugerido: 0.05";
}
else{ // ingresó un step positivo...
break;
cout << "\n\n\n";
}
} // end for...
// No requiero los siguientes renglones porque
// se definió el problema con media cero...
cout << "\nMedia de la posicion de la partı́cula:
(sobre el eje x)";
cout << "\n(Presione 0 (cero) si la desconoce): ";
cin >> media;
cout << "\n\nDesviacion estandar de la posicion...";
cout << "\n(Presione 0 si la desconoce): ";
cin >> sigma;
if (sigma == 0){
sigma = 1;
}
for (;;){ // hasta que presione S ó N
cout << "\n\nDesea iniciar la semilla?";
cout << "\n(del generador de numeros aleatorios) [S/N]";
cin >> semilla;
if (semilla == ’S’ || semilla == ’s’){
srand(unsigned(time(0)));
cout << "\n\nSe reinicia la semilla...";
break; // salir del for infinito
}
if (semilla == ’N’ || semilla == ’n’){
cout << "\n\nNo se reinicia la semilla...";
}
cout << "\n\nError en argumento...";
} // end for infinito para la semilla
cout << "\n\n\n"; // un poco de espacio...
t = 0; // reinicio el tiempo del experimento...

en C++
82 Códigos
ofstream out_stream; // creo canal p/escritura de datos...

out_stream.open("brown.txt"); // creo y abro el archivo...
if (out_stream.fail()){ // si no puede abrir el archivo...
cout << "\n\nNo se pudo abrir el archivo...";
cout << "\nPor favor, reinicie el programa...";
exit(1); // Termina el programa
}
out_stream << "\n";
out_stream << "# Simulacion de un movimiento Browniano"
<< "\n";
out_stream << "# el eje t representa al tiempo" << "\n";
out_stream << "# y el eje x (vertical) representa la
posicion..." << "\n";
out_stream << "# Los datos van desde t = 0 hasta t = "
<< tiempo << ".\n";
out_stream << "0 0 i\n"; // Primer dato...
for (t = step; t <= tiempo ; t += step){
x += dnormal();
out_stream << t << " " << x << " i\n";
i++;
}
cout << "\n\n\nSe han grabado " << i
<< " datos en el archivo";
cout << "\nbrown.txt\n";
out_stream << "# Este archivo contiene "
<< i << " datos.";
// pregunto si desea salir...

}
cout << "\n\n\n";
return 0;
}
/**************************************
Declaro la función DNORMAL...
***************************************/
double dnormal(double media, double sigma){
/*
Esta función genera números pseudoaleatorios
con distribución uniforme a partir de su media
y su desviación estándar.
*/
double u, v, x, y, z;
u = uniforme();
y = uniforme();

en C++
2.5 Mis tareas 83
x = sqrt(-2 * log(u)) * cos(2 * PI * y);

if (u >= 0.5){
z = media + sigma * step * x;
}
else{
z = media - sigma * step * x;
}
return z;
// step se utiliza porque el problema define
// que la varianza es proporcional al intervalo de tiempo.
}
/**************************************
Declaro la función DNORMAL...
***************************************/
double dnormal(void){
/*
Esta función genera números pseudoaleatorios
con distribución uniforme.
*/
double u, x, y, z;
// Defino la media y desviación estándar...
double media = 0, sigma = 1;
u = uniforme();
y = uniforme();
x = sqrt(-2 * log(u)) * cos(2 * PI * y);
if (u >= 0.5){
z = media + sigma * step * x;
}
else{
z = media - sigma * step * x;
}
return z;
// step se utiliza porque el problema define
// que la varianza es proporcional al intervalo de tiempo.
}
/**************************************
Declaro la función UNIFORME...
***************************************/
double uniforme(void){
// Esta función genera un número pseudoaleatorio
// con distribución uniforme en el intervalo (0,1).
return (double(rand())/double(RAND_MAX));
}

en C++
84 Códigos
2.5.10 Simulación de la distribución binomial
Utilizando ANSI-C y las funciones de generación de números pseudoaleatorios,

escribe un programa que por simulación y la ley de grandes números aproxima
la distribución binomial con n y p para todos los valores de k = 0, 1, 2, · · · , n.
Incluye en tu respuesta el código que escribiste junto con un dibujo preparado
con gnuplot de la distribucion Bin(n, p) con los valores definidos para n y p.
1 /*
2 Tarea 3.
3 Nombre del archivo: tres.c
4 Utilizando ANSI-C y las funciones de generacion
5 de numeros pseudoaleatorios, escribe un programa
6 que por simulacion y la ley de numeros grandes
7 aproxima la distribucion binomial con n y p para
8 todos los valores de k = 0, 1, 2, . . . , n.
9 Incluye en tu respuesta el codigo que escribiste
10 junto con un dibujo preparado con gnuplot de la
11 distribucion Bin(n, p) con los valores definidos
12 para n y p.
13 Autor: Efrain Soto Apolinar.
14 fecha de ultima modificacion: 15 de agosto de 2008
15 */
17 #include <math.h>
18 #include <stdlib.h>
19 int combinaciones(int m, int k);
20 float binomial(double p, int N, int k);
21 void bernoulli(int n, double p, int N);
22 float uniforme(void);
23 int main(int argc, char** args) {
24 char letra;
25 int n, k, N = 15;
26 int i, j; // contadores
27 double p = 0.4;
28 float resp;
29 printf("\nEste programa simula un proceso");
30 printf("\nbinomial por la ley de los grandes numeros");
31 printf("\n\nparametro p = 0.4");
32 printf("\n\nparametro N = 15");
33 printf("\nIntroduce el numero de simulaciones:");
34 scanf("%i", &n);
35 // La simulacion es:
36 bernoulli(n, p, N);
37 printf("\n\nValores teoricos:\n");
38 for(i = 0 ; i < 16 ; i++){
39 printf("\nk = %i, p = %f,", i, binomial(p,N,i));

en C++
2.5 Mis tareas 85
40 }
41 printf("\n\n");
42 printf("\nPresiona una tecla...");
43 scanf("%c", &letra);
44 return 0;
45 }
46 /*-----------------------------------------------
47 Funcion para calcular las combinaciones
48 -------------------------------------------------*/
49 int combinaciones(int m, int k){
50 int i; // contador
51 long int num = 1;
52 long int den = 1;
53 int r = 1; // resultado
54 for(i = 0 ; i < k ; i++){
55 num = num * (m - i);
56 den = den * (i + 1);
57 // simplifico para que no crezca rapido...
58 while(num % 2 == 0 && den % 2 == 0){
59 num /= 2;
60 den /= 2;
61 }
62 while(num % 3 == 0 && den % 3 == 0){
63 num /= 3;
64 den /= 3;
65 }
66 while(num % 5 == 0 && den % 5 == 0){
67 num /= 5;
68 den /= 5;
69 }
70 }
71 r = num / den;
72 return r;
73 }
74
75 /*-----------------------------------------------
76 Funcion para calcular la probabilidad binomial
77 -------------------------------------------------*/
78 float binomial(double p, int N, int k){
80 float r; // respuesta
81 r = (int)(combinaciones(N,k)) * pow(p,k) * pow(1-p,N-k);
82 return r;
83 }
84
85 /*-----------------------------------------------
86 Funcion para el proceso de Bernoulli...
87 Voy a realizar n exprimentos de Bernoulli
88 p = probabilidad de exito
89 N = numero de ensayos por experimento

en C++
86 Códigos
90 n = numero de experimentos
91 -------------------------------------------------*/
92 void bernoulli(int n, double p, int N){
93 int arreglo[16]; // cuenta
94 int i, j, c; // contadores
95 int tote; // total de exitos
96 float u;
97 // reinicio el arreglo
98 for(c = 0 ; c < 16 ; c++){
99 arreglo[c] = 0;
100 }
101 // Vienen los n ensayos de Bernoulli
102 for(i = 1 ; i <= n ; i++){
103 tote = 0; // reinicio total exitos
104 for(j = 0 ; j <= N ; j++){
105 u = uniforme(); // pseudo-uniforme (0,1)
106 if (u <= p){ // exito
107 tote++;
108 }
109
110 }
111 arreglo[tote]++;
112 }
113 // Imprimo los resultados...
114 printf("\n\nResultados de la simulacion:\n");
115 for (c = 0 ; c < 16 ; c++){
116 printf("\nk = %i, p = %f,", c, 1.0 * arreglo[c]/n);
117 }
118 }
119
120 /*-----------------------------------------------
121 Funcion para generar uniformes (0,1)
122 -------------------------------------------------*/
123 float uniforme(void){
124 float u;
125 u = (float)(rand()) / RAND_MAX;
126 return u;
127 }

en C++
2.5 Mis tareas 87
2.5.11 Introducción a la dinámica de poblaciones
1. Definir estado inicial N (población inicial)
2. Probabilidad de un nacimiento sin muerte p (homogenea)

3. Probabilida de una muerte sin nacimiento q (homogenea)
4. Probabilidad de mantener el mismo estado 1 − p − q
3 Observar el desarrollo del tamaño de la población sobre varias repeti-

ciones del proceso.
3 Variar los valores de p y q.
1 /*
2 Simulacion de la dinamica de poblaciones
3 Fecha: 19 de agosto de 2008
4
5 Caso discreto.
6 Definir estado inicial N (poblacion inicial)
7 Probabilidad de un nacimiento sin muerte p (homogenea)
8 Probabilida de una muerte sin nacimiento q (homogenea)
9 Probabilidad de mantener el mismo estado 1 - p - q
10
11 Observar el desarrollo del tamaño de la poblacion

12 sobre varias repeticiones del proceso
13 */
17
18 double uniforme(void);
19
20 int main(int argc, char** args){

21 int i = 0; // contadores
22 double p = 0.45; // probabilidad de nuevo nacimiento
23 double q = 0.45; // probabilidad de muerte
24 double eq = 1 - p - q; // probabilidad de quedar igual
25 double r; // numero aleatorio
26 int N = 10000; // poblacion inicial
27 int MAXP = 10 * N; // poblacion final
28
29 // para el manejo del archivo...

30 FILE *stream_f; //
31 stream_f = fopen("datos.txt", "w"); // abrir para lectura
32 if (stream_f == NULL){
33 printf ("\nNo se puede abrir el archivo <<datos.txt>>\n");

en C++
88 Códigos
34 printf("\nPor favor, verifique el nombre archivo");

35 }
36 srand(unsigned(time(0)));
37 printf("\nEspere por favor...\n");
38 printf("\nSimulando dinamica de la poblacion...");
39 while (N > 0 && N < MAXP){
40 r = uniforme();
41 if (r <= p){
42 // Felicidades! nacio un changuito
43 N++;
44 }
45 if (r > p && r <= p + q){
46 // Desgracia, un changuito fue devorado
47 N--;
48 }
49 //if (r > p + q){
50 // Nadie nacio...
51 // Nadie murio...
52 //}
53 printf("\nt = %i \tN = %i",i, N);
54 // guardo en archivo...
55 if(i % 25 == 0){
56 fprintf(stream_f, "\n%i \t%i",i, N);
57 }
58 i++;
59 if (i > 10000){
60 break;
61 }
62 }
63 fclose(stream_f);
64 printf("\nSimulacion exitosa...");
65 return 0;
66 }
67
68 /*-----------------------------------------------
69 Funcion para generar uniformes (0,1)
70 -------------------------------------------------*/
71 double uniforme(void){
72 double u;
73 u = 1.0 * rand() / RAND_MAX;
74 return u;
75 }

en C++
2.6 Proyectos 89
2.6 Proyectos
En esta sección encontrarás códigos de problemas que he resuelto para incre-
mentar mi biblioteca de programas.
Espero que sean de ayuda para ti.
2.6.1 Regresión lineal

/* Nombre del archivo: LR.cpp
Este programa pide las coordenadas (x,y) de n puntos

y los graba en un archivo. Después lee estos datos y
calcula la recta de mejor ajuste por el método de
mı́nimos cuadrados.
----------------------------------
----------------------------------
----------------------------------
----------------------------------
*/
#include <fstream> // para grabar datos generados...
//
int main(void){
char respuesta, letra;
// char file_name[15];
int i, j, n; // contadores
double b, m; // parámetros...
double xi, yi; // datos
double Sx, Sy, Sxs, Sxy; // sumas de datos...
Sx = 0; Sy = 0; Sxs = 0; Sxy = 0;
// Información sobre el programa...
cout << "\n\nEste programa pide un grupo de datos ";
cout << "\nque corresponden a las coordenadas de n";

en C++
90 Códigos
cout << "\npuntos en el plano, guarda esta información";

cout << "\nen un archivo y después lee esa información";
cout << "\npara encontrar la recta de regresión";
cout << "\n\n\nPor favor, introduce las coordenadas de ";
cout << "\nlos puntos conocidos, ingresando primero";
cout << "\nlacoordenada en x y después la coordenada en y";
cout << "\nCuando hayas terminado introduce el número ";
cout << "\n1 000 000, pero sin espacios.";
ifstream in_stream;
ofstream out_stream;
// cout << "\nNombre del archivo: ";
// cin >> file_name;
//out_stream.open(file_name); // creo y abro el archivo...
//
out_stream.open("LR.txt"); // creo y abro el archivo...
}
for (i = 1 ; ; i++){
cout << "\nCoordenada en x del punto " <> xi;
if (xi == 1000000){
cout << "\n\n\nEl último valor no se incluye
en los datos...";
out_stream.close();// Cierro el archivo...
cout << "\nLos datos se han grabado correctamente...";
cout << "\n\nProcesando información...";
n = i - 1; // Número total de datos...
break;
}
cout << "\nCoordenada en y del punto " <> yi;
if (yi == 1000000){
en los datos...";
n = i - 1; // número total de datos...
break;
}
out_stream << xi << " " << yi << " i\n";
cout << "Dato " << i << " grabado correctamente";
cout << "\n";
} // Termino de grabar la información...
// Abrimos el archivo para leer...
in_stream.open("LR.txt");
if (in_stream.fail()){// si no puede abrir el archivo...

en C++
2.6 Proyectos 91

}
for (j=1; j <= n ; j++){ // realizo cálculos...
in_stream >> xi >> yi;
do { // estoy buscando el siguiente renglón
in_stream >> letra;
} while (!letra == ’\n’);
//
Sx += xi; // Suma de x
Sy += yi; // Suma de y
Sxy += xi * yi; // Suma de xy
Sxs += xi * xi; // Suma de x cuadrada
}
// Cierro el archivo de lectura...
in_stream.close();
// Calculo los parámetros...
m = (n * Sxy - Sx * Sy) / (n * Sxs - Sx * Sx);
b = (Sy - m * Sx) / n;
cout << "\n\n\n"; // espacio
cout << "La recta de mejor ajuste es: \n";
cout << "\n y = " << b << " + " << m << " x.";
}
cout << "\n\n\n";
return 0;
}
2.6.2 Regresión cuadrática

/* Nombre del archivo:CR.cpp
Este programa pide las coordenadas (x,y) de n puntos

y los graba en un archivo. Después lee estos datos y
calcula:
a) la recta demejor ajuste, la cual se expresa como:
y = beta + mx
b) La parábola de mejor ajuste, que se expresa como:
y = axˆ2 + bx + c

en C++
92 Códigos
ambos por el método de mı́nimos cuadrados.

----------------------------------
----------------------------------
----------------------------------
----------------------------------
*/
//
int main(void){
char respuesta, letra;
// char file_name[15];
int i, j, n; // contadores
double a, b, c; // parámetros para parábola...
double m, beta; // parámetros para recta...
double Da = 0, Dp = 0;
double xi, yi; // datos
double Sx, Sy, Sx2, Sx3, Sx4, Sxy, Sx2y;
double Error_p = 0, Error_r = 0;
double dip, dir, y_approxp, y_approxr;
Sx = 0; Sy = 0; Sxy = 0;
Sx2 = 0; Sx3 = 0; Sx4 = 0; Sx2y = 0;
// Información sobre el programa...
cout << "\n\nEste programa pide un grupo de datos ";
cout << "\nque corresponden a las coordenadas de n";
cout << "\npuntos en el plano, guarda esta información";
cout << "\nen un archivo y después lee esa información";
cout << "\npara encontrar la parábola de regresión";
cout << "\n\n\nPor favor, introduce las coordenadas de ";
cout << "\nlos puntos conocidos, ingresando primero";
cout << "\nlacoordenada en x y después la coordenada en y";
cout << "\nCuando hayas terminado introduce el número ";
cout << "\n1 000 000, pero sin espacios.";
ifstream in_stream;
ofstream out_stream;
// cout << "\nNombre del archivo: ";
// cin >> file_name;
//out_stream.open(file_name); // creo y abro el archivo...
//
out_stream.open("CR.txt"); // creo y abro el archivo...

en C++
2.6 Proyectos 93

}
for (i = 1 ; ; i++){
cout << "\nCoordenada en x del punto " <> xi;
if (xi == 1000000){
en los datos...";
n = i - 1; // Número total de datos...
break;
}
cout << "\nCoordenada en y del punto " <> yi;
if (yi == 1000000){
en los datos...";
n = i - 1; // número total de datos...
break;
}
cout << "Dato " << i << " grabado correctamente";
cout << "\n";
} // Termino de grabar la información...
// Abrimos el archivo para leer...
in_stream.open("CR.txt");
if (in_stream.fail()){ // si no abrir el archivo...
}
for (j = 1; j <= n ; j++){ // realizo cálculos...
in_stream >> letra;
//
Sx += xi; // Suma de x
Sy += yi; // Suma de y
Sxy += xi * yi; // Suma de xy
Sx2 += xi * xi; // Suma de x cuadrada
Sx3 += xi * xi * xi; // Suma de x cúbica

en C++
94 Códigos
Sx4 += xi * xi * xi * xi; // Suma x cuarta

Sx2y += xi * xi * yi;
}
in_stream.close();
// Calculo parámetros de recta...
m = (n * Sxy - Sx * Sy) / (n * Sx2 - Sx * Sx);
beta = (Sy - m * Sx) / n;
// Calculo los parámetros de parábola...

Da = Sy * Sx2 * Sx2 + n * Sxy * Sx3 + Sx * Sx * Sx2y;
Da = Da - n * Sx2 * Sx2y - Sx * Sx3 * Sy - Sx * Sxy * Sx2;
Dp = Sx2 * Sx2 * Sx2 + n * Sx3 * Sx3 + Sx4 * Sx * Sx;
Dp = Dp - n * Sx2 * Sx4 - 2 * Sx * Sx2 * Sx3;
a = Da / Dp;
b = (Sx * (Sy - a * Sx2) - n * (Sxy - a * Sx3))
/ (Sx * Sx - n * Sx2);
c = (Sy - a * Sx2 - b * Sx) / n;
cout << "La recta de mejor ajuste es: \n";
cout << "\n y = " << beta << " + " << m << " x ";
cout << "La parábola de mejor ajuste es: \n";
cout << "\n y = " << a << " xˆ2 + " << b << " x + " << c;
cout << "\n\n\n";
//
//
// Vuelvo a abrir el archivo...
in_stream.open("CR.txt");
if (in_stream.fail()){ // si no puede abrir el archivo...
}
for (j = 1; j <= n ; j++){ // realizo cálculos...
in_stream >> letra;
//
// calculo el pronóstico con parábola de regresión...
y_approxp = a * xi * xi + b * xi + c;
y_approxr = beta + m * xi;
// discrepancia...
dip = (yi - y_approxp) * (yi - y_approxp);
dir = (yi - y_approxr) * (yi - y_approxr);
Error_p += dip; // Error total
Error_r += dir;
}

en C++
2.6 Proyectos 95

in_stream.close();
cout << "\nError total para la recta: " << Error_r;
cout << "\nError total para la parábola: " << Error_p;
//
//
//
cout << "Generando datos de la parábola de mejor ajuste...";
// creo y abro el archivo...
// pma = parábola de mejor ajuste.
out_stream.open("pma.txt");
}
// Reinicio las coordenadas...
xi = 0;
yi = 0;
for (i = 0 ; i <= 100 ; i++){
yi = a * xi * xi + b * xi + c;
// grabamos los datos en el archivo...
xi = xi + 0.07;
}
cout << "\n\n\nSe han grabado 100 datos
en el intervalo";
cout << "\n(0,7) en el archivo <<pma.txt>>";
}
cout << "\n\n\n";
return 0;
}

en C++
96 Códigos
2.7 Librerı́a Estadı́stica

Crear una librerı́a con funciones estadı́sticas básicas para utilizar durante los
siguientes semestres de la maestrı́a.
• Media / Desviación estándar / Varianza

• Moda (intervalo de mayor frecuencia)
• Graficar el histograma de frecuencias
• Generadores de números pseudoalestorios con las siguientes distribuciones:
3 Uniforme en el intervalo (0,1),
3 Uniforme en el intervalo (a, b), definido por el usuario,
3 Normal con media 0.0 y desviación estándar 1.0,
3 Normal con media µ y desviación estándar σ, definidas por el usuario,
3 Exponencial con parámetro λ, definido por el usuario,
3 Weibull con parámetros de forma c y de escala k, definidos por el
usuario,
3 Rayleigh con media µ, definida por el usuario.
La librerı́a se codificará de manera que se pueda utilizar en el lenguaje C++ ,

con posibilidad de adaptarla al lenguaje ANSI-C.
2.8 Implementación
Puede accesar al archivo estadistica.h con un clı́c derecho y elija Open File
en el siguiente ı́cono : . O bien, con doble clı́c sobre el mismo.
A continuación está el código del mismo archivo.
1 /*
2 Nombre del archivo: "estadistica.h"
3 Descripción:
4 Este archivo contiene funciones y clases
5 para trabajar con cuestiones de probabilidad.
6
7 Las funciones se detallan con comentarios

8 en el código.

en C++
2.8 Implementación 97
10
11 Fecha de última Modificación: 02 de junio de 2008.

12
13 BIBLIOGRAFÍA CONSULTADA:
14 -----------------------------------------
15 CUESTIONES DE ESTADÍSTICA...
16 -----------------------------------------
17 [1] Jerry Banks, John S. Carson II, Barry L. Nelson.
18 Discrete-Event System Simulation.
19 Ed. Prentice Hall.
20 2nd Edition.
21 1996. U.S.A.
22
23 [2] John E. Freund

24 Mathematical Statistics
25 Ed. Prentice Hall
26 5th Edition.
27 1992. U.S.A.
28
29 -----------------------------------------
30 CUESTIONES DE PROGRAMACIÓN...
31 -----------------------------------------
32 [1] Walter Savitch
33 Problem Solving with C++: The Object of Programming
34 Ed. Addison Wesley Longmann Inc.
35 U.S.A. 1999.
36
37 [2] Edward Scheinerman

38 C++ for Mathematicians
39 An Introduction for Students and Professionals
40 Ed. Chapman & Hall/CRC
41 2006. U.S.A.
42
43 [3] Herbert Schildt

44 C++: The Complete Reference
45 Third Edition
46 Ed. McGraw-Hill
47 1998. U.S.A.
48
49 -----------------------------------------
50 Sitios de Internet Consultados...
51 -----------------------------------------
52 - Algoritmo para generar números
53 pseudoaleatorios con distribución Rayleigh:
54 http://www.brighton-webs.co.uk/distributions/rayleigh.asp
55
56 */
57
58 #ifndef PROBABILITY_H

en C++
98 Códigos
59 #define PROBABILITY_H
60
62 #include <time.h>
65 #include <wchar.h>
66 #include <ctype.h>
67 #include <assert.h>
68
69
70 const double PI = 3.141592654;

71 const long PROBABILITY_RAND_MAX = 2147483647;// = 2ˆ31 - 1;
72
73 // Declaro las funciones...

74 void suniforme(unsigned seed);
75 double uniforme(void);
76 double uniforme(float a, float b);
77 void funiforme(int N, char filename[]);
78 void funiforme(int N, float a, float b, char filename[]);
79 double lpuniforme(void);
80
81 //double triangular(double media);

82 double normal(void);
83 double normal(double media, double desviacionStd);
84 void fnormal(int N, char filename[]);
85 void fnormal(int N, char filename[], double media,
86 double desvStd);
87 void errorDNormal(void);
88
89 double weibull(double c, double k);

90 void fweibull(int N, double C, double K, char filename[]);
91
92 float exponencial(float lambda);

93 void fexponencial(int N, float Lambda, char filename[]);
94
95 int geometrica(float p);

96 void fgeometrica(int N, float p, char filename[]);
97 int poisson(float alpha);
98 void fpoisson(int N, float a, char filename[]);
99
100 double rayleigh(float media);

101 void frayleigh(int N, char filename[], float M);
102 void ftriangular(int N, char filename[], float media);
103
104 double media(char filename[]);

105 double desviacionStd(char filename[]);
106
107 double media(char filename[]);

108 double desviacionStd(char filename[]);

en C++
109
110 void histograma(char filename[]);

111 void histograma(char filename[], int No_Int);
112 //hist Phistograma(char filename[], int No_Int);
113
114 void PchiUniforme(char filename[], int Num_Int, float alpha);

115
116 /***************************************************
117 double uniforme(void)
118 Descripción:
119 Esta función genera un número pseudo-aleatorio
120 con distribución uniforme en el intervalo (0,1).
121 BUGS:
122 Ninguno conocido...
123 ****************************************************/
124 double uniforme(void){/*** [tested] ***/
125 double u;
126 u = (double)(rand()) / (double)(RAND_MAX);
127 return u;
128 }
129
130
131
132 /***************************************************
133 double uniforme(float a, float b)
134 Descripción:
135 Esta función genera un número pseudo-aleatorio
136 con distribución uniforme en el intervalo (a,b).
137 /////////////////////////////////////////////////////
138 BUGS:
140 ****************************************************/
141 double uniforme(float a, float b){/*** [tested] ***/
142 double x;
143 x = (double)(a) + uniforme() * (double)(b - a);
144 return x;
145 }
146
147 /***************************************************
148 void funiforme(int N, char filename[15])
149 Descripción:
150 Esta función guarda N números pseudoaleatorios
151 con distribución uniforme en el intervalo (0,1)
152 en el archivo con nombre <<filename>>.
153 /////////////////////////////////////////////////////
154 BUGS:
155 Ninguno conocido.
156 ****************************************************/
157 void funiforme(int N, char filename[15]){/*** [tested] ***/
158 float x;

en C++
100 Códigos
159 FILE *stream_unif; //

160 stream_unif = fopen(filename, "w"); // abrir archivo
161 if (stream_unif == NULL){
162 printf ("\nNo se puede abrir el archivo %s\n",
163 filename);
165 return;
166 }
167 fprintf(stream_unif, "# Este archivo contiene %i
168 números\n", N);
169 fprintf(stream_unif, "# pseudoaletorios con distribucion
170 uniforme\n");
171 fprintf(stream_unif, "# en el intervalo [0.0, 1.0]\n");
172 // Aquı́ va el código para grabar...
173 for(int i = 1 ; i <= N ; i++){
174 x = uniforme(); // generamos un número
175 fprintf(stream_unif, "%f\n", x); // grabamos...
176 }
177 fclose(stream_unif); // cerrar archivo...
178 }
179
180 /***************************************************
181 void funiforme(int N, char filename[], float a, float b)
182 Descripción:
184 con distribución uniforme en el intervalo (a,b)
185 en el archivo con nombre <<filename>>.
186 /////////////////////////////////////////////////////
187 BUGS:
188 Ninguno conocido.
189 ****************************************************/
190 void funiforme(int N, char filename[], float a, float b){
191 /*** [tested] ***/
192 float x;
193 FILE *stream_unif; //
194 stream_unif = fopen(filename, "w"); // abrir archivo
195 if (stream_unif == NULL){
197 filename);
199 return;
200 }
201 fprintf(stream_unif, "# Este archivo contiene %i
203 fprintf(stream_unif, "# pseudoaletorios con distribucion
204 uniforme\n");
205 fprintf(stream_unif, "# en el intervalo [%.3f,%.3f]\n",
206 a, b);
208 for(int i = 1 ; i <= N ; i++){

en C++
209 x = uniforme(a, b); // generamos un número

210 fprintf(stream_unif, "%f\n", x); // grabamos...
211 }
212 fclose(stream_unif); // cerrar archivo...
213 }
214
215
216 /***************************************************
217 double lpuniforme(void)
218 Descripción:
219 Esta función genera números pseudoaleatorios
220 con distribución normal con media 0.0
221 y desviación estándar 1.0.
222 /////////////////////////////////////////////////////
223 BUGS:
224 * Este generador de números seudoaleatorios
225 solamente ha sido probado dibujando histogramas
226 y parece presentar distribución uniforme.
227 NO se ha sometido a ninguna prueba estadı́stica
228 formal.
229 * Se sugiere utilizar para requerimientos de
230 grandes cantidades de números pseudoaleatorios.
231 * Cuando se utiliza para generar números
232 pseudoaleatorios con distribución normal
233 el histograma aparece con sesgo negativo
234 (corrido hacia la derecha). [Instancia de
235 10,000 números generados]
236 ****************************************************/
237 double lpuniforme(void){
238 double u;
239 int primo1 = 8191; // = 2ˆ13 - 1; Número primo
240 int primo2 = 524287; // = 2ˆ19 - 1; Otro número primo
241 static int semilla = 1001; // es primo...
242 static bool first = true;
243 if (first){
244 first = false;
245 return ((double)(semilla)/((double)
246 (PROBABILITY_RAND_MAX)));
247 }
248 unsigned modular = semilla;
249 //
250 modular = (primo1 * modular + primo2) %
251 PROBABILITY_RAND_MAX;
252 semilla = modular; // cambio el valor de la semilla...
253 // calculo el valor que me va a devolver...
254 u = (double)(modular) / ((double)
255 (PROBABILITY_RAND_MAX));
256 return (u);
257 }
258

en C++
102 Códigos
259 /***************************************************
260 double normal(void)
261 Descripción:
265 /////////////////////////////////////////////////////
266 BUGS:
268 ****************************************************/
269 double normal(void){/*** [tested] ***/
270 double media = 0.0, desviacionStd = 1.0;
271 double u, x, v, z;
272 u = uniforme();
273 v = uniforme();
274 x = sqrt(-2 * log(u)) * cos(2 * PI * v);
275 if (u >= 0.5){
276 z = media + desviacionStd * x;
277 }
278 else{
279 z = media - desviacionStd * x;
280 }
281 return z;
282 }
283
284 /***************************************************
285 double normal(double media, double desviacionStd)
286 Descripción:
288 con distribución normal con media << media >>
289 y desviación estándar << desviacionStd >>
290 /////////////////////////////////////////////////////
291 BUGS:
293 ****************************************************/
294 double normal(double media, double desviacionStd){
295 /*** [tested] ***/
296 if (desviacionStd <= 0){
297 errorDNormal();
298 return 0.0;
299 }
301 u = uniforme();
302 v = uniforme();
304 if (u >= 0.5){
306 }
307 else{

en C++
309 }
310 return z;
311 }
312
313 /***************************************************
314 void fnormal(int N, char filename[15])
315 Descripción:
317 con distribución normal con media 0.0 y
318 desviacion estándar 1.0 en el archivo con
319 nombre <<filename>>.
320 /////////////////////////////////////////////////////
321 BUGS:
323 ****************************************************/
324 void fnormal(int N, char filename[]){/*** [tested] ***/
325 double x;
326 FILE *stream_normal; //
327 stream_normal = fopen(filename, "w"); // abrir archivo
328 if (stream_normal == NULL){
330 filename);
332 return;
333 }
334 fprintf(stream_normal, "# Este archivo contiene %i
336 fprintf(stream_normal, "# pseudoaletorios con distribucion
337 normal\n");
338 fprintf(stream_normal, "# con media = 0.0 y desviacion
339 estandar = 1.0\n");
341 for(int i = 1 ; i <= N ; i++){
342 x = normal(); // generamos un número
343 fprintf(stream_normal, "%f\n", x); // grabamos...
344 }
345 fprintf(stream_normal, "\n# Fin del archivo...\n");
346 fclose(stream_normal); // cerrar archivo...
347 }
348 /**********************************************
349 void fnormal(int N, char filename[], float med, float desvStd)
350 Descripción:
352 con distribución normal con media << med >> y
353 desviacion estándar << desvStd >> en el archivo
354 de nombre <<filename>>.
355 /////////////////////////////////////////////////////
356 BUGS:
358 **********************************************/

en C++
104 Códigos
359 void fnormal(int N, char filename[], float med, float desvStd){

360 /*** [tested] ***/
361 if (desviacionStd <= 0){
362 errorDNormal();
363 return;
364 }
365 double x;
366 FILE *stream_normal; //
367 stream_normal = fopen(filename, "w"); // abrir archivo
368 if (stream_normal == NULL){
370 filename);
372 return;
373 }
374 fprintf(stream_normal, "# Este archivo contiene %i
376 fprintf(stream_normal, "# pseudoaletorios con
377 distribucion normal\n");
378 fprintf(stream_normal, "# con media = %.3f y desviacion
379 estándar = %.3f.\n", med, desvStd);
381 for(int i = 1 ; i <= N ; i++){
382 x = normal(med, desvStd); // generamos un número
383 fprintf(stream_normal, "%f\n", x); // grabamos...
384 }
385 fprintf(stream_normal, "\n# Fin del archivo...\n");
386 fclose(stream_normal); // cerrar archivo...
387 return;
388 }
389
390 /***************************************************
391 double lnormal(void)
392 Descripción:
396 /////////////////////////////////////////////////////
397 BUGS:
398 Esta función genera números que presentan un sesgo
399 hacia la derecha cuando se grafican su histograma
400 de frecuencias. Sin embargo, los calculos de media
401 y desciación estándar están cercanos a 0.0 y 1.0,
402 respectivamente.
403 ****************************************************/
404 double lnormal(void){/*** [tested] ***/
405 double media = 0.0, desviacionStd = 1.0;
407 u = lpuniforme();
408 v = lpuniforme();

en C++

410 if (u >= 0.5){
412 }
413 else{
415 }
416 return z;
417 }
418
419
420 void errorDNormal(void){

421 // Imposible generar número
422 // con distribución normal ası́...
423 printf("\n\nError en el segundo argumento de función:");
424 printf("\ndouble normal(double media, double
425 desviacionStd)");
426 printf("\ndesviacionStd debe ser un número
427 positivo...");
428 printf("\nPor favor corrija el valor...");
429 return;
430 }
431
432 /**************************************
433 float exponencial(float lambda)
434 Descripción:
436 con distribución exponencial de parámetro
437 lambda.
438 /////////////////////////////////////////////////////
439 BUGS:
441 ***************************************/
442 float exponencial(float lambda){/*** [tested] ***/
443 double x;
444 x = -log(1 - uniforme()) / lambda;
445 return x;
446 }
447
448 /**************************************
449 void fexponencial(int N, float Lambda, char filename[15])
450 Descripción:
451 Esta función genera N números pseudoaleatorios
452 con distribución exponencial, con parámetro
453 << Lambda >>, y los graba en el archivo de nombre
454 << filename >>
455 /////////////////////////////////////////////////////
456 BUGS:
458 ***************************************/

en C++
106 Códigos
459 void fexponencial(int N, float Lambda, char filename[]){

460 /*** [tested] ***/
461 float x;
462 FILE *stream_exponencial; //
463 stream_exponencial = fopen(filename, "w");//abrir archivo
464 if (stream_exponencial == NULL){
466 filename);
468 return;
469 }
470 fprintf(stream_exponencial, "# Este archivo contiene %i
472 fprintf(stream_exponencial, "# pseudoaletorios con
473 distribucion exponencial\n");
474 fprintf(stream_exponencial, "# con parámetro lambda =
475 %.3f\n", Lambda);
477 for(int i = 1 ; i <= N ; i++){
478 x = exponencial(Lambda); // generamos un número
479 fprintf(stream_exponencial, "%f\n", x);
480 }
481 fprintf(stream_exponencial, "\n# Fin del archivo...\n");
482 fclose(stream_exponencial); // cerrar archivo...
483 }
484
485
486 /**************************************
487 float geometrica(float p)
488 Descripción:
490 con distribución geometrica de parámetro p.
491 /////////////////////////////////////////////////////
492 BUGS:
494 ***************************************/
495 int geometrica(float p){
496 double x;
497 int y;
498 x = (log(1 - uniforme()) / log(1 - p)) - 1;
499 y = (int)(x + 0.5); // redondeo... [round Up]
500 return y;
501 }
502
503
504 /**************************************
505 void fgeometrica(int N, float p, char filename[15])
506 Descripción:
508 con distribución geometrica, con parámetro

en C++
509 <>, y los graba en el archivo de nombre

510 << filename >>.
511 /////////////////////////////////////////////////////
512 BUGS:
514 ***************************************/
515 void fgeometrica(int N, float p, char filename[]){
516 /*** [tested] ***/
517 int x;
518 FILE *stream_geometrica; //
519 stream_geometrica = fopen(filename, "w");// abrir archivo
520 if (stream_geometrica == NULL){
522 filename);
524 return;
525 }
526 fprintf(stream_geometrica, "# Este archivo contiene %i
528 fprintf(stream_geometrica, "# pseudoaletorios con
529 distribucion geométrica\n");
530 fprintf(stream_geometrica, "# con parámetro p =
531 %.3f\n", p);
533 for(int i = 1 ; i <= N ; i++){
534 x = geometrica(p); // generamos un número
535 fprintf(stream_geometrica, "%i\n", x);
536 }
537 fprintf(stream_geometrica, "\n# Fin del archivo...\n");
538 fclose(stream_geometrica); // cerrar archivo...
539 }
540
541
542 /**************************************
543 int poisson(float alpha)
544 Descripción:
546 con distribución Poisson de parámetro alpha.
547 /////////////////////////////////////////////////////
548 BUGS:
550 ***************************************/
551 int poisson(float alpha){
552 int n = 0;
553 static int p = 1;
554 double comparador;
555 double u;
556 do{
557 u = (double)(rand()) / (double)(RAND_MAX);
558 comparador *= p * u;

en C++
108 Códigos
559 n++;
560 } while (comparador > exp(-alpha));
561 return n;
562 }
563
564
565 /**************************************
566 void fpoisson(int N, float a, char filename[15])
567 Descripción:
569 con distribución poisson, con parámetro
570 << a >>, y los graba en el archivo de nombre
571 << filename >>.
572 /////////////////////////////////////////////////////
573 BUGS:
575 ***************************************/
576 void fpoisson(int N, float a, char filename[]){
577 /*** [tested] ***/
578 int x;
579 FILE *stream_poisson; //
580 stream_poisson = fopen(filename, "w");// abrir archivo
581 if (stream_poisson == NULL){
583 filename);
585 return;
586 }
587 fprintf(stream_poisson, "# Este archivo contiene %i
589 fprintf(stream_poisson, "# pseudoaletorios con
590 distribucion geométrica\n");
591 fprintf(stream_poisson, "# con parámetro p = %.3f\n",
592 a);
594 for(int i = 1 ; i <= N ; i++){
595 x = poisson(a); // generamos un número
596 fprintf(stream_poisson, "%i\n", x);
597 }
598 fprintf(stream_poisson, "\n# Fin del archivo...\n");
599 fclose(stream_poisson); // cerrar archivo...
600 }
601
602
603
604 /***************************************************
605 double weibull(double c, double k)
607 con distribución Weibull.
608 Los parámetros c y k corresponden a la forma

en C++
609 y escala de la distribución, respectivamente.

610 /////////////////////////////////////////////////////
611 BUGS:
613 ****************************************************/
614 double weibull(double c, double k){/*** [tested] ***/
615 double x;
616 x = c * pow(-log(1 - uniforme()), 1/k);
617 return x;
618 }
619
620 /***************************************************
621 void fweibull(int N, char filename[15], float C, float K)
622 Descripción:
624 con distribución weibull, con parámetros
625 << C >> y << K >>, y los graba en el archivo de
626 nombre << filename >>.
627 /////////////////////////////////////////////////////
628 BUGS:
630 ****************************************************/
631 void fweibull(int N, char filename[], float C, float K){
632 /*** [tested] ***/
633 float x;
634 FILE *stream_weib; //
635 stream_weib = fopen(filename, "w"); // abrir archivo
636 if (stream_weib == NULL){
638 filename);
640 return;
641 }
642 fprintf(stream_weib, "# Este archivo contiene %i
644 fprintf(stream_weib, "# pseudoaletorios con distribucion
645 Weibull\n");
646 fprintf(stream_weib, "# con parámetros C = %.3f y K =
647 %.3f\n", C, K);
649 for(int i = 1 ; i <= N ; i++){
650 x = weibull(C, K); // generamos un número
651 fprintf(stream_weib, "%f\n", x); // grabamos...
652 }
653 fclose(stream_weib); // cerrar archivo...
654 }
655
656 /**************************************
657 double rayleigh(float media)
658 Descripción:

en C++
110 Códigos

660 con distribución rayleigh con media << media >>
661 Fuente:
662 http://www.brighton-webs.co.uk/distributions/rayleigh.asp
663 /////////////////////////////////////////////////////
664 BUGS:
666 ***************************************/
667 double rayleigh(float media){/*** [tested] ***/
668 double factor, r;
669 factor = media / 1.253314;
670 r = sqrt(-2 * factor * factor * log(uniforme()));
671 return r;
672 }
673
674 /***************************************************
675 void frayleigh(int N, char filename[15], float M)
676 Descripción:
678 con distribución rayleigh, con media
679 << M >> y los graba en el archivo de
681 /////////////////////////////////////////////////////
682 BUGS:
684 ****************************************************/
685 void frayleigh(int N, char filename[], float M){
686 /*** [tested] ***/
687 float x;
688 FILE *stream_rayl; //
689 stream_rayl = fopen(filename, "w"); // abrir archivo
690 if (stream_rayl == NULL){
692 filename);
694 return;
695 }
696 fprintf(stream_rayl, "# Este archivo contiene %i
698 fprintf(stream_rayl, "# pseudoaletorios con distribución
699 Rayleigh\n");
700 fprintf(stream_rayl, "# con media = %.3f\n", M);
702 for(int i = 1 ; i <= N ; i++){
703 x = rayleigh(M); // generamos un número
704 fprintf(stream_rayl, "%f\n", x); // grabamos...
705 }
706 fclose(stream_rayl); // cerrar archivo...
707 }
708

en C++
709
710 /***************************************************
711 double triangular(double media)
713 con distribución triangular con parámetro << media >>
714 /////////////////////////////////////////////////////
715 BUGS:
716 Al dibujar el histograma la distribución en realidad
717 no parece triangular...
718 NO USAR...
719 BUSCAR EN INTERNET CÓMO SIMULARLA...
720 ****************************************************/
721 double triangular(double media){
722 double R, x;
723 R = uniforme();
724 if (R <= 0.5){
725 x = sqrt(2 * media * R); // Ok...
726 }
727 else{
728 x = media * (2 - sqrt(2 * (R)));
729 }
730 return x;
731 }
732
733 /***************************************************
734 void ftriangular(int N, char filename[], float media)
735 Descripción:
737 con distribución rayleigh, con media
738 << M >> y los graba en el archivo de
740 /////////////////////////////////////////////////////
741 BUGS:
743 ****************************************************/
744 void ftriangular(int N, char filename[], float media){
745 /*** [tested] ***/
746 float x;
747 FILE *stream_tria; //
748 stream_tria = fopen(filename, "w"); // abrir archivo
749 if (stream_tria == NULL){
751 filename);
753 return;
754 }
755 fprintf(stream_tria, "# Este archivo contiene %i
757 fprintf(stream_tria, "# pseudoaletorios con distribución
758 Rayleigh\n");

en C++
112 Códigos
759 fprintf(stream_tria, "# con media = %.3f\n", media);

761 for(int i = 1 ; i <= N ; i++){
762 x = triangular(media); // generamos un número
763 fprintf(stream_tria, "%f\n", x); // grabamos...
764 }
765 fclose(stream_tria); // cerrar archivo...
766 }
767
768
769
770
771
772
773 /**************************************
774 double media(char filename[])
775 Descripción:
776 Esta función calcula la media aritmética de
777 los datos contenidos en el archivo de nombre
778 << filename >>.
779 /////////////////////////////////////////////////////
780 BUGS:
782 ***************************************/
783 double media(char filename[]){/*** [tested] ***/
784 char respuesta, letra = ’ ’;
785 double datum;
786 double x, Sx;
787 double media; // lo que va a regresar
788 int n = 0, j = 1, i = 0; // contadores...
789 char dato[15];
790 char B4; // letra leida antes...
791 FILE *stream_media; // stream_uniforme
792 stream_media = fopen(filename, "r+"); // abrir archivo
793 if (stream_media == NULL){
795 filename);
797 system("PAUSE");
798 return 0;
799 }
800 Sx = 0; // reinicio la suma de datos
801 // Ahora leemos los datos...
802 do{
803 letra = fgetc(stream_media); // leer un char
804 if (letra == feof(stream_media)){
806 }
807 switch(letra){
808 case ’\n’: // llegó a un nuevo renglón

en C++
809 if (i > 1){

810 dato[i] = ’\0’; // fin del arreglo
811 x = atof(dato); // convierto a float
812 Sx += x; // Suma de x
813 i = 0;
814 n++;
815 }
816 break;
817 case ’\t’: // para el caso de varias columnas...
818 //if (i > 0){
822 i = 0;
823 n++;
824 //}
825 break;
826 case ’ ’: // espacio en blanco...
827 if (i > 1){
831 i = 0;
832 n++;
833 break;
834 }
835 case ’#’: // comentario...
836 do{ // leer todos los alfanuméricos
837 letra = fgetc(stream_media);
838 if (letra == feof(stream_media)){
839 break;
840 }
841 } while (letra!=’\n’);
842 i = 1;
843 dato[0] = letra;
844 break;
845 default:
846 dato[i] = letra;
847 i++;
848 }
849 } while(!feof(stream_media));
850 fclose(stream_media); // cerrar archivo...
851
852 media = Sx / (1.0 * n);

853 return(media);
854 }
855
856 /**************************************
857 double desviacionStd(char filename[15])
858 Descripción:

en C++
114 Códigos
859 Esta función calcula la desviación estándar de

860 los datos contenidos en el archivo de nombre
861 << filename >>.
862 /////////////////////////////////////////////////////
863 BUGS:
865 ***************************************/
866 double desviacionStd(char filename[]){/*** [tested] ***/
867 char respuesta, letra = ’ ’;
868 double datum;
869 double x, Sx, Sx2;
870 double varianza, sd;
871 int n = 0, j = 1, i = 0; // contadores...
872 char dato[15];
873 char B4; // letra leida antes...
874 FILE *stream_sd; // stream_uniforme
875 stream_sd = fopen(filename, "r+"); // abrir archivo
876 if (stream_sd == NULL){
878 filename);
880 return 0.0;
881 }
882 Sx = 0, Sx2 = 0; // reinicio los contadores
884 do{
885 letra = fgetc(stream_sd); // leer un char
886 if (letra == feof(stream_sd)){
888 }
889 switch(letra){
891 if (i > 1){
895 Sx2 += x * x; // Suma de xˆ2
896 i = 0;
897 n++;
898 }
899 break;
901 //if (i > 0){
905 Sx2 += x * x; // Suma de xˆ2
906 i = 0;
907 n++;
908 //}

en C++
909 break;
911 if (i > 1){
915 Sx2 += x * x; // Suma de xˆ2
916 i = 0;
917 n++;
918 break;
919 }
922 letra = fgetc(stream_sd);
923 if (letra == feof(stream_sd)){
924 break;
925 }
927 i = 1;
929 break;
930 default:
932 i++;
933 }
934 } while(!feof(stream_sd));
935 fclose(stream_sd); // cerrar archivo...
936 varianza = (Sx2 - Sx * Sx / (1.0 * n)) / (n - 1.0);
937 sd = sqrt(varianza);
938 return(sd);
939 printf("\n\n\n");
940 }
941
942
943
944
945 /**************************************
946 void histograma(char filename[15])
947 Descripción:
948 Esta función genera un histograma en la pantalla
949 a partir de los datos leı́dos en el archivo de
950 nombre filename.
951 /////////////////////////////////////////////////////
952 BUGS:
954 ***************************************/
955 void histograma(char filename[]){/*** [tested] ***/
956 int I[10]; // los intervalos...
957 int errores = 0, max =0, min = 1000000;
958 int n = 0, j = 1, i = 0; // contadores

en C++
116 Códigos
959 int imax, imin;//

960 double vmax = -2147483647, vmin = 2147483647;
961 double anchoIntervalo; // = vmax - vmin
962 char dato[15]; // cada dato en forma de string
963 float x; // el número generado...
964 double escala; // para hacer la gráfica...
965 int factor; // para hacer la gráfica...
966 char letra = ’ ’;
967 //
968 // limpio la memoria del array para el histograma...
969 for (i = 0 ; i <= 9 ; i++){
970 I[i] = 0;
971 }
972 // Histograma
973 FILE *stream_histo; //
974 stream_histo = fopen(filename, "r+"); // abrir archivo
975 if (stream_histo == NULL){
977 filename);
979 return;
980 }
982 do{
983 letra = fgetc(stream_histo); // leer un char
984 if (letra == feof(stream_histo)){
986 }
987 switch(letra){
989 if (i > 1){
992 // encuentro el mı́nimo y el máximo...
993 if (x > vmax){
994 vmax = x;
995 }
996 if (x < vmin){
997 vmin = x;
998 }
999 i = 0;
1000 n++;
1001 }
1002 break;
1007 if (x > vmax){
1008 vmax = x;

en C++
1009 }
1010 if (x < vmin){
1011 vmin = x;
1012 }
1013 i = 0;
1014 n++;
1015 break;
1017 if (i > 1){
1020 i = 0;
1021 n++;
1023 if (x > vmax){
1024 vmax = x;
1025 }
1026 if (x < vmin){
1027 vmin = x;
1028 }
1029
1030
1031 break;
1032 }
1035 letra = fgetc(stream_histo);
1037 break;
1038 }
1040 i = 1;
1042 break;
1043 default:
1045 i++;
1046 }
1047 } while(!feof(stream_histo));
1048 anchoIntervalo = vmax - vmin;
1049 // regreso al inicio del archivo
1050 fseek(stream_histo, 0, SEEK_SET);
1051 // Volvemos a leer los datos...
1052 // Ahora para generar el histograma
1053 do{
1057 }
1058 switch(letra){

en C++
118 Códigos

1060 if (i > 1){
1063 i = 0;
1064 n++;
1065 // Asigno al arreglo para el histograma
1066 for(j = 0 ; j <= 9 ; j++){
1067 if ((x > (0.1 * j * anchoIntervalo
1068 + vmin)) && (x <= (0.1 * (j+1) *
1069 anchoIntervalo + vmin))){
1070 I[j]++;
1071 break;
1072 }
1073 }
1074 }
1075 break;
1079 i = 0;
1080 n++;
1082 for(j = 0 ; j <= 9 ; j++){
1083 if ((x > (0.1 * (j) * anchoIntervalo
1084 + vmin)) && (x <= (0.1 * (j+1) *
1086 I[j]++;
1087 break;
1088 }
1089 }
1090 break;
1092 if (i > 1){
1095 i = 0;
1096 n++;
1098 for(j = 0 ; j <= 9 ; j++){
1099 if ((x > (0.1 * (j) * anchoIntervalo
1100 + vmin)) && (x <= (0.1 * (j+1) *
1102 I[j]++;
1103 break;
1104 }
1105 }
1106 break;
1107 }

en C++

1112 break;
1113 }
1115 i = 1;
1117 break;
1118 default:
1120 i++;
1121 }
1123 fclose(stream_histo); // cerrar archivo...
1124 // Encuentro el intervalo con mayor número de ocurrencias
1125 for (i = 0; i <= 9 ; i++){
1126 if (I[i] > max){
1127 max = I[i];
1128 imax = i;
1129 }
1130 if (I[i] < min){
1131 min = I[i];
1132 imin = i;
1133 }
1134 }
1135 // Ahora imprimo los resultados...
1136 printf("\n\n"); // un poco de espacio...
1137 for (i = 0 ; i <= 9 ; i++){
1138 printf("\n Intervalo %.1f -- %.1f ", (anchoIntervalo * i
1139 / 10 + vmin),(anchoIntervalo * (i+1) / 10) + vmin);
1140 escala = 35.0 * I[i] / max;
1141 factor = int(escala + 0.5); // redondeo
1142 // Imprime la barra del intervalo (i-1)
1143 for (j = 0 ; j <= factor ; j++){
1144 printf("|");
1145 } // termina de imprimir la barra...
1146 if (I[i] == max){
1147 printf(" (%i) [Max]\n", I[i]);
1148 continue;
1149 }
1150 if (I[i] == min){
1151 printf(" (%i) [Min]\n", I[i]);
1152 continue;
1153 }
1154 printf(" (%i)\n", I[i]);
1155 }
1156 return;
1157 } // Fin de la función HISTOGRAMA
1158

en C++
120 Códigos
1159
1160 /**************************************
1161 void histograma(char filename[], int No_Int)
1162 Descripción:
1163 Esta función genera un histograma de << No_Int >>
1164 intervalos en la pantalla a partir de los datos
1165 leı́dos en el archivo de nombre << filename >>.
1166 /////////////////////////////////////////////////////
1167 BUGS:
1169 ***************************************/
1170 void histograma(char filename[], int No_Int){
1171 /*** [tested] ***/
1172 int I[No_Int - 1]; // los intervalos...
1176 double vmax = -2147483647, vmin = 2147483647;
1177 double anchoIntervalo; // = vmax - vmin
1183 //
1185 for (i = 0 ; i < No_Int ; i++){
1186 I[i] = 0;
1187 }
1188 // Histograma
1192 printf ("\nNo se puede abrir el archivo %s\n", filename);
1194 return;
1195 }
1197 do{
1201 }
1202 switch(letra){
1204 if (i > 1){
1208 if (x > vmax){

en C++
1209 vmax = x;
1210 }
1211 if (x < vmin){
1212 vmin = x;
1213 }
1214 i = 0;
1215 n++;
1216 }
1217 break;
1222 if (x > vmax){
1223 vmax = x;
1224 }
1225 if (x < vmin){
1226 vmin = x;
1227 }
1228 i = 0;
1229 n++;
1230 break;
1232 if (i > 1){
1235 i = 0;
1236 n++;
1238 if (x > vmax){
1239 vmax = x;
1240 }
1241 if (x < vmin){
1242 vmin = x;
1243 }
1244
1245
1246 break;
1247 }
1252 break;
1253 }
1255 i = 1;
1257 break;
1258 default:

en C++
122 Códigos

1260 i++;
1261 }
1263 anchoIntervalo = vmax - vmin;
1268 do{
1272 }
1273 switch(letra){
1275 if (i > 1){
1278 i = 0;
1279 n++;
1281 for(j = 0 ; j < No_Int ; j++){
1282 if ((x > (j * anchoIntervalo / No_Int
1283 + vmin)) && (x <= ((j+1) *
1284 anchoIntervalo / No_Int + vmin))){
1285 I[j]++;
1286 break;
1287 }
1288 }
1289 }
1290 break;
1294 i = 0;
1295 n++;
1297 for(j = 0 ; j < No_Int ; j++){
1299 + vmin)) && (x <= ((j+1) *
1301 I[j]++;
1302 break;
1303 }
1304 }
1305 break;
1307 if (i > 1){

en C++

1310 i = 0;
1311 n++;
1313 for(j = 0 ; j < No_Int ; j++){
1315 + vmin)) && (x <= ((j+1) *
1317 I[j]++;
1318 break;
1319 }
1320 }
1321 break;
1322 }
1327 break;
1328 }
1330 i = 1;
1332 break;
1333 default:
1335 i++;
1336 }
1339 // Encuentro el intervalo con mayor número de ocurrencias
1340 for (i = 0; i < No_Int ; i++){
1341 if (I[i] > max){
1342 max = I[i];
1343 imax = i;
1344 }
1345 if (I[i] < min){
1346 min = I[i];
1347 imin = i;
1348 }
1349 }
1350 // Ahora imprimo los resultados...
1351 printf("\n\n"); // un poco de espacio...
1352 for (i = 0 ; i < No_Int ; i++){
1353 printf("\n Intervalo %.1f -- %.1f ", (anchoIntervalo * i
1354 / No_Int + vmin),(anchoIntervalo * (i+1) / No_Int) + vmin);
1355 escala = 35.0 * I[i] / max;
1356 factor = int(escala + 0.5); // redondeo
1357 // Imprime la barra del intervalo (i-1)
1358 for (j = 0 ; j <= factor ; j++){

en C++
124 Códigos
1359 printf("|");
1360 } // termina de imprimir la barra...
1361 if (I[i] == max){
1362 printf(" (%i) [Max]\n", I[i]);
1363 continue;
1364 }
1365 if (I[i] == min){
1366 printf(" (%i) [Min]\n", I[i]);
1367 continue;
1368 }
1369 printf(" (%i)\n", I[i]);
1370 }
1371 return;
1373
1374
1375
1376 struct hist{

1377 /*
1378 Esta estructura servirá para crear
1379 un histograma y pasarlo como
1380 argumento y regresarlo...
1381 */
1382 //int size;
1383 int I[30];
1384 int imax, imin;
1385 float vmin, vmax;
1386 int total_datos;
1387 };
1388
1389
1390
1391 /**************************************
1392 void histograma(char filename[15])
1393 Descripción:
1394 Esta función genera un histograma de No_Int
1395 intervalos en la pantalla a partir de los
1396 datos leı́dos en el archivo de nombre
1397 << filename >>.
1398 /////////////////////////////////////////////////////
1399 BUGS:
1401 ***************************************/
1402 hist Phistograma(char filename[], int No_Int){
1403 /*** [tested] ***/
1407
1408 double anchoIntervalo; // = vmax - h.vmin

en C++

1414 hist h; // Nuevo histograma
1415 h.imax = -1;
1416 h.imin = -1;
1417 h.vmax = -2147483647; // máximo
1418 h.vmin = 2147483647; // mı́nimo
1419 h.total_datos = 0;
1420 //
1422 for (i = 0 ; i < 30 ; i++){
1423 h.I[i] = 0;
1424 }
1425 // Histograma
1430 filename);
1432 return h;
1433 }
1435 do{
1439 }
1440 switch(letra){
1442 if (i > 1){
1445 h.total_datos++;
1447 if (x > h.vmax){
1448 h.vmax = x;
1449 }
1450 if (x < h.vmin){
1451 h.vmin = x;
1452 }
1453 i = 0;
1454 n++;
1455 }
1456 break;

en C++
126 Códigos

1462 if (x > h.vmax){
1463 h.vmax = x;
1464 }
1465 if (x < h.vmin){
1466 h.vmin = x;
1467 }
1468 i = 0;
1469 n++;
1470 break;
1472 if (i > 1){
1476 i = 0;
1477 n++;
1479 if (x > h.vmax){
1480 h.vmax = x;
1481 }
1482 if (x < h.vmin){
1483 h.vmin = x;
1484 }
1485
1486
1487 break;
1488 }
1493 break;
1494 }
1496 i = 1;
1498 break;
1499 default:
1501 i++;
1502 }
1504 anchoIntervalo = h.vmax - h.vmin;

en C++
1509 do{
1513 }
1514 switch(letra){
1516 if (i > 1){
1519 i = 0;
1520 n++;
1522 for(j = 0 ; j < No_Int ; j++){
1524 + h.vmin)) && (x <= ((j+1) *
1525 anchoIntervalo / No_Int + h.vmin))){
1526 h.I[j]++;
1527 break;
1528 }
1529 }
1530 }
1531 break;
1535 i = 0;
1536 n++;
1538 for(j = 0 ; j < No_Int ; j++){
1540 + h.vmin)) && (x <= ((j+1) *
1542 h.I[j]++;
1543 break;
1544 }
1545 }
1546 break;
1548 if (i > 1){
1551 i = 0;
1552 n++;
1554 for(j = 0 ; j < No_Int ; j++){
1556 + h.vmin)) && (x <= ((j+1) *
1558 h.I[j]++;

en C++
128 Códigos
1559 break;
1560 }
1561 }
1562 break;
1563 }
1568 break;
1569 }
1571 i = 1;
1573 break;
1574 default:
1576 i++;
1577 }
1580 for (i = 0; i < No_Int ; i++){
1581 if (h.I[i] > max){
1582 max = h.I[i];
1583 h.imax = i;
1584 }
1585 if (h.I[i] < min){
1586 min = h.I[i];
1587 h.imin = i;
1588 }
1589 }
1590 return h;
1592
1593
1594
1595
1596 /******************************************************
1597 void PchiUniforme(char filename[], int Num_Int)
1598 Descripción:
1599 Esta función prueba que los datos contenidos en el
1600 archivo de nombre << filename >> presenten una
1601 distribución normal, calculando el valor de Chiˆ2.
1602 /////////////////////////////////////////////////////
1603 BUGS:
1605 ------------------------------------------------------
1606 NOTAS:
1607 A. El algoritmo es el siguiente:
1608 1. Se leen los datos del archivo para contar

en C++
1609 las frecuencias realtivas en cada intervalo

1610 del histograma y el total de datos N
1611 contenidos en el archivo.
1612 2. Se generan N numeros pseudoaleatorios con
1613 distribución uniforme en el intervalo
1614 (0,1)
1615 ********************************************************/
1616 void PchiUniforme(char filename[], int Num_Int){
1617 float discrepancia = 0.0;
1618 hist observado; // datos leidos
1619 hist teorico; // datos generados
1620 float pt, po;
1621 int i;
1622 // Primero generamos el histograma
1623 // a partir de los datos contenidos en el archivo
1624 observado = Phistograma(filename, Num_Int);
1625 // Ahora generamos números en ese mismo intervalo...
1626 funiforme(observado.total_datos, "ChiUnif.txt");
1627 teorico = Phistograma("ChiUnif.txt", Num_Int);
1628 //
1629 pt = 1.0 / (float)(Num_Int);
1630 for(i = 0 ; i < Num_Int ; i++){
1631 po = (float)(observado.I[i]) /
1632 (float)(observado.total_datos);
1633 discrepancia += (po - pt) * (po - pt) / (pt);
1634 }
1635 printf("\nEl archivo %s contiene %i datos.", filename,
1636 observado.total_datos);
1637 printf("\n\nChiˆ2 = %f", discrepancia);
1638 if (discrepancia < 0.15 && teorico.total_datos > 1000){
1639 printf("\nLos datos contenidos en el archivo %s",
1640 filename);
1641 printf("\nparecen presentar distribucion uniforme.");
1642 return;
1643 }
1644 }
1645
1646 /******************************************************
1647 void PchiNormal(char filename[], int Num_Int)
1648 Descripción:
1651 distribución uniforme.
1652 Devuelve el número de datos leidos del archivo,
1653 la media de esos datos y su desviación estándar.
1654 También despliega el valor de Chiˆ2.
1655 /////////////////////////////////////////////////////
1656 BUGS:
1658 ********************************************************/

en C++
130 Códigos
1659 void PchiNormal(char filename[], int Num_Int){

1663 float m, DStd;
1664 float pt, po;
1665 float z; // punto medio del intervalo i
1666 int i;
1667 int NI;
1671 // Calculamos los parámetros de la distribución...
1672 m = media(filename);
1673 DStd = desviacionStd(filename);
1674 // Ahora generamos números con esos parámetros...
1675 fnormal(100000, "ChiNorm.txt", m, DStd);
1676 teorico = Phistograma("ChiNorm.txt", Num_Int);
1677 // Comparamos los dos histogramas...
1678 for(i = 0 ; i < Num_Int ; i++){
1681 pt = (float)(teorico.I[i]) /
1682 (float)(teorico.total_datos);
1684 }
1685 // Resultados...
1688 printf("\nMedia calculada: %f", m);
1689 printf("\nDesviacion Estandar calculada: %f", DStd);
1690 printf("\n\nChiˆ2 = %f\n", discrepancia);
1693 filename);
1694 printf("\nparecen presentar distribucion normal.");
1695 return;
1696 }
1697 }
1698
1699 /******************************************************
1700 void PchiExponencial(char filename[], int Num_Int,
1701 float lambda)
1702 Descripción:
1705 distribución exponencial con parámetro << lambda >>.
1707 la media de esos datos el valor de Chiˆ2.
1708 /////////////////////////////////////////////////////

en C++
1709 BUGS:
1711 ********************************************************/
1712 void PchiExponencial(char filename[], int Num_Int,
1713 float lambda){
1717 float m;
1718 float pt, po;
1719 int i;
1725 // Ahora generamos números pseudoaleatorios...
1726 fexponencial(100000, lambda, "ChiExpo.txt");
1727 teorico = Phistograma("ChiExpo.txt", Num_Int);
1729 for(i = 0 ; i < Num_Int ; i++){
1735 }
1742 filename);
1743 printf("\nparecen presentar distribucion
1744 exponencial.");
1745 return;
1746 }
1747 }
1748
1749 /******************************************************
1750 void PchiWeibull(char filename[], int Num_Int, float c,
1751 float k)
1752 Descripción:
1755 distribución Weibull con parámetro << promedio >>.
1758 /////////////////////////////////////////////////////

en C++
132 Códigos
1759 BUGS:
1761 ********************************************************/
1762 void PchiWeibull(char filename[], int Num_Int, float c,
1763 float k){
1767 float m; // media calculada
1768 float pt, po;
1769 int i;
1776 fweibull(100000, "ChiWeib.txt", c, k);
1777 teorico = Phistograma("ChiWeib.txt", Num_Int);
1779 for(i = 0 ; i < Num_Int ; i++){
1785 }
1792 filename);
1793 printf("\nparecen presentar distribucion Weibull.");
1794 return;
1795 }
1796 }
1797
1798 /******************************************************
1799 void PchiRayleigh(char filename[], int Num_Int, float media)
1800 Descripción:
1803 distribución exponencial con parámetro << lambda >>.
1806 /////////////////////////////////////////////////////
1807 BUGS:

en C++
1809 ********************************************************/
1810 void PchiRayleigh(char filename[], int Num_Int, float Media){
1814 float m;
1815 float pt, po;
1816 int i;
1823 frayleigh(100000, "ChiExpo.txt", Media);
1824 teorico = Phistograma("ChiExpo.txt", Num_Int);
1826 for(i = 0 ; i < Num_Int ; i++){
1832 }
1839 filename);
1840 printf("\nparecen presentar distribucion Rayleigh.");
1841 return;
1842 }
1843 }
1844
1845
1846 /******************************************************
1847 void RL(char filename[])
1848 Descripción:
1849 Esta función calcula la recta de mejor ajuste a los
1850 datos contenidos en el archivo << filename >>.
1851 /////////////////////////////////////////////////////
1852 BUGS:
1854 ********************************************************/
1855 void RL(char filename[]){
1856 char letra;
1858 float x, y; // coordenadas del punto

en C++
134 Códigos
1859 int i, j = 0; // contadores

1860 float m, beta; // parámetros para recta...
1861 float Sx, Sy, Sx2, Sxy; // sumas de datos...
1862 float Error_r = 0;
1863 float dir, y_approxr;
1864 int punto = 0;
1865 Sx = 0; Sy = 0; Sxy = 0;
1866 Sx2 = 0;
1867 FILE *stream_RL; //
1868 stream_RL = fopen(filename, "r+"); // abrir archivo
1869 if (stream_RL == NULL){
1871 filename);
1873 return;
1874 }
1875 do{
1876 letra = fgetc(stream_RL); // leer un char
1877 if (letra == feof(stream_RL)){
1879 }
1880 switch(letra){
1882 if (i > 1){
1884 if (j % 2 == 0){ // dato impar...
1885 x = atof(dato);// convierto a un float
1886 punto = 0;
1887 }
1888 else{
1889 y = atof(dato);
1890 punto = 1;
1891 }
1892 j++;
1893 i = 0;
1894 }
1895 break;
1898 if (j % 2 == 0){
1900 punto = 0;
1901 }
1902 else{
1904 punto = 1;
1905 }
1906 j++;
1907 i = 0;
1908 break;

en C++

1910 if (i > 1){
1912 if (j % 2 == 0){
1914 punto = 0;
1915 }
1916 else{
1918 punto = 1;
1919 }
1920 j++;
1921 i = 0;
1922 break;
1923 }
1926 letra = fgetc(stream_RL);
1927 if (letra == feof(stream_RL)){
1928 break;
1929 }
1931 i = 0;
1933 break;
1934 default:
1936 punto = 0;
1937 i++;
1938 }
1939 if (punto == 1){ // realizar cálculos
1940 // Realizamos los cálculos...
1941 Sx += x; // Suma de x
1942 Sy += y; // Suma de y
1943 Sxy += x * y; // Suma de xy
1944 Sx2 += x * x; // Suma de x cuadrada
1945 punto = 0;
1946 }
1947 } while(!feof(stream_RL));
1948
1949 // Calculo parámetros de recta...

1950 if (j > 4){
1951 m = (j * Sxy - Sx * Sy) / (j * Sx2 - Sx * Sx);
1952 beta = (Sy - m * Sx) / j;
1953 // Muestro los resultados...
1954 printf("\n\nLa recta de mejor ajuste es:");
1955 printf("\n y = %.3f + %.3f x.\n", beta, m);
1956 }
1957 else{
1958 printf("\nNo se pueden realizar los calculos.");

en C++
136 Códigos
1959 printf("\nEl archivo contiene dos datos o menos...");

1960 }
1961 // cierro el archivo...
1962 fclose(stream_RL);
1963 //system("PAUSE");
1964 return;
1965 }
1966
1967 /******************************************************
1968 void RC(char filename[])
1969 Descripción:
1970 Esta función calcula la recta de mejor ajuste a los
1971 datos contenidos en el archivo << filename >>.
1972 /////////////////////////////////////////////////////
1973 BUGS:
1975 ********************************************************/
1976 void RC(char filename[]){
1977 char letra;
1979 float x, y; // coordenadas del punto
1980 int i, j = 0; // contadores
1981 float a, b, c; // parámetros para parábola...
1982 float Da = 0, Dp = 0;
1983 float Sx, Sy, Sx2, Sx3, Sx4, Sxy, Sx2y;// sumas de datos.
1984 float Error_p = 0;
1985 float dip, y_approxp;
1986 int punto = 0;
1987 Sx = 0; Sy = 0; Sxy = 0;
1988 Sx2 = 0; Sx3 = 0; Sx4 = 0; Sx2y = 0;
1989
1990 FILE *stream_RC; //

1991 stream_RC = fopen(filename, "r+"); // abrir archivo
1992 if (stream_RC == NULL){
1994 filename);
1996 return;
1997 }
1998 do{
1999 letra = fgetc(stream_RC); // leer un char
2000 if (letra == feof(stream_RC)){
2002 }
2003 switch(letra){
2005 if (i > 1){
2007 if (j % 2 == 0){ // dato impar...
2008 x = atof(dato); // convierto a un float

en C++
2009 punto = 0;
2010 }
2011 else{
2013 punto = 1;
2014 }
2015 j++;
2016 i = 0;
2017 }
2018 break;
2019 case ’\t’:// para el caso de varias columnas...
2021 if (j % 2 == 0){
2023 punto = 0;
2024 }
2025 else{
2027 punto = 1;
2028 }
2029 j++;
2030 i = 0;
2031 break;
2033 if (i > 1){
2035 if (j % 2 == 0){
2037 punto = 0;
2038 }
2039 else{
2041 punto = 1;
2042 }
2043 j++;
2044 i = 0;
2045 break;
2046 }
2049 letra = fgetc(stream_RC);
2050 if (letra == feof(stream_RC)){
2051 break;
2052 }
2054 i = 0;
2056 break;
2057 default:

en C++
138 Códigos
2059 punto = 0;
2060 i++;
2061 }
2062 if (punto == 1){
2063 // Realizamos los cálculos...
2064 Sx += x; // Suma de x
2065 Sy += y; // Suma de y
2066 Sxy += x * y; // Suma de xy
2067 Sx2 += x * x; // Suma de x cuadrada
2068 Sx3 += x * x * x; // Suma de x cúbica
2069 Sx4 += x * x * x * x; // Suma x cuarta
2070 Sx2y += x * x * y;
2071 punto = 0;
2072 }
2073 } while(!feof(stream_RC));
2074
2075 // Calculo parámetros de la parábola...

2076 if (j > 6){
2077 // Calculo los parámetros de parábola...
2078 Da = Sy * Sx2 * Sx2 + j * Sxy * Sx3 + Sx * Sx * Sx2y;
2079 Da = Da - j * Sx2 * Sx2y - Sx * Sx3 * Sy - Sx * Sxy * Sx2;
2080 Dp = Sx2 * Sx2 * Sx2 + j * Sx3 * Sx3 + Sx4 * Sx * Sx;
2081 Dp = Dp - j * Sx2 * Sx4 - 2 * Sx * Sx2 * Sx3;
2082 a = Da / Dp;
2083 b = (Sx * (Sy - a * Sx2) - j * (Sxy - a * Sx3)) /
2084 (Sx * Sx - j * Sx2);
2085 c = (Sy - a * Sx2 - b * Sx) / j;
2086 // Muestro los resultados...
2087 printf("\nLa parabola de mejor ajuste es:");
2088 printf("\n y = %.3f xˆ2 + %.3f x + %.3f\n\n", a, b, c);
2089 }
2090 else{
2091 printf("\nNo se pueden realizar los calculos.");
2092 printf("\nEl archivo contiene menos de tres datos...");
2093 }
2094 // cierro el archivo...
2095 fclose(stream_RC);
2096 //system("PAUSE");
2097 return;
2098 }
2099
2100
2101
2102 #endif // PROBABILITY_H

en C++
2.8.1 Ejemplos de uso
En esta sección se muestra cómo utilizar dentro de programas las funciones que
se definieron anteriormente.
Después de cada código se muestra el resultado que imprimió cada programa.
Dado que el encabezado del programa es el mismo siempre se muestra solamente

el programa completo en el primer programa y en los demás se omite.
2.8.1.1 funiforme(total, archivo)
Función 2.8.1
void funiforme(int N, char filename[])
Descripción: Esta función guarda N números pseudoaleatorios con dis-
tribución uniforme en el intervalo (0.0, 1.0) en el archivo con nombre filename.
1 /* Nombre del archivo: testP.cpp

2 Con este programa estoy revisando que las
3 funciones que he incluido en el archivo:
4 <<estadistica.h>> que estoy elaborando estén
5 correctas.
6 ----------------------------------
7 ----------------------------------
8 Nombre del Archivo: testP.cpp
10 Email: efrain@yalma.fime.uanl.mx
11 efra.soto.a@gmail.com
12 Fecha de última modificación: 29 de mayo de 2008
13 ----------------------------------
14 ----------------------------------
15 */
16 #include "estadistica.h"
17
19 int main(void){
20 int total; // números a generar...
21 char archivo[15]; // nombre del archivo...
22 printf("\nEste programa verifica que las funciones");
23 printf("\nincluidas en el codigo del archivo");
24 printf("\n<< estadistica.h >>");
25 printf("\nfuncionen correctamente...");
26 printf("\n\nEstamos probando las funciones: \n");
27 printf("- funiforme(int N, char filename[]),\n");
28 printf("- histograma(char filename[]),\n");
29 printf("- media(char filename[]),\n");
30 printf("- desviacionStd(char filename[]),\n");
31 printf("\n\nCuantos numeros desea generar: ");
32 scanf("%i", &total);
33 printf("\nNombre del archivo: [Incluye extension] ");
34 scanf("%s", &archivo);
35 funiforme(total, archivo);
36 histograma(archivo);
37 printf("\n\nMedia calculada: %f", media(archivo));
38 printf("\n\nDesviacion Estandar calculada: %f", desviacionStd(archivo));

en C++
140 Códigos
40 system("PAUSE");
41 return 0;
42 }
El programa arroja los siguientes resultados ante los siguientes datos:
Este programa verifica que las funciones

incluidas en el codigo del archivo
<< estadistica.h >>
funcionen correctamente...
Estamos probando las funciones:

- funiforme(int N, char filename[15]),
- histograma(char filename[15]),
- media(char filename[15]),
- desviacionStd(char filename[15]),
Cuantos numeros desea generar: 10000
Nombre del archivo: [Incluye extension] test.txt
Intervalo 0.0 -- 0.1 |||||||||||||||||||||||||||||||||| (987)

Intervalo 0.1 -- 0.2 |||||||||||||||||||||||||||||||||| (1004)
Intervalo 0.2 -- 0.3 |||||||||||||||||||||||||||||||| (955) [Min]
Intervalo 0.3 -- 0.4 ||||||||||||||||||||||||||||||||| (978)
Intervalo 0.4 -- 0.5 |||||||||||||||||||||||||||||||||| (996)
Intervalo 0.5 -- 0.6 ||||||||||||||||||||||||||||||||| (984)
Intervalo 0.6 -- 0.7 |||||||||||||||||||||||||||||||||||| (1062) [Max]
Intervalo 0.7 -- 0.8 |||||||||||||||||||||||||||||||||| (1001)
Intervalo 0.8 -- 0.9 |||||||||||||||||||||||||||||||||| (1014)
Intervalo 0.9 -- 1.0 ||||||||||||||||||||||||||||||||||| (1018)
Media calculada: 0.503787

Desviacion Estandar calculada: 0.288886
Presione una tecla para continuar . . .
2.8.1.2 funiforme(total, archivo, A, B)
Función 2.8.2
void funiforme(int N, char filename[], float a, float b)
tribución uniforme en el intervalo (a, b) en el archivo con nombre filename.
Modificamos la lı́nea 35 del programa anterior (lı́nea 25 del siguiente programa)

para utilizar la función funiforme, ahora considerando también un intervalo
(A, B) defindo por el usuario:
2

en C++
4 int main(void){
7 float A, B; // parametros de la distribucion
13 printf("- funiforme(int N, char filename[], float a, float b),\n");
19 printf("\n\nLimite inferior de la distribucion: ");
20 scanf("%f", &A);
21 printf("\n\nLimite superior de la distribucion: ");
22 scanf("%f", &B);
25 funiforme(total, archivo, A, B);
30 system("PAUSE");
31 return 0;
32 }
Nóte que se agregaron algunas lı́neas de código para pedir los parámetros A
y B, que corresponden a los lı́mites inferior y superior del intervalo donde se
generarán los números pseudoaleatorios con distribución uniforme.
El programa ahora arroja los siguientes resultados:
...
Limite inferior de la distribucion: -100

Limite superior de la distribucion: 100
Intervalo -100.0 -- -80.0 |||||||||||||||||||||||||||||||||| (987)

Intervalo -80.0 -- -60.0 |||||||||||||||||||||||||||||||||| (1004)
Intervalo -60.0 -- -40.0 |||||||||||||||||||||||||||||||| (955) [Min]
Intervalo -40.0 -- -20.0 ||||||||||||||||||||||||||||||||| (978)
Intervalo -20.0 -- 0.0 |||||||||||||||||||||||||||||||||| (996)
Intervalo 0.0 -- 20.0 ||||||||||||||||||||||||||||||||| (984)
Intervalo 20.0 -- 40.0 |||||||||||||||||||||||||||||||||||| (1062) [Max]
Intervalo 40.0 -- 60.0 |||||||||||||||||||||||||||||||||| (1001)
Intervalo 60.0 -- 80.0 |||||||||||||||||||||||||||||||||| (1014)
Intervalo 80.0 -- 100.0 ||||||||||||||||||||||||||||||||||| (1018)


en C++
142 Códigos
2.8.1.3 fnormal(total, archivo)
Función 2.8.3
void fnormal(int N, char filename[])
tribución normal con media 0.0 y desviacion estándar 1.0 en el archivo con
nombre filename.
2
4 int main(void){
12 printf("- fnormal(int N, char filename[]),\n");
20 fnormal(total, archivo);//, A, B
25 system("PAUSE");
26 return 0;
27 }
El programa arroja:
Intervalo -3.8 -- -3.0 | (13)

Intervalo -3.0 -- -2.2 ||| (134)
Intervalo -2.2 -- -1.4 |||||||| (608)
Intervalo -1.4 -- -0.6 |||||||||||||||||||||| (1827)
Intervalo -0.6 -- 0.1 |||||||||||||||||||||||||||||||||||| (3039) [Max]
Intervalo 0.1 -- 0.9 ||||||||||||||||||||||||||||||| (2645)
Intervalo 0.9 -- 1.7 |||||||||||||||| (1308)
Intervalo 1.7 -- 2.5 ||||| (367)
Intervalo 2.5 -- 3.3 || (52)
Intervalo 3.3 -- 4.1 | (6) [Min]
Media calculada: -0.002336


en C++
2.8.1.4 fnormal(total, archivo, media, SD)
Función 2.8.4
void fnormal(int N, char filename[], float med, float desvStd)
tribución normal con media med y desviacion estándar desvStd en el archivo de
nombre filename.
3 int main(void){
5 float mean, SD;
12 printf("- fnormal(int N, char filename[], float med, float desvStd),\n");
18 printf("\n\nMedia de la distribucion: ");
19 scanf("%f", &mean);
20 printf("\n\nDesviacion estandar de la distribucion: ");
21 scanf("%f", &SD);
24 fnormal(total, archivo, mean, SD);//
29 system("PAUSE");
30 return 0;
31 }

Media de la distribucion: 100
Desviacion estandar de la distribucion: 7
Intervalo 73.4 -- 78.9 | (13)

Intervalo 78.9 -- 84.5 ||| (134)
Intervalo 84.5 -- 90.0 |||||||| (608)
Intervalo 90.0 -- 95.5 |||||||||||||||||||||| (1827)
Intervalo 95.5 -- 101.0 |||||||||||||||||||||||||||||||||||| (3039) [Max]
Intervalo 101.0 -- 106.6 ||||||||||||||||||||||||||||||| (2645)
Intervalo 106.6 -- 112.1 |||||||||||||||| (1308)
Intervalo 112.1 -- 117.6 ||||| (367)
Intervalo 117.6 -- 123.1 || (52)
Intervalo 123.1 -- 128.7 | (6) [Min]


en C++
144 Códigos
2.8.1.5 fexponencial(total, lambda, archivo)
Función 2.8.5
void fexponencial(int N, float Lambda, char filename[])
Descripción: Esta función genera N números pseudoaleatorios con dis-
tribución exponencial, con parámetro Lambda, y los graba en el archivo de
nombre filename.
2
4 int main(void){
7 float L; // parametro de la distribucion
13 printf("- fexponencial(int N, float Lambda, char filename[]),\n");
19 printf("\n\nParametro Lambda de la distribucion: ");
20 scanf("%f", &L);
23 fexponencial(total, L, archivo);//, mean, SD
28 system("PAUSE");
29 return 0;
30 }

Parametro Lambda de la distribucion: 0.5
Intervalo 0.0 -- 1.9 |||||||||||||||||||||||||||||||||||| (6143) [Max]

Intervalo 1.9 -- 3.9 ||||||||||||||| (2400)
Intervalo 3.9 -- 5.8 |||||| (916)
Intervalo 5.8 -- 7.8 ||| (319)
Intervalo 7.8 -- 9.7 || (123)
Intervalo 9.7 -- 11.6 | (58)
Intervalo 11.6 -- 13.6 | (29)
Intervalo 13.6 -- 15.5 | (5)
Intervalo 15.5 -- 17.5 | (4)
Intervalo 17.5 -- 19.4 | (2) [Min]


en C++
2.8.1.6 fgeometrica(total, p, archivo)
Función 2.8.6
void fgeometrica(int N, float p, char filename[15])
tribución geometrica, con parámetro p, y los graba en el archivo de nombre
filename.
2
4 int main(void){
7 float p; // parametro de la distribucion
10 printf("\n\nParametro p de la distribucion: ");
11 scanf("%f", &p);
14 fgeometrica(total, p, archivo);//, mean, SD
18 system("PAUSE");
19 return 0;
20 }

Parametro p de la distribucion: 0.75

2.8.1.7 fpoisson(total, alpha, archivo)
Función 2.8.7
void fpoisson(int N, float a, char filename[])
tribución poisson, con parámetro α, y los graba en el archivo de nombre
filename.
2

en C++
146 Códigos

4 int main(void){
5 char filename[15];
6 float a; // parametro de la distribucion
7 int total, i;
8 printf("\nEste programa verifica que la funcion");
9 printf("\nvoid fpoisson(int N, float alpha, char filename[])");
10 printf("\nfuncione correctamente...\n");
11 printf("Cuantos numeros desea generar? ");
13 printf("\nParametro Alpha supuesto: ");
14 scanf("%f", &a);
15 printf("\nNombre del archivo: ");
16 scanf("%s", &filename);
17 fpoisson(total, a, filename);
19 system("PAUSE");
20 return 0;
21 }
Este programa verifica que la funcion

void fpoisson(int N, float alpha, char filename[])
funcione correctamente...
Cuantos numeros desea generar? 1200
Parametro Alpha supuesto: 3

Nombre del archivo: test.txt
2.8.1.8 fweibull(total, archivo, c, k)
Función 2.8.8
void fweibull(int N, char filename[], float C, float K)
tribución weibull, con parámetros C y K, y los graba en el archivo de nombre
filename.
3 int main(void){
4 int total; // de números a generar...
6 float C, K; // parametros de la distribucion
12 printf("- fweibull(int N, char filename[], float C, float K),\n");

en C++
18 printf("\n\nParametro C de la distribucion: ");

19 scanf("%f", &C);
20 printf("\n\nParametro K de la distribucion: ");
21 scanf("%f", &K);/**/
24 fweibull(total, archivo, C, K);
29 system("PAUSE");
30 return 0;
31 }
Parametro C de la distribucion: 11.86

Parametro K de la distribucion: 1.77
Intervalo 0.1 -- 4.3 ||||||||||||||||||||| (1534)

Intervalo 4.3 -- 8.6 |||||||||||||||||||||||||||||||||||| (2726) [Max]
Intervalo 8.6 -- 12.9 |||||||||||||||||||||||||||||||||| (2572)
Intervalo 12.9 -- 17.2 ||||||||||||||||||||||| (1682)
Intervalo 17.2 -- 21.4 ||||||||||||| (907)
Intervalo 21.4 -- 25.7 |||||| (367)
Intervalo 25.7 -- 30.0 ||| (132)
Intervalo 30.0 -- 34.3 || (65)
Intervalo 34.3 -- 38.5 | (9)
Intervalo 38.5 -- 42.8 | (5) [Min]

2.8.1.9 frayleigh(total, archivo, media)
Función 2.8.9
void frayleigh(int N, char filename[], float M)
tribución rayleigh, con media M y los graba en el archivo de nombre filename.
3 int main(void){
6 float mean;
12 printf("- frayleigh(int N, char filename[], float M),\n");

en C++
148 Códigos

22 frayleigh(total, archivo, mean);
27 system("PAUSE");
28 return 0;
29 }
Media de la distribucion: 9.8

Intervalo 0.1 -- 3.4 |||||||||||||| (946)

Intervalo 3.4 -- 6.8 ||||||||||||||||||||||||||||||| (2237)
Intervalo 6.8 -- 10.2 |||||||||||||||||||||||||||||||||||| (2598) [Max]
Intervalo 10.2 -- 13.5 |||||||||||||||||||||||||||| (1996)
Intervalo 13.5 -- 16.9 |||||||||||||||||| (1274)
Intervalo 16.9 -- 20.3 ||||||||| (603)
Intervalo 20.3 -- 23.6 |||| (234)
Intervalo 23.6 -- 27.0 || (78)
Intervalo 27.0 -- 30.4 | (28)
Intervalo 30.4 -- 33.7 | (5) [Min]

2.8.1.10 histograma(archivo, intervalos)
Función 2.8.10
histograma(char filename[], int No Int)
Descripción: Esta función genera un histograma de No Int intervalos en la
pantalla a partir de los datos leı́dos en el archivo de nombre filename.
3 int main(void){
6 float mean; // parametro de la distribucion
9 printf("\n<< probability.h >>");
12 printf("- funiforme(int N, char filename[]),\n");

en C++

22 frayleigh(total, archivo, mean);
23 histograma(archivo, 20);
24 system("PAUSE");
25 return 0;
26 }

Intervalo 0.1 -- 1.8 |||||||| (259)

Intervalo 1.8 -- 3.4 ||||||||||||||||||| (687)
Intervalo 3.4 -- 5.1 ||||||||||||||||||||||||||| (1027)
Intervalo 5.1 -- 6.8 |||||||||||||||||||||||||||||||| (1210)
Intervalo 6.8 -- 8.5 |||||||||||||||||||||||||||||||||||| (1367) [Max]
Intervalo 8.5 -- 10.2 ||||||||||||||||||||||||||||||||| (1231)
Intervalo 10.2 -- 11.9 |||||||||||||||||||||||||||||| (1116)
Intervalo 11.9 -- 13.5 |||||||||||||||||||||||| (880)
Intervalo 13.5 -- 15.2 |||||||||||||||||||| (747)
Intervalo 15.2 -- 16.9 |||||||||||||| (527)
Intervalo 16.9 -- 18.6 |||||||||| (339)
Intervalo 18.6 -- 20.3 |||||||| (264)
Intervalo 20.3 -- 21.9 ||||| (142)
Intervalo 21.9 -- 23.6 ||| (92)
Intervalo 23.6 -- 25.3 || (45)
Intervalo 25.3 -- 27.0 || (33)
Intervalo 27.0 -- 28.7 | (19)
Intervalo 28.7 -- 30.4 | (9)
Intervalo 30.4 -- 32.0 | (3)
Intervalo 32.0 -- 33.7 | (2) [Min]
Una caso en el que se requiere un histograma con un mayor número de intervalos

en el histograma se justifica, por ejemplo, en el caso del pronóstico del recurso
eólico de un local.
En este caso, la energı́a eléctrica que se puede producir utilizando un generador

eólico es proporcional al cubo de la velocidad.
Cuando la velocidad del viento varı́a en un 25.99%, la√cantidad de energı́a

producida con el viento aumenta al doble, debido a que 3 2 ≈ 1.2599. Por esa
misma razón, sin la velocidad del viento disminuye en ese mismo porcentaje, la
cantidad de energı́a producida se reduce ahora a la mitad.
Por otra parte, si la velocidad del√viento aumenta un 44.22%, la energı́a pro-

ducida aumenta al triple, porque 3 3 ≈ 1.4422.
Entonces, distribución más suave nos permite calcular un pronóstico de la en-

ergı́a producida por un generador eólico con mayor precisión.

en C++
150 Códigos
Otro ejemplo, donde se hace evidente la cantidad de información extra que

muestra esta función para un mismo conjunto de datos es el siguiente:
4 int main(void){
7 float C, K; // parametros de la distribucion...
8 cout << "\nCuantos numeros desea generar: ";
9 cin >> total;
10 cout << "\nParametro C de la distribucion: ";
11 cin >> C;
12 cout << "\nParametro K de la distribucion: ";
13 cin >> K;
14 cout << "\nNombre del archivo: [Incluye extension] ";
15 cin >> archivo;
16 fweibull(total, archivo, C, K);
17 cout << "\nHistograma con 10 intervalos:";
18 histograma(archivo,10);
23 cout << "\nMedia calculada: " << media(archivo);
24 cout << "\nDesviacion Estandar calculada: " << desviacionStd(archivo);
25 cout << "\n\n\n";
26 system("PAUSE");
27 return 0;
28 }

Nombre del archivo: [Incluye extension] weibull.txt
Histograma con 10 intervalos:
Intervalo 0.0 -- 4.5 |||||||||||||||||||| (84735)

Intervalo 4.5 -- 8.9 |||||||||||||||||||||||||||||||||||| (152812) [Max]
Intervalo 8.9 -- 13.4 |||||||||||||||||||||||||||||||| (135245)
Intervalo 13.4 -- 17.8 ||||||||||||||||||||| (85517)
Intervalo 17.8 -- 22.3 ||||||||||| (42269)
Intervalo 22.3 -- 26.7 ||||| (17150)
Intervalo 26.7 -- 31.2 || (5674)
Intervalo 31.2 -- 35.6 | (1712)
Intervalo 35.6 -- 40.1 | (363)
Intervalo 40.1 -- 44.5 | (83) [Min]
Intervalo 0.0 -- 2.2 ||||||||||||| (26559)

Intervalo 2.2 -- 4.5 ||||||||||||||||||||||||||| (58176)
Intervalo 4.5 -- 6.7 |||||||||||||||||||||||||||||||||| (74215)
Intervalo 6.7 -- 8.9 |||||||||||||||||||||||||||||||||||| (78597) [Max]
Intervalo 8.9 -- 11.1 |||||||||||||||||||||||||||||||||| (73003)
Intervalo 11.1 -- 13.4 ||||||||||||||||||||||||||||| (62242)
Intervalo 13.4 -- 15.6 ||||||||||||||||||||||| (49103)
Intervalo 15.6 -- 17.8 ||||||||||||||||| (36414)
Intervalo 17.8 -- 20.0 |||||||||||| (25392)
Intervalo 20.0 -- 22.3 ||||||||| (16877)
Intervalo 22.3 -- 24.5 |||||| (10727)

en C++
Intervalo 24.5 -- 26.7 |||| (6423)

Intervalo 26.7 -- 28.9 ||| (3664)
Intervalo 28.9 -- 31.2 || (2010)
Intervalo 31.2 -- 33.4 || (1138)
Intervalo 33.4 -- 35.6 | (574)
Intervalo 35.6 -- 37.8 | (244)
Intervalo 37.8 -- 40.1 | (119)
Intervalo 40.1 -- 42.3 | (44)
Intervalo 42.3 -- 44.5 | (39) [Min]
Intervalo 0.0 -- 1.5 |||||||||| (13088)

Intervalo 1.5 -- 3.0 ||||||||||||||||||||| (30209)
Intervalo 3.0 -- 4.5 ||||||||||||||||||||||||||||| (41438)
Intervalo 4.5 -- 5.9 |||||||||||||||||||||||||||||||||| (48517)
Intervalo 5.9 -- 7.4 |||||||||||||||||||||||||||||||||||| (52126)
Intervalo 7.4 -- 8.9 |||||||||||||||||||||||||||||||||||| (52169) [Max]
Intervalo 8.9 -- 10.4 |||||||||||||||||||||||||||||||||| (49325)
Intervalo 10.4 -- 11.9 |||||||||||||||||||||||||||||||| (45771)
Intervalo 11.9 -- 13.4 |||||||||||||||||||||||||||| (40149)
Intervalo 13.4 -- 14.8 |||||||||||||||||||||||| (34137)
Intervalo 14.8 -- 16.3 |||||||||||||||||||| (28353)
Intervalo 16.3 -- 17.8 |||||||||||||||| (23027)
Intervalo 17.8 -- 19.3 ||||||||||||| (18022)
Intervalo 19.3 -- 20.8 |||||||||| (13989)
Intervalo 20.8 -- 22.3 |||||||| (10258)
Intervalo 22.3 -- 23.7 |||||| (7683)
Intervalo 23.7 -- 25.2 ||||| (5599)
Intervalo 25.2 -- 26.7 |||| (3868)
Intervalo 26.7 -- 28.2 ||| (2690)
Intervalo 28.2 -- 29.7 || (1796)
Intervalo 29.7 -- 31.2 || (1188)
Intervalo 31.2 -- 32.7 || (841)
Intervalo 32.7 -- 34.1 | (535)
Intervalo 34.1 -- 35.6 | (336)
Intervalo 35.6 -- 37.1 | (187)
Intervalo 37.1 -- 38.6 | (98)
Intervalo 38.6 -- 40.1 | (78)
Intervalo 40.1 -- 41.6 | (29)
Intervalo 41.6 -- 43.0 | (33)
Intervalo 43.0 -- 44.5 | (21) [Min]

Evidentemente, mientras más intervalos conozcamos, podremos hacer cálculos

más refinados y tener resultados más precisos. Mientras el primer histograma
(10 intervalos) nos indica alguna información, no se compara con el nivel de
detalle que nos proporciona el último histograma (30 intervalos). Si hacemos
el pronóstico de la energı́a producida en un año a partir de las probabilidades
asignadas a cada intervalo, los resultados serán muy diferentes, porque en ese
caso, cada intervalos representa los lı́mites superior e inferior de la velocidad del
viento.
Como la energı́a producida depende del cubo de la velocidad del viento, ten-
dremos una diferencia considerable al realizar el pronóstico. Tomando el punto
medio de cada intervalo, elevándolo al cubo y multiplicando por la probabilidad
que le corresponde a ese intervalo, tendremos una aproximación simplificada del
resultado (falta considerar cuestiones técnicas relativas al generador eólico, al-

en C++
152 Códigos
gunas cuestiones de conversión de la energı́a cinética del viento a la electricidad

generada por el generador eólico, etc.) y podemos ver la gran diferencia en cada
caso.
Nota: Los datos que se introdujeron en el último ejemplo corresponden a

la distribución que presenta la velocidad de viento en la Venta, Oaxaca, Mex.
Fuente: Evaluación del recurso eólico de La Venta, Juchitán, Oaxaca. M. A.
Borja, O. A. Jaramillo, M. F. Morales. Instituto de Investigaciones Eléctricas.
Temixco, Morelos, México. ojs@iie.org.mx. El valor 525 600 = 60 × 24 × 365,
el número de minutos en un año no bisiesto. Entonces, el valor que aparece
entre paréntesis indica el número de minutos al año que la velocidad presentó
una velocidad en el intervalo que le corresponde.
El promedio calculado con la ayuda de la función media(archivo) corresponde

a la media aritmética de los datos. No considera la frecuencia relativa por la
cual debe multiplicarse para realizar este cálculo. Histogramas con mayores in-
tervalos nos muestran información que nos ayudarán, en este caso, a pronosticar
con mayor precisión el valor buscado, dado que tendremos una curva más suave.
Intervalo 0.0 -- 1.1 |||||||| (7846)

Intervalo 1.1 -- 2.2 |||||||||||||||||| (18713)
Intervalo 2.2 -- 3.3 |||||||||||||||||||||||| (26181)
Intervalo 3.3 -- 4.5 ||||||||||||||||||||||||||||| (31995)
Intervalo 4.5 -- 5.6 ||||||||||||||||||||||||||||||||| (35839)
Intervalo 5.6 -- 6.7 ||||||||||||||||||||||||||||||||||| (38376)
Intervalo 6.7 -- 7.8 |||||||||||||||||||||||||||||||||||| (39618) [Max]
Intervalo 7.8 -- 8.9 ||||||||||||||||||||||||||||||||||| (38979)
Intervalo 8.9 -- 10.0 |||||||||||||||||||||||||||||||||| (37305)
Intervalo 10.0 -- 11.1 ||||||||||||||||||||||||||||||||| (35698)
Intervalo 11.1 -- 12.2 |||||||||||||||||||||||||||||| (32791)
Intervalo 12.2 -- 13.4 ||||||||||||||||||||||||||| (29451)
Intervalo 13.4 -- 14.5 |||||||||||||||||||||||| (26195)
Intervalo 14.5 -- 15.6 ||||||||||||||||||||| (22908)
Intervalo 15.6 -- 16.7 |||||||||||||||||| (19512)
Intervalo 16.7 -- 17.8 |||||||||||||||| (16902)
Intervalo 17.8 -- 18.9 ||||||||||||| (13930)
Intervalo 18.9 -- 20.0 ||||||||||| (11462)
Intervalo 20.0 -- 21.1 ||||||||| (9468)
Intervalo 21.1 -- 22.3 |||||||| (7409)
Intervalo 22.3 -- 23.4 |||||| (5946)
Intervalo 23.4 -- 24.5 ||||| (4781)
Intervalo 24.5 -- 25.6 |||| (3714)
Intervalo 25.6 -- 26.7 ||| (2709)
Intervalo 26.7 -- 27.8 ||| (2100)
Intervalo 27.8 -- 28.9 || (1564)
Intervalo 28.9 -- 30.1 || (1138)
Intervalo 30.1 -- 31.2 || (872)
Intervalo 31.2 -- 32.3 || (667)
Intervalo 32.3 -- 33.4 | (471)
Intervalo 33.4 -- 34.5 | (353)
Intervalo 34.5 -- 35.6 | (221)
Intervalo 35.6 -- 36.7 | (134)
Intervalo 36.7 -- 37.8 | (110)
Intervalo 37.8 -- 39.0 | (75)
Intervalo 39.0 -- 40.1 | (44)
Intervalo 40.1 -- 41.2 | (29)
Intervalo 41.2 -- 42.3 | (15) [Min]

en C++
Intervalo 42.3 -- 43.4 | (18)

Intervalo 43.4 -- 44.5 | (21)
Intervalo 0.0 -- 0.9 ||||||| (5258)

Intervalo 0.9 -- 1.8 ||||||||||||||| (12698)
Intervalo 1.8 -- 2.7 ||||||||||||||||||||| (18220)
Intervalo 2.7 -- 3.6 |||||||||||||||||||||||||| (22630)
Intervalo 3.6 -- 4.5 |||||||||||||||||||||||||||||| (25929)
Intervalo 4.5 -- 5.3 |||||||||||||||||||||||||||||||| (28446)
Intervalo 5.3 -- 6.2 |||||||||||||||||||||||||||||||||| (30203)
Intervalo 6.2 -- 7.1 |||||||||||||||||||||||||||||||||||| (31348)
Intervalo 7.1 -- 8.0 |||||||||||||||||||||||||||||||||||| (31668) [Max]
Intervalo 8.0 -- 8.9 ||||||||||||||||||||||||||||||||||| (31147)
Intervalo 8.9 -- 9.8 |||||||||||||||||||||||||||||||||| (30042)
Intervalo 9.8 -- 10.7 ||||||||||||||||||||||||||||||||| (28861)
Intervalo 10.7 -- 11.6 ||||||||||||||||||||||||||||||| (27510)
Intervalo 11.6 -- 12.5 ||||||||||||||||||||||||||||| (25550)
Intervalo 12.5 -- 13.4 ||||||||||||||||||||||||||| (23282)
Intervalo 13.4 -- 14.2 ||||||||||||||||||||||||| (21302)
Intervalo 14.2 -- 15.1 |||||||||||||||||||||| (19039)
Intervalo 15.1 -- 16.0 |||||||||||||||||||| (16896)
Intervalo 16.0 -- 16.9 |||||||||||||||||| (14965)
Intervalo 16.9 -- 17.8 |||||||||||||||| (13315)
Intervalo 17.8 -- 18.7 |||||||||||||| (11387)
Intervalo 18.7 -- 19.6 |||||||||||| (9700)
Intervalo 19.6 -- 20.5 |||||||||| (8388)
Intervalo 20.5 -- 21.4 ||||||||| (7033)
Intervalo 21.4 -- 22.3 ||||||| (5761)
Intervalo 22.3 -- 23.2 |||||| (4872)
Intervalo 23.2 -- 24.0 ||||| (4038)
Intervalo 24.0 -- 24.9 ||||| (3413)
Intervalo 24.9 -- 25.8 |||| (2728)
Intervalo 25.8 -- 26.7 ||| (2099)
Intervalo 26.7 -- 27.6 ||| (1732)
Intervalo 27.6 -- 28.5 ||| (1358)
Intervalo 28.5 -- 29.4 || (1088)
Intervalo 29.4 -- 30.3 || (820)
Intervalo 30.3 -- 31.2 || (676)
Intervalo 31.2 -- 32.1 || (571)
Intervalo 32.1 -- 32.9 | (403)
Intervalo 32.9 -- 33.8 | (319)
Intervalo 33.8 -- 34.7 | (241)
Intervalo 34.7 -- 35.6 | (178)
Intervalo 35.6 -- 36.5 | (111)
Intervalo 36.5 -- 37.4 | (104)
Intervalo 37.4 -- 38.3 | (56)
Intervalo 38.3 -- 39.2 | (48)
Intervalo 39.2 -- 40.1 | (44)
Intervalo 40.1 -- 41.0 | (12)
Intervalo 41.0 -- 41.9 | (32)
Intervalo 41.9 -- 42.7 | (0) [Min]
Intervalo 42.7 -- 43.6 | (18)
Intervalo 43.6 -- 44.5 | (21)

en C++
154 Códigos
2.8.1.11 PchiUniforme(archivo, No Int)
Función 2.8.11
void PchiUniforme(char filename[], int Num Int)
Descripción: Esta función sirve de apoyo en la prueba de bondad de ajuste
que los datos contenidos en el archivo de nombre filename presenten una dis-
tribución uniforme, calculando el valor de χ2 .
3 int main(void){
8 printf("\nChiUniforme(char filename[], int Num_Int)");
9 printf("\nfuncione correctamente...");
14 funiforme(total, archivo); // genero uniformes...
15 PchiUniforme(archivo, 15); // prueba chiˆ2
16 printf("\nHistograma Observado...");
17 histograma(archivo, 15); // dibujar histograma...
19 system("PAUSE");
20 return 0;
21 }

ChiUniforme(char filename[], int Num_Int, float alpha)

El archivo test.txt contiene 20000 datos.
Chiˆ2 = 0.001277
Los datos contenidos en el archivo test.txt

parecen presentar distribucion uniforme.
Histograma Observado...
Intervalo 0.0 -- 0.1 ||||||||||||||||||||||||||||||||| (1351)

Intervalo 0.1 -- 0.1 ||||||||||||||||||||||||||||||| (1248) [Min]
Intervalo 0.1 -- 0.2 ||||||||||||||||||||||||||||||||| (1345)
Intervalo 0.2 -- 0.3 ||||||||||||||||||||||||||||||||| (1342)
Intervalo 0.3 -- 0.3 |||||||||||||||||||||||||||||||| (1283)
Intervalo 0.3 -- 0.4 |||||||||||||||||||||||||||||||| (1293)
Intervalo 0.4 -- 0.5 ||||||||||||||||||||||||||||||||| (1321)
Intervalo 0.5 -- 0.5 |||||||||||||||||||||||||||||||| (1281)
Intervalo 0.5 -- 0.6 |||||||||||||||||||||||||||||||||| (1367)
Intervalo 0.6 -- 0.7 |||||||||||||||||||||||||||||||||||| (1458) [Max]
Intervalo 0.7 -- 0.7 ||||||||||||||||||||||||||||||||| (1322)
Intervalo 0.7 -- 0.8 |||||||||||||||||||||||||||||||| (1312)
Intervalo 0.8 -- 0.9 |||||||||||||||||||||||||||||||||| (1358)

en C++
Intervalo 0.9 -- 0.9 |||||||||||||||||||||||||||||||||| (1359)

Intervalo 0.9 -- 1.0 |||||||||||||||||||||||||||||||||| (1359)
El siguiente prueba un archivo que tiene datos con distribución normal estándar.
3 int main(void){
6 printf("\nChiUniforme(char filename[], int Num_Int)");
10 PchiUniforme(archivo, 15);
14 system("PAUSE");
15 return 0;
16 }

ChiUniforme(char filename[], int Num_Int)
Nombre del archivo: [Incluye extension] normal.txt
El archivo normal.txt contiene 99999 datos.
Chiˆ2 = 1.339906
Intervalo -1.1 -- -0.9 | (11) [Min]

Intervalo -0.9 -- -0.7 | (92)
Intervalo -0.7 -- -0.5 || (517)
Intervalo -0.5 -- -0.3 |||| (1948)
Intervalo -0.3 -- -0.1 |||||||||| (5820)
Intervalo -0.1 -- 0.1 ||||||||||||||||||||| (12346)
Intervalo 0.1 -- 0.2 ||||||||||||||||||||||||||||||| (19189)
Intervalo 0.2 -- 0.4 |||||||||||||||||||||||||||||||||||| (22026) [Max]
Intervalo 0.4 -- 0.6 ||||||||||||||||||||||||||||||| (18597)
Intervalo 0.6 -- 0.8 |||||||||||||||||||| (11736)
Intervalo 0.8 -- 1.0 |||||||||| (5414)
Intervalo 1.0 -- 1.2 |||| (1747)
Intervalo 1.2 -- 1.4 || (460)
Intervalo 1.4 -- 1.6 | (80)
Intervalo 1.6 -- 1.8 | (15)

en C++
156 Códigos
2.8.1.12 PchiNormal(archivo, No Int)
Función 2.8.12
void PchiNormal(char filename[], int Num Int)
tribución normal, calculando el valor de χ2 . La función calcula la media y
la desviación estándar de los datos contenidos en el archivo y los utiliza para
realizar el cálculo de χ2 .
3 int main(void){
6 printf("\nPchiNormal(char filename[], int Num_Int)");
10 PchiNormal(archivo, 15);
14 system("PAUSE");
15 return 0;
16 }

PchiNormal(char filename[], int Num\_Int)
Nombre del archivo: [Incluye extension] Normal.txt
El archivo Normal.txt contiene 99999 datos.

Chiˆ2 = 0.000004
Los datos contenidos en el archivo Normal.txt

parecen presentar distribucion normal.
Intervalo -1.1 -- -0.9 | (11) [Min]

Intervalo -0.9 -- -0.7 | (92)
Intervalo -0.7 -- -0.5 || (517)
Intervalo -0.5 -- -0.3 |||| (1948)
Intervalo -0.3 -- -0.1 |||||||||| (5820)
Intervalo -0.1 -- 0.1 ||||||||||||||||||||| (12346)
Intervalo 0.1 -- 0.2 ||||||||||||||||||||||||||||||| (19189)
Intervalo 0.2 -- 0.4 |||||||||||||||||||||||||||||||||||| (22026) [Max]
Intervalo 0.4 -- 0.6 ||||||||||||||||||||||||||||||| (18597)
Intervalo 0.6 -- 0.8 |||||||||||||||||||| (11736)
Intervalo 0.8 -- 1.0 |||||||||| (5414)
Intervalo 1.0 -- 1.2 |||| (1747)
Intervalo 1.2 -- 1.4 || (460)
Intervalo 1.4 -- 1.6 | (80)
Intervalo 1.6 -- 1.8 | (15)

en C++
Un segundo ejemplo donde se utiliza un archivo con datos uniformes es el sigu-

iente:

PchiNormal(char filename[], int Num\_Int)
Nombre del archivo: [Incluye extension] Uniforme.txt
El archivo Uniforme.txt contiene 99999 datos.

Chiˆ2 = 79.591026
Intervalo 0.0 -- 0.1 ||||||||||||||||||||||||||||||||||| (6650)

Intervalo 0.1 -- 0.1 ||||||||||||||||||||||||||||||||||| (6591)
Intervalo 0.1 -- 0.2 ||||||||||||||||||||||||||||||||||| (6733)
Intervalo 0.2 -- 0.3 |||||||||||||||||||||||||||||||||| (6522)
Intervalo 0.3 -- 0.3 |||||||||||||||||||||||||||||||||| (6514)
Intervalo 0.3 -- 0.4 ||||||||||||||||||||||||||||||||||| (6677)
Intervalo 0.4 -- 0.5 ||||||||||||||||||||||||||||||||||| (6681)
Intervalo 0.5 -- 0.5 ||||||||||||||||||||||||||||||||||| (6673)
Intervalo 0.5 -- 0.6 ||||||||||||||||||||||||||||||||||| (6701)
Intervalo 0.6 -- 0.7 |||||||||||||||||||||||||||||||||||| (6880) [Max]
Intervalo 0.7 -- 0.7 ||||||||||||||||||||||||||||||||||| (6665)
Intervalo 0.7 -- 0.8 |||||||||||||||||||||||||||||||||| (6513) [Min]
Intervalo 0.8 -- 0.9 ||||||||||||||||||||||||||||||||||| (6730)
Intervalo 0.9 -- 0.9 |||||||||||||||||||||||||||||||||||| (6849)
Intervalo 0.9 -- 1.0 ||||||||||||||||||||||||||||||||||| (6618)
2.8.1.13 PchiExponencial(archivo, Num Int, lambda)
Función 2.8.13
void PchiExponencial(char filename[], int Num Int, float lambda)
tribución normal, calculando el valor de χ2 . La función calcula la media y
la desviación estándar de los datos contenidos en el archivo y los utiliza para
realizar el cálculo de χ2 .
3 int main(void){

en C++
158 Códigos
6 float L;
8 printf("\nPchiExponencial(char filename[], int Num_Int, float lambda)");
12 printf("\n\nParametro Lambda de la distribucion: ");
13 scanf("%f", &L);
16 fexponencial(total, 3.0, archivo); // genero numeros pseudoaleatorios
17 PchiExponencial(archivo, 15, 3); // prueba de bondad de ajuste
21 system("PAUSE");
22 return 0;
23 }

PchiExponencial(char filename[], int Num\_Int, float lambda)

Parametro Lambda de la distribucion: 3

Chiˆ2 = 0.762427
Intervalo 0.0 -- 0.2 |||||||||||||||||||||||||||||||||||| (98) [Max]

Intervalo 0.2 -- 0.4 ||||||||||||||||||||||||| (68)
Intervalo 0.4 -- 0.5 |||||||||||||| (35)
Intervalo 0.5 -- 0.7 ||||||||| (23)
Intervalo 0.7 -- 0.9 ||||| (10)
Intervalo 0.9 -- 1.1 ||| (5)
Intervalo 1.1 -- 1.3 || (2)
Intervalo 1.3 -- 1.4 | (1)
Intervalo 1.4 -- 1.6 || (2)
Intervalo 1.6 -- 1.8 || (2)
Intervalo 1.8 -- 2.0 | (1)
Intervalo 2.0 -- 2.2 | (1)
Intervalo 2.2 -- 2.3 | (0) [Min]
Intervalo 2.3 -- 2.5 | (0) [Min]
Intervalo 2.5 -- 2.7 | (1)
Enseguida se da un ejemplo donde se utiliza el archivo Uniforme.txt que con-

tiene datos con distribución uniforme.
En la lı́nea 10 del código se indica a la función que suponemos que el archivo

contiene datos con distribución exponencial con parámetro λ = 3.0

en C++
3 int main(void){
5 float L; // parametro lambda
7 printf("\nChiUniforme(char filename[], int Num_Int, float alpha)");
11 printf("\nParametro Lambda supuesto: ");
12 scanf("%f", &L);
13 PchiExponencial(archivo, 15, L);
15 system("PAUSE");
16 return 0;
17 }

Nombre del archivo: [Incluye extension] Uniforme.txt
Parametro Lambda supuesto: 3.0
El archivo Uniforme.txt contiene 99999 datos.

Chiˆ2 = 288.591888
2.8.1.14 PchiWeibull(Archivo, Num Int, C, K)
Función 2.8.14
void PchiWeibull(char filename[], int Num Int, float c, float k)
Descripción: Esta función prueba que los datos contenidos en el archivo de
nombre filename presenten una distribución Weibull con parámetro promedio.
Devuelve el número de datos leidos del archivo, la media de esos datos el valor
de χ2 .
3 int main(void){
5 float C, K; // intervalo para generar uniformes
11 printf("\nValor del parametro C: ");
12 scanf("%f", &C);
13 printf("\nValor del parametro K: ");
14 scanf("%f", &K);
15 PchiWeibull(archivo, 15, C, K);

en C++
160 Códigos
19 system("PAUSE");
20 return 0;
21 }

Nombre del archivo: [Incluye extension] Weibull.txt
Valor del parametro C: 11.86

Valor del parametro K: 1.77
El archivo Weibull.txt contiene 525577 datos.

Chiˆ2 = 0.000090
Los datos contenidos en el archivo Weibull.txt

parecen presentar distribucion Weibull.
Intervalo 0.0 -- 3.0 |||||||||||||||| (43297)

Intervalo 3.0 -- 5.9 ||||||||||||||||||||||||||||||| (89955)
Intervalo 5.9 -- 8.9 |||||||||||||||||||||||||||||||||||| (104295) [Max]
Intervalo 8.9 -- 11.9 ||||||||||||||||||||||||||||||||| (95096)
Intervalo 11.9 -- 14.8 |||||||||||||||||||||||||| (74286)
Intervalo 14.8 -- 17.8 |||||||||||||||||| (51380)
Intervalo 17.8 -- 20.8 |||||||||||| (32011)
Intervalo 20.8 -- 23.7 ||||||| (17941)
Intervalo 23.7 -- 26.7 |||| (9467)
Intervalo 26.7 -- 29.7 ||| (4486)
Intervalo 29.7 -- 32.7 || (2029)
Intervalo 32.7 -- 35.6 | (871)
Intervalo 35.6 -- 38.6 | (285)
Intervalo 38.6 -- 41.6 | (107)
Intervalo 41.6 -- 44.5 | (54) [Min]
Otro ejemplo, donde los datos NO presentan distribución Weibull...

Valor del parametro C: 11.86

Valor del parametro K: 1.77

Chiˆ2 = 1.659585
Intervalo 0.0 -- 0.2 |||||||||||||||||||||||||||||||||||| (98) [Max]

Intervalo 0.2 -- 0.4 ||||||||||||||||||||||||| (68)
Intervalo 0.4 -- 0.5 |||||||||||||| (35)

en C++
Intervalo 0.5 -- 0.7 ||||||||| (23)

Intervalo 0.7 -- 0.9 ||||| (10)
Intervalo 0.9 -- 1.1 ||| (5)
Intervalo 1.1 -- 1.3 || (2)
Intervalo 1.3 -- 1.4 | (1)
Intervalo 1.4 -- 1.6 || (2)
Intervalo 1.6 -- 1.8 || (2)
Intervalo 1.8 -- 2.0 | (1)
Intervalo 2.0 -- 2.2 | (1)
Intervalo 2.2 -- 2.3 | (0) [Min]
Intervalo 2.3 -- 2.5 | (0) [Min]
Intervalo 2.5 -- 2.7 | (1)
2.8.1.15 PchiRayleigh(archivo, Num Int, media)
Función 2.8.15
void PchiRayleigh(char filename[], int Num Int, float Media)
Descripción: Esta función prueba que los datos contenidos en el archivo de
nombre filename presenten una distribución exponencial con parámetro λ. De-
vuelve el número de datos leidos del archivo, la media de esos datos el valor de
χ2 .
3 int main(void){
5 float mean; // intervalo para generar uniformes
11 printf("\nMedia de la distribución: ");
13 PchiRayleigh(archivo, 15, mean);
17 system("PAUSE");
18 return 0;
19 }

Nombre del archivo: [Incluye extension] Rayleigh.txt
El archivo Rayleigh.txt contiene 1000 datos.


en C++
162 Códigos
Chiˆ2 = 0.541957
Intervalo 0.2 -- 2.6 ||||||| (28)

Intervalo 2.6 -- 5.0 ||||||||||||||||||| (87)
Intervalo 5.0 -- 7.4 ||||||||||||||||||||||||||||| (136)
Intervalo 7.4 -- 9.8 |||||||||||||||||||||||||||||||||||| (172) [Max]
Intervalo 9.8 -- 12.2 |||||||||||||||||||||||||||||| (142)
Intervalo 12.2 -- 14.5 ||||||||||||||||||||||||| (119)
Intervalo 14.5 -- 16.9 ||||||||||||||||||| (89)
Intervalo 16.9 -- 19.3 ||||||||||||||||||| (89)
Intervalo 19.3 -- 21.7 |||||||||||| (53)
Intervalo 21.7 -- 24.1 |||||||||| (43)
Intervalo 24.1 -- 26.5 |||| (17)
Intervalo 26.5 -- 28.8 || (7)
Intervalo 28.8 -- 31.2 || (7)
Intervalo 31.2 -- 33.6 || (5) [Min]
Intervalo 33.6 -- 36.0 || (5) [Min]
2.8.1.16 RL(archivo)
Función 2.8.16
void RL(char filename[])
Descripción: Esta función calcula la recta de mejor ajuste a los datos con-
tenidos en el archivo filename.
3 int main(void){
7 RL(archivo);
8 system("PAUSE");
9 return 0;
10 }
La recta de mejor ajuste es:

y = 1.712 + 0.719 x.

en C++
2.8.1.17 RC(archivo)
Función 2.8.17
void RC(char filename[])
Descripción: Esta función calcula la parábola de mejor ajuste a los datos
contenidos en el archivo filename.
3 int main(void){
7 RC(archivo);
8 system("PAUSE");
9 return 0;
10 }
La parabola de mejor ajuste es:

y = -0.045 xˆ2 + 1.454 x + 0.933
Para las dos funciones anteriores, se utilizó el archivo test.txt que contiene la
siguiente información:
# Este archivo contiene 50 números

# pseudoaletorios con distribucion normal
# con media = 12.000 y desviacion estándar = 5.000.
28.840973
8.729749
6.863858
6.250802
11.933395
6.088670
7.881029
4.318137
19.204657
7.066312
11.284149
1.689564
23.058068
6.932590
8.060572
16.921389
15.777704
21.330462
13.134103
10.166203
11.624262
13.341073
15.478254

en C++
164 Códigos
11.428067
12.683624
13.958144
12.400598
8.131033
14.381212
14.918339
6.156746
16.142108
-1.425609
13.150411
10.138522
11.561960
10.334757
8.227782
6.067277
14.986136
8.198230
8.960726
8.599253
10.486869
9.866934
17.731067
9.864873
17.186035
6.512353
7.776886
# Fin del archivo...

en C++
2.8.2 Otras funciones
Las siguientes son funciones que están incluidas en el archivo estadistica.h.

Las funciones antes mencionadas utilizan las funciones definidas en esta sección
para generar números pseudoaleatorios con distibuciones dadas conocidos sus
parámetros (en caso de que se requiera indicar).
2.8.2.1 uniforme()
Función 2.8.18
double uniforme(void)
Descripción: Esta función genera un número pseudoaleatorio con distribución
uniforme en el intervalo (0, 1).
3 int main(void){
8 for(i = 1 ; i <= total ; i++){
9 printf("\n %i,\t %f", i, uniforme()); //
10 }
12 system("PAUSE");
13 return 0;
14 }
1, 0.001251
2, 0.563585
3, 0.193304
4, 0.808741
5, 0.585009
6, 0.479873
7, 0.350291
8, 0.895962
9, 0.822840
10, 0.746605
11, 0.174108
12, 0.858943
13, 0.710501
14, 0.513535
15, 0.303995

en C++
166 Códigos
2.8.2.2 uniforme(a,b)
Función 2.8.19
double uniforme(float a, float b)
Descripción: Esta función genera un número pseudo-aleatorio con distribución
uniforme en el intervalo (a, b).
3 int main(void){
5 float A, B; // intervalo para generar uniformes
9 printf("\n\nLimite inferior de la distribucion: ");
10 scanf("%f", &A);
11 printf("\n\nLimite superior de la distribucion: ");
12 scanf("%f", &B);
13 for(i = 1 ; i <= total ; i++){
14 printf("\n %i,\t %f", i, uniforme(A,B)); //
15 }
17 system("PAUSE");
18 return 0;
19 }
Limite inferior de la distribucion: -100

Limite superior de la distribucion: 100
1, -99.749748
2, 12.717063
3, -61.339152
4, 61.748100
5, 17.001862
6, -4.025391
7, -29.941710
8, 79.192480
9, 64.568010
10, 49.320963
11, -65.178381
12, 71.788690
13, 42.100284
14, 2.706992
15, -39.201025
16, -97.003082
17, -81.719413
18, -27.109592
19, -70.537431
20, -66.820276
21, 97.705008
22, -10.861538
23, -76.183355
24, -99.066134
25, -98.217719

en C++
2.8.2.3 weibull(c,k)
Función 2.8.20
double weibull(double c, double k)
Descripción: Esta función genera números pseudoaleatorios con distribución
Weibull. Los parámetros c y k corresponden a la forma y escala de la dis-
tribución, respectivamente.
3 int main(void){
5 float C, K; // intervalo para generar uniformes
9 printf("\n\nParametro C de la distribucion: ");
10 scanf("%f", &C);
11 printf("\n\nParametro K de la distribucion: ");
12 scanf("%f", &K);
13 for(i = 1 ; i <= total ; i++){
14 printf("\n %i,\t %f", i, weibull(C,K)); //
15 }
17 system("PAUSE");
18 return 0;
19 }

1, 0.271845
2, 10.668868
3, 4.974081
4, 15.760481
5, 11.030096
6, 9.327647
7, 7.374055
8, 18.813593
9, 16.168644
10, 14.185015
11, 4.658680
12, 17.339041
13, 13.390201
14, 9.855590
15, 6.684013
16, 1.109751
17, 3.152986
18, 7.584638
19, 4.201994
20, 4.521017
21, 27.628521
22, 8.803132
23, 3.692812
24, 0.572603
25, 0.825961

en C++
168 Códigos
2.8.2.4 rayleigh(media)
Función 2.8.21
double rayleigh(float media)
Rayleigh con media media.
2
4 int main(void){
5 float mean; // parametro de la distribucion
6 int total, i;
8 printf("\nfloat rayleigh(float media)");
10 printf("Cuantos numeros deseas generar? ");
12 printf("\nMedia de la distribucion: ");
14 for(i = 1 ; i <= total ; i++){
15 printf("\nGenerado: %f", rayleigh(mean));
16 }
18 system("PAUSE");
19 return 0;
20 }

float rayleign(float media)
Cuantos numeros deseas generar? 25
Generado: 35.005940
Generado: 10.253663
Generado: 17.358807
Generado: 6.238612
Generado: 9.914491
Generado: 11.602552
Generado: 13.868260
Generado: 4.487969
Generado: 5.979245
Generado: 7.319658
Generado: 17.902631
Generado: 5.279985
Generado: 7.916121
Generado: 11.053911
Generado: 14.775617
Generado: 27.752294
Generado: 20.944032
Generado: 13.603776
Generado: 18.738855
Generado: 18.148271
Generado: 1.454668
Generado: 12.172394
Generado: 19.752192
Generado: 31.368345

en C++
Generado: 29.418927
2.8.2.5 normal()
Función 2.8.22
double normal(void)
uniforme con media = 0.0 y desviacionStd = 1.0, es decir, distribución normal
estandarizada.
3 int main(void){
8
9 for(i = 1 ; i <= total ; i++){
10 printf("\n %i,\t %f", i, normal()); //
11 }
13 system("PAUSE");
14 return 0;
15 }
1, 3.368195
2, -0.654050
3, -1.027228
4, -1.149840
5, -0.013321
6, -1.182266
7, -0.823794
8, -1.536373
9, 1.440931
10, -0.986738
11, -0.143170
12, -2.062087
13, 2.211614
14, -1.013482
15, -0.787886
16, 0.984278
17, 0.755541
18, 1.866092
19, 0.226821
20, -0.366759
21, -0.075148
22, 0.268215
23, 0.695651
24, -0.114387

en C++
170 Códigos
25, 0.136725
2.8.2.6 normal(media, desviacionStd)
Función 2.8.23
double normal(double media, double desviacionStd)
uniforme con media media y desviación estándar desviacionStd, definidas por
el usuario.
3 int main(void){
5 float mean, SD; // intervalo para generar uniformes
11 printf("\n\nDesviacion estandar de la distribucion: ");
12 scanf("%f", &SD);
13
14 for(i = 1 ; i <= total ; i++){
15 printf("\n %i,\t %f", i, normal(mean, SD)); //
17 system("PAUSE");
18 return 0;
19 }

Desviacion estandar de la distribucion: 12
1, 140.418334
2, 92.151398
3, 87.673259
4, 86.201924
5, 99.840149
6, 85.812808
7, 90.114470
8, 81.563529
9, 117.291178
10, 88.159150
11, 98.281958
12, 75.254955
13, 126.539363
14, 87.838215
15, 90.545373
16, 111.811334
17, 109.066489
18, 122.393108

en C++
19, 102.721846
20, 95.598887
2.8.2.7 exponencial(lambda)
Función 2.8.24
float exponencial(float lambda)
exponencial y parámetro lambda definido por el usuario.
3 int main(void){
6 float L; // Parametro de la distribucion
9 printf("\n\nParametro lambda de la distribucion: ");
10 scanf("%f", &L);
11 for(i = 1 ; i <= total ; i++){
12 printf("\n %i,\t %f", i, exponencial(L)); //
13 }
15 system("PAUSE");
16 return 0;
17 }
1, 0.002504
2, 1.658325
3, 0.429617
4, 3.308248
5, 1.758998
6, 1.307365
7, 0.862463
8, 4.526006
9, 3.461405
10, 2.745610
11, 0.382583
12, 3.917189
13, 2.479210
14, 1.441180
15, 0.724797
16, 0.030196
17, 0.191707
18, 0.906535
19, 0.318725
20, 0.362801
21, 8.935176
22, 1.180071

en C++
172 Códigos
23, 0.253584
24, 0.009361
25, 0.017903
2.8.2.8 geometrica(p)
Función 2.8.25
int geometrica(float p)
geometrica de parámetro p.
2
4 int main(void){
5 float p; // parametro de la distribucion
6 int total, i;
8 printf("\nint geometrica(float p)");
12 printf("\nParametro p supuesto: ");
13 scanf("%f", &p);
14 for(i = 1 ; i <= total ; i++){
15 printf("\nGenerado: %i", geometrica(p));
16 }
18 system("PAUSE");
19 return 0;
20 }

int geometrica(float p)
Parametro p supuesto: 0.25
Generado: 0
Generado: 2
Generado: 0
Generado: 5
Generado: 2
Generado: 1
Generado: 0
Generado: 7
Generado: 5
Generado: 4
Generado: 0
Generado: 6
Generado: 3
Generado: 2
Generado: 0
Generado: 0

en C++
Generado: 0
Generado: 1
Generado: 0
Generado: 0
Generado: 15
Generado: 1
Generado: 0
Generado: 0
Generado: 0
2.8.2.9 poisson(alpha)
Función 2.8.26
int poisson(float alpha)
Poisson de parámetro α.
2
4 int main(void){
5 float a; // parametro de la distribucion
6 int total, i;
8 printf("\nint poisson(float alpha)");
12 printf("\nParametro Alpha supuesto: ");
13 scanf("%f", &a);
14 for(i = 1 ; i <= 25 ; i++){
15 printf("\nGenerado: %i", poisson(a));
16 }
18 system("PAUSE");
19 return 0;
20 }

int poisson(float alpha)
Parametro Alpha supuesto: 3
Generado: 1
Generado: 598
Generado: 593
Generado: 579
Generado: 655
Generado: 585
Generado: 611
Generado: 604

en C++
174 Códigos
Generado: 637
Generado: 606
Generado: 616
Generado: 592
Generado: 622
Generado: 628
Generado: 587
Generado: 565
Generado: 618
Generado: 592
Generado: 613
Generado: 616
Generado: 621
Generado: 610
Generado: 612
Generado: 640
Generado: 581
2.8.2.10 media(archivo), desviacionStd(archivo)
Función 2.8.27
double media(char filename[])
Descripción: Esta función calcula la media aritmética de los datos contenidos
en el archivo de nombre filename.
Función 2.8.28
double desviacionStd(char filename[])
Descripción: Esta función calcula la desviación estándar de los datos con-
tenidos en el archivo de nombre filename.
3 int main(void){
7 histograma(archivo, 20);
11 system("PAUSE");
12 return 0;
13 }
Intervalo 103.8 -- 118.5 | (4) [Min]

Intervalo 118.5 -- 133.2 | (39)
Intervalo 133.2 -- 147.9 | (126)
Intervalo 147.9 -- 162.6 || (458)

en C++
Intervalo 162.6 -- 177.3 |||| (1210)

Intervalo 177.3 -- 192.1 ||||||| (3011)
Intervalo 192.1 -- 206.8 |||||||||||||| (5881)
Intervalo 206.8 -- 221.5 |||||||||||||||||||||| (9987)
Intervalo 221.5 -- 236.2 ||||||||||||||||||||||||||||||| (13892)
Intervalo 236.2 -- 250.9 |||||||||||||||||||||||||||||||||||| (16299) [Max]
Intervalo 250.9 -- 265.6 |||||||||||||||||||||||||||||||||||| (16221)
Intervalo 265.6 -- 280.3 |||||||||||||||||||||||||||||| (13426)
Intervalo 280.3 -- 295.0 ||||||||||||||||||||| (9513)
Intervalo 295.0 -- 309.8 ||||||||||||| (5625)
Intervalo 309.8 -- 324.5 ||||||| (2636)
Intervalo 324.5 -- 339.2 ||| (1117)
Intervalo 339.2 -- 353.9 || (404)
Intervalo 353.9 -- 368.6 | (110)
Intervalo 368.6 -- 383.3 | (29)
Intervalo 383.3 -- 398.0 | (10)

Presione una tecla para continuar...

en C++
176 Códigos
2.8.3 Simulación del recurso eólico
Este es el proyecto que elegı́ para la materia Simulación de Sistemas en mis

cursos.
Puedes ver las notas de este curso en mi página de Internet4 .
2.8.3.1 Energı́a extraida del viento
Un generador eólico utiliza la energı́a cinética del viento para generar electrici-
dad.
Lo que pasa en realidad es que la energı́a del viento es transferida a un rotor

que tiene dos o más aspas acopladas mecánicamente al generador eléctrico.
La enegı́a cinética que contienen m kilogramos de viento que se mueve a veloci-

dad v [m/s] es:
1
Ek = mv 2
2
Sin embargo, generalmente no conocemos la masa de aire que atravesarán las
aspas del generador eólico, ası́ que es una mejor idea expresarlo con términos
de la densidad y la velocidad del viento.
Por definición, la densidad ρ del viento es igual al cociente de su masa al volu-

men. De donde, m = ρ · V .
Podemos ver el volumen de aire que atraviesan las aspas del generador eólico
como el cilindro de altura v · t y área de base igual al área A [m2 ] que barren las
aspas del generador. Entonces, por unidad de tiempo, el volumen de aire que
atraviesan las aspas del generador eólico es:
V =A·v Flujo volumétrico (m3 /s)
Ası́ que la energı́a cinética del viento con velocidad v puede expresarse como:
1
P = ρAv 3 potencia (W)
2
El recurso eólico de dos sitios distintos se compara en base a la potencia eólica
especı́fica, es decir, por cada metro cuadrado de área que barren sus aspas.
Sabemos que la potencia eólica especı́fica varı́a con el cubo de la velocidad del
viento.
4 Puede accesar a mi página de Internet en: http://yalma.fime.uanl.mx/˜ efrain/
Para encontrar las notas vaya a Descargas, después a Notas de mis Cursos, y finalmente a Mis
Notas

en C++
√
Considerando que 3 2 ≈ 1.2599, podemos darnos cuenta que cuando la velocidad
del viento aumenta en un 25.99% la potencia generada crece al doble. Por otra
parte, si la velocidad del viento disminuye el mismo porcentaje, la potencia
generada disminuye a la mitad.
√
También, 3 3 ≈ 1.4422 nos indica que si la velocidad del viento crece un 44.22%,
la potencia eléctrica generada aumentará al triple, mientras que si la velocidad
del viento disminuye en esa misma cantidad, la potencia generada disminuirá a
la tercera parte.
He aquı́ la importancia de caracterizar la distribución de la velocidad del viento

para poder determinar correctamente la potencia generada en un sitio especı́fico.
La energı́a extraida del viento es igual a la diferencia de la energı́a cinética del

viento que atraviesa el generador antes y después de pasar a través de él:
1
P0 = · ṁ · (v 2 − v02 )
2
donde P0 es la potencia [W] absorvida por el generador, ṁ es el flujo másico
[kg/s], v es la velocidad del viento [m/s] al entrar al generador y v0 es la velocidad
del viento [m/s] después de atravesar el generador.
La velocidad del viento es discontinua de v a v0 en el plano de las aspas del gen-

erador. El flujo másico del viento a través de las aspas se calcula multiplicando
la densidad por la velocidad promedio:

v + v0
ṁ = ρ · A ·
2
La potencia mecánica que mueve al rotor, que mueve finalmente al generador
eléctrico es:
1 v + v0
P0 = ρA · · (v 2 − v02 )
2 2
Esta expresión puede reescribirse como:
v 2
v0 0
1+ 1−
1 v v
P0 = ρ A · v 3
2 2
Podemos definir: v 2
v0 0
1+ 1−
v v
Cp =
2
que representa la fracción del viento que “aprovechan” las aspas del generador
eólico.
Para velocidades de entrada del viento a las aspas del generador eólico, los
valores de Cp dependen de la proporción v0 /v, alcanzando un máximo cuando
este cociente es igual a 1/3. Entonces, Cp = 16/27 ≈ 0.5926.

en C++
178 Códigos
La máxima potencia transmitida a las aspas ocurrirá cuando v = 3 v0 , o bien,

cuando Cp = 0.5926. Entonces,
1
P0 = ρ A · v 3 · (0.59)
2
En diseños prácticos de aspas, el valor máximo alcanzado es de aproximada-
mente 0.5 para turbinas de alta velocidad que trabajan con dos aspas, y entre
0.2 y 0.4 para turbinas de baja velocidad con más aspas.
Considerando Cp = 0.5 obtenemos una expresión más simple:

1
P0 = ρ A · v3
4
2.8.4 Distribución del viento
Dato que el viento se origina con las diferencias de densidad en el aire debido
a los cambios de temperatura que el sol ocasiona en el aire atmosférico, con
la colaboración del movimiento rotativo de la tierra, los patrones de viento
generalmente se repiten con periodicidad de un año.
Dado que la potencia generada con un generador eólico es proporcional al cubo

de la velocidad del viento, su distribución se convierte en la medición más im-
portante para determinar la cantidad de energı́a que un sitio considerado.
El comportamiento de la velocidad del viento nunca es estable. Depende de

muchos factores, entre el clima, la topografı́a del lugar y la altura en la que se
mide a partir del suelo.
La velocidad del viento cambia continuamente, por lo que la velocidad promedio

debe basarse en mediciones de al menos una década. De esta manera tendremos
mayor confianza en el valor asignado al sitio. Sin embargo, medir la velocidad
del viento por 10 años requiere de una inversión grande además de que un
proyecto generalmente no puede esperar tanto. En los casos en que se tienen
poca información, se mide la velocidad del viento y ésta se compara con la
velocidad medida en otro sitio cercano y a partir de estas consideraciones se
realiza una estimación del promedio anual del sitio considerado.
Las variaciones de la velocidad del viento se pueden describir por una función
de distribución de probabilidad.
2.8.4.1 Distribución Weibull
La distribución de la velocidad del viento en una localidad puede descibirse

utilizando al distribución Weibull con el parámetro k de forma y el parámetro
c de escala.

en C++
La probabilidad de que la velocidad de viento sea de v m/s durante algún

intervalo de tiempo dado es:

k v k−1 −(v/c)k
h(v) = e para 0 < v < ∞
c c
En la gráfica de distribución de probabilidad se grafica h vs. v para distintos
intervalos de tiempo, donde:
Fracción de tiempo en que la velocidad del viento está entre v y v + ∆v
h=
∆v
Por definición de la función de probabilidad, la probabilidad de que la velocidad
del viento esté entre cero e infinito en ese periodo de tiempo es igual a uno:
Z∞
h dv = 1
0
Si elegimos el periodo de tiempo igual a un año, y expresamos la integral en

términos del número de horas en un año, entonces tenemos:
Número de horas que la velocidad del viento está entre v y v + ∆v
h=
∆v
Las unidades de h son horas por año por metros por segundo, y la integral se
convierte en 8 760, el número total de horas en el año, en lugar de la unidad.
Para la distribución Weibull con valor de k = 1 tenemos la distribución expo-

nencial. En el caso k = 2 la distribución se conoce como distribución Rayleigh.
Este tipo de distribución es el que presenta la velocidad de viento en muchos
sitios.
2.8.4.2 Distribución Rayleigh
• Distribución Rayleigh:
2
2 αxe−αx para x > 0
f (x) =
0 para x ≤ 0
donde: α > 0
2u u 2
Φ(u) = 2
exp −
c c
Para esta distribución:
r
1 π
µ =
2 α
1 π
σ2 = 1−
α 4

en C++
180 Códigos
2.8.4.3 Distribución de energı́a
Si definimos la función de densidad de energı́a como:
Contribución en kWh al año por las velocidades entre v y v + ∆v

e=
∆v
podremos graficar esta distribución y la distribución de probabilidad de la ve-
locidad y conocer a partir de qué velocidad el número de horas que el viento
presenta esa velocidad, decrece más rápido que v 3 . Este valor nos indicará un
decremento neto en la contribución energética anual global.
2.8.4.4 Anemómetros digitales
La velocidad promedio de un sitio en un periodo de tiempo se calcula sumando

muchas lecturas en ese periodo de tiempo entre el número de lecturas. La
mayorı́a de los anemómetros se instalaban con el propósito de medir la velocidad
del viento y no con propósitos de la medición del recurso energético. Ası́ que el
promedio calculado como se indicó se realizaba de manera semejante para una
hora, un dı́a y para un año:
n
1X
v̄ = vi
n i=1
Pero para estimar el recurso eólico disponible en un lugar necesitamos calcular:

v
u n
u1 X 3
3
vrmc = t v
n i=1 i
La expresión anterior no toma en cuenta la densidad del aire, que también afecta
la cantidad de energı́a producida por el viento. Para calcular el recurso eólico
de un sitio se recomienda utilizar la siguiente fórmula:
n
1 X
Prmc = ρi vi3
2 n i=1
donde n es el número de mediciones realizadas, ρi es la densidad del aire [kg/m3 ]

en el momento de realizar la i-ésima medición y vi es la velocidad del viento
[m/s] en la i-ésima medición, y Prmc representa la densidad de energı́a promedio.
2.8.4.5 Predicción del recurso eólico
La energı́a que podemos aprovechar del viento depende de su velocidad, la cual

es una variable aleatoria. Para el operador de la granja eólica esto representa

en C++
una dificultad para designar el despacho de energı́a a la red, además de que no

se conoce la cantidad de energı́a disponible con anticipación.
Sin embargo, si la velocidad del viento puede pronosticarse con varias horas
de anticipación, podemos despachar la energı́a de una manera cómoda. Alexi-
adis, et al5 , han propuesto una nueva técnica para pronosticar la velocidad del
viento y la cantidad de energı́a producida con muchas horas de anticipación. La
técnica está basada en correlación cruzada en sitios vecinos y redes artificiales
neuronales. La técnica propuesta puede mejorar significativamente la precisión
de las predicciones comparado con el modelo comúnmente usado. El modelo
propuesto se calibra en diferentes sitios en un periodo de un año.
2.8.5 Un caso especı́fico

• La Venta, Oaxaca. México6 .
– El viento presenta Distribución Weibull.

– Velocidad promedio del viento: 9.3 m/s.
– k = 1.77, c = 11.86 m/s a una altura de 32 metros.
– k = 1.73, c = 10.44 m/s a una altura de 15 metros.
2.8.6 Implementación
Enseguida se muestra el código de la implementación elaborada en el lenguaje

C++ .
/* Nombre del archivo: windFinal.cpp

Este programa simula la velocidad de viento de
una localidad de acuerdo a la distribución que
se especifique.
Calcula además, la densidad de recurso eólico
local (Watts/metro cuadrado) y en el caso de
la distribución Weibull, calcula la velocidad
de viento promedio como media ponderada de la
velocidad media de cada intervalo por la
probabilidad de que el viento presente esa
velocidad.
----------------------------------
----------------------------------
Fecha de última Modificación: 01 de mayo de 2008
5 Alexiadis, M. C., Dokopoulos, P. S., and Sahsamanogdou, H. S. 1998. Wind Speed and
Power Forecasting Based on Spatial Correlation Models, IEEE Paper No. PE-437-EC-0-04-
1998.
6 Fuente: Evaluación del recurso eólico de La Venta, Juchitán, Oaxaca. M. A. Borja, O. A.
Jaramillo, M. F. Morales. Instituto de Investigaciones Eléctricas. Temixco, Morelos, México.

en C++
182 Códigos
----------------------------------
----------------------------------
*/
#include <cstdio> // Librerı́a básica...
#include <cstdlib> // Otra Librerı́a...
#include <iostream> // Funciones básicas: input/output
//
double uniforme (void);
double weibull(double c, double k);
//
void duniforme(void);
void drayleigh(void);
void dweibull(void);
float windPower(double windSpeed);

int main(void){
char respuesta, semilla;
int i = 0;
int continuar;
char distribucion;
//continuar = 0;
cout << "Este programa simula el Recurso Eolico";
cout << "\nde un sitio dados los parametros de su distribucion.";
for (;;){ // hasta que presione S ó N
cout << "\n\nDesea iniciar la semilla del aleatorio? [S/N] ";
cin >> semilla;
if (semilla == ’S’ || semilla == ’s’){
srand(time(0));
cout << "Se reinicia la semilla...";
}
if (semilla == ’N’ || semilla == ’n’){
cout << "No se reinicia la semilla...";
}
} // end for infinito para la semilla
cout << "\n\nSeleccione la distribucion estadistica ";
cout << "\nque presenta el viento de la localidad: ";
cout << "\n[R] Rayleigh.";
cout << "\n[W] Weibull.";
cout << "\n[C] Cancelar...";
cout << "\nIngrese una opcion: ";
cin >> distribucion;
switch (distribucion){
case ’R’:
drayleigh();
break;
case ’r’:
drayleigh();
break;
case ’W’:
dweibull();
break;
case ’w’:
dweibull();
break;
case ’C’:
break;
case ’c’:
break;
default:

en C++
cout << "\nPor favor, intente de nuevo...";

continuar = 1;
} // end switch
if (continuar == 0){
// se debe salir...
break;
}
cout << "\n\nPresione < S > para salir... < C > para continuar...";
}
cout << "\n\n\n";
return 0;
}
/**************************************
Declaro la función UNIFORME...
***************************************/
double uniforme(void){
// Esta función genera un número pseudoaleatorio
// en el intervalo (0,1) con distribución uniforme.
return (1.0 * rand()/(1.0 * RAND_MAX));
}
/**************************************
Declaro la función WEIBULL...
***************************************/
double weibull(double c, double k){
// Esta función genera números pseudoaleatorios
// con distribución Weibull
double x;
x = c * pow(-log(1 - uniforme()), 1/k);
return x;
}
/**************************************
Declaro la función RAYLEIGH...
***************************************/
double rayleigh(double media){
// Esta función genera números pseudoaleatorios
// con distribución rayleigh
// Fuente:
// http://www.brighton-webs.co.uk/distributions/rayleigh.asp
double factor, r;
factor = media / 1.253314;
r = sqrt(-2 * factor * factor * log(uniforme()));
return r;
}
/**************************************
Declaro la función DWEIBULL..
***************************************/
void dweibull(void){
/*
Para simular viento con distribución Weibull...
*/
int I[24]; // los intervalos...
int max =0, min = 1000000;
//int total; // cuántos vamos a generar...
int i = 0, j; // contadores
double x; // el número generado...
double escala; // para hacer la gráfica...
int factor; // para hacer la gráfica...
//double k = 0.0, c = 1.0; // parámetros

en C++
184 Códigos
double c, k; // parámetros alpha y beta

double t; // tiempo
float velocidadProm = 0; // Velocidad Promedio
float sv3 = 0;// suma de cubo de velocidad
float densidadEnergetica;
float energia = 0; // Energia anual
//
cout << "\nValor del parametro c: ";
cin >> c; // alpha
cout << "Valor del parametro k: ";
cin >> k; // beta
t = 0; // reinicio el tiempo del experimento...
FILE* f = fopen("speedwei.txt", "w+");
// limpio la memoria del array...
for (i = 0 ; i <= 24 ; i++){
I[i] = 0;
}
for (t = 0; t < 8760; t++){
x = weibull(c, k);// Genero un pseudoaleatorio
fprintf(f, "%f\n", x); // grabo en archivo...
sv3 += pow(x, 3.0) / 4.0;
energia += windPower(x);
for (i = 0 ; i <= 24 ; i++){
if ((x > 0.1 * i * c) && (x <= 0.1 * (i + 1) *c)){
I[i]++;
break;
}
}
}
fclose(f);
// Calculo la velocidad promedio...
for (i = 0 ; i <= 24 ; i++){
velocidadProm += 1.0 * I[i] * c / 8760;
}
velocidadProm = velocidadProm * 465 / 593; // factor de escala...
// Encuentro el intervalo con mayor número de ocurrencias
for (i = 0; i <= 24 ; i++){
if (I[i] > max){
max = I[i];
}
if (I[i] < min){
min = I[i];
}
}
for (i = 0 ; i <= 24 ; i++){
printf("\n%.2f m/s -- %.2f m/s ", (0.1*i*velocidadProm),
(0.1*(i+1)*velocidadProm));
escala = 35.0 * I[i] / max;
factor = (int)(escala + 0.5); // redondeo
// Imprime la barra del intervalo (i-1)
for (j = 0 ; j <= factor ; j++){
cout << "|";
} // termina de imprimir la barra...
if (I[i] == max){
cout << " (" << I[i] << ") [Maximo]";
continue;
}
if (I[i] == min){
cout << " (" << I[i] << ") [Minimo]";
continue;
}
cout << " (" << I[i] << ")";
}
printf("\n\nVelocidad Promedio del viento: %.2f m/s.", velocidadProm);
// calculo recurso energético...
densidadEnergetica = sv3 / (2 * 8760);
printf("\nDensidad energetica promedio: %.3f W/mˆ2", densidadEnergetica);
printf("\nEnergia anual estimada: %.2f W-hr/mˆ2.", energia);

en C++
return;
} // Fin de la función DWEIBULL
/**************************************
Declaro la función DRAYLEIGH..
***************************************/
void drayleigh(void){
int I[24]; // los intervalos...
int max =0, min = 1000000;
int total; // cuántos vamos a generar...
int i, j; // contadores
int imax, imin;
double t;
double x; // el número generado...
float sv3 = 0.0;
float densidadEnergetica;
float energia = 0; // Energia anual
float media; // parámetro de la distribución
double escala; // para hacer la gráfica...
int factor; // para hacer la gráfica...
FILE* f = fopen("speedray.txt", "w+");
for(;;){// hasta que indique el valor de lambda

cout << "\nIntroduzca la velocidad media del viento: ";
scanf("%f", &media);
if (media <= 0.0){
cout << "\n\nEl valor debe ser positivo...";
cout << "\nPor favor intente de nuevo...\n";
continue;
}
break;
}
// limpio la memoria del array...
for (i = 0 ; i <= 24 ; i++){
I[i] = 0;
}
for (t = 0; t < 8760; t++){
x = rayleigh(media);// Genero un pseudoaleatorio
x = x * 593 / 465;
fprintf(f, "%f\n", x); // grabo en archivo...
sv3 += pow(x, 3.0) / 4;
energia += windPower(x);
for(i = 0 ; i <= 24 ; i++){
if ((x > 0.1 * i * media) && (x <= 0.2 * (i + 1) * media)){
I[i]++;
break;
}
}
}
fclose(f);
// Encuentro el intervalo con mayor número de ocurrencias
for (i = 0; i <= 24 ; i++){
if (I[i] > max){
max = I[i];
imax = i;
}
if (I[i] < min){
min = I[i];
imin = i;
}
}
// Ahora imprimo los resultados...
for (i = 0 ; i <= 24 ; i++){
printf("\n%.2f m/s -- %.2f m/s ", (0.1*i*media), (0.1*(i+1)*media));
escala = 35.0 * I[i] / max;
factor = (int)(escala + 0.5); // redondeo
// Imprime la barra del intervalo (i-1)
for (j = 0 ; j <= factor ; j++){

en C++
186 Códigos
cout << "|";

} // termina de imprimir la barra...
if (I[i] == max){
cout << " (" << I[i] << ") [Maximo]";
continue;
}
if (I[i] == min){
cout << " (" << I[i] << ") [Minimo]";
continue;
}
cout << " (" << I[i] << ")";
}
// calculo recurso energético...
densidadEnergetica = sv3 / (2 * 8760);
printf("\n\nDensidad energetica promedio: %.3f W/mˆ2", densidadEnergetica);
printf("\nEnergia anual estimada: %.2f W-hr/mˆ2.", energia);
return;
} // Fin de la función DRAYLEIGH
/**************************************
Declaro la función WINDPOWER..
***************************************/
float windPower(double windSpeed){
/*
Esta función calcula la energı́a producida por el generador
considerando la el teorema de Welt’z, Densidad del aire = 1,000 kg/mˆ3,
Area de rotor = 1 mˆ2, v ---> generada por el programa,
windspeed (con distribución dada)
*/
double rho = 1.00; // densidad del aire
double potencia; // Potencia generada
double eficiencia = 0.15; // eficiencia del generador
double weltz = 0.59; // factor de terorema de Weltz
potencia = eficiencia * rho * weltz * pow(windSpeed,3);
return potencia;
}s
2.8.7 Resultados de la simulación
Se consideraron los siguientes datos:
• Velocidad promedio del viento: 9.3 m/s.
• k = 1.77, c = 11.86 m/s.
que corresponden a La Venta, Oaxaca. Los parámetros de la distribución

Weibull están calculados a partir de mediciones de velocidad de viento real-
izadas a 53 metros de altura (respecto del suelo).
Este programa simula el Recurso Eolico

de un sitio dados los parametros de su distribucion.
Desea iniciar la semilla del aleatorio? [S/N] s

Se reinicia la semilla...
Seleccione la distribucion estadistica

que presenta el viento de la localidad:

en C++
[R] Rayleigh.
[W] Weibull.
[C] Cancelar...
Ingrese una opcion: w
Valor del parametro c: 11.86

Valor del parametro k: 1.77
0.00 m/s -- 0.93 m/s ||||||||| (168)

0.93 m/s -- 1.85 m/s ||||||||||||||||||| (366)
1.85 m/s -- 2.78 m/s ||||||||||||||||||||||| (443)
2.78 m/s -- 3.70 m/s |||||||||||||||||||||||||||||||| (609)
3.70 m/s -- 4.63 m/s |||||||||||||||||||||||||||||||||||| (693) [Maximo]
4.63 m/s -- 5.55 m/s ||||||||||||||||||||||||||||||||||| (674)
5.55 m/s -- 6.48 m/s |||||||||||||||||||||||||||||||||||| (684)
6.48 m/s -- 7.40 m/s |||||||||||||||||||||||||||||||||| (652)
7.40 m/s -- 8.33 m/s ||||||||||||||||||||||||||||||||||| (681)
8.33 m/s -- 9.25 m/s ||||||||||||||||||||||||||||||| (600)
9.25 m/s -- 10.18 m/s |||||||||||||||||||||||||||| (538)
10.18 m/s -- 11.10 m/s |||||||||||||||||||||||| (453)
11.10 m/s -- 12.03 m/s |||||||||||||||||||||| (420)
12.03 m/s -- 12.95 m/s ||||||||||||||||||| (363)
12.95 m/s -- 13.88 m/s ||||||||||||||| (287)
13.88 m/s -- 14.80 m/s |||||||||||||| (262)
14.80 m/s -- 15.73 m/s |||||||||| (180)
15.73 m/s -- 16.65 m/s |||||||||| (187)
16.65 m/s -- 17.58 m/s |||||||| (144)
17.58 m/s -- 18.50 m/s ||||| (85)
18.50 m/s -- 19.43 m/s ||||| (87)
19.43 m/s -- 20.35 m/s ||| (39)
20.35 m/s -- 21.28 m/s ||| (46)
21.28 m/s -- 22.21 m/s ||| (32)
22.21 m/s -- 23.13 m/s || (22) [Minimo]
Velocidad Promedio del viento: 9.25 m/s.

Densidad energetica promedio: 313.121 W/mˆ2
Energia anual estimada: 1942003.75 W-hr/mˆ2.
Presione < S > para salir... < C > para continuar...c
Este programa simula el Recurso Eolico

de un sitio dados los parametros de su distribucion.
Desea iniciar la semilla del aleatorio? [S/N] s

Se reinicia la semilla...
Seleccione la distribucion estadistica

que presenta el viento de la localidad:
[R] Rayleigh.
[W] Weibull.
[C] Cancelar...
Ingrese una opcion: r
Introduzca la velocidad media del viento: 9.3
0.00 m/s -- 0.93 m/s ||||||| (182)

0.93 m/s -- 1.86 m/s ||||||||||||||||| (496)
1.86 m/s -- 2.79 m/s ||||||||||||||||||||||||| (727)
2.79 m/s -- 3.72 m/s |||||||||||||||||||||||||||||| (895)
3.72 m/s -- 4.65 m/s |||||||||||||||||||||||||||||||||| (991)
4.65 m/s -- 5.58 m/s |||||||||||||||||||||||||||||||||||| (1064) [Maximo]
5.58 m/s -- 6.51 m/s |||||||||||||||||||||||||||||||| (950)
6.51 m/s -- 7.44 m/s |||||||||||||||||||||||||||||||| (937)
7.44 m/s -- 8.37 m/s ||||||||||||||||||||||||| (733)
8.37 m/s -- 9.30 m/s ||||||||||||||||||| (557)
9.30 m/s -- 10.23 m/s |||||||||||||| (399)
10.23 m/s -- 11.16 m/s |||||||||| (284)

en C++
188 Códigos
11.16 m/s -- 12.09 m/s |||||||| (222)

12.09 m/s -- 13.02 m/s |||||| (145)
13.02 m/s -- 13.95 m/s ||| (75)
13.95 m/s -- 14.88 m/s || (36)
14.88 m/s -- 15.81 m/s || (35)
15.81 m/s -- 16.74 m/s || (17)
16.74 m/s -- 17.67 m/s | (6)
17.67 m/s -- 18.60 m/s | (6)
18.60 m/s -- 19.53 m/s | (1)
19.53 m/s -- 20.46 m/s | (2)
20.46 m/s -- 21.39 m/s | (0) [Minimo]
21.39 m/s -- 22.32 m/s | (0) [Minimo]
22.32 m/s -- 23.25 m/s | (0) [Minimo]
Densidad energetica promedio: 395.494 W/mˆ2

Energia anual estimada: 2452892.00 W-hr/mˆ2.
Presione < S > para salir... < C > para continuar...
El número entre paréntesis a la derecha de cada intervalo indica la cantidad

de horas que se tuvieron velocidades de viento en ese intervalo en un año, con-
siderando que la distribución de probabilidad de esa variable aleatoria sigue la
distribución indicada.
Es de notar que la densidad energética varı́a al considerar distintas distribu-

ciones, a pesar de utilizar los datos de un sitio obtenidos a partir del mismo
estudio y realizar el cálculo de la densidad de recurso eólico local con la misma
metodologı́a.
Para la distribución Weibull se obtuvo una densidad energética de 315.558

W/m2 , mientras que para el caso de la distribuión Rayleigh se obtuvo un valor
correspondiente de 403.202 W/m2 . El primer caso siendo un 78.26% de la se-
gunda estimación.
También es importante indicar que no se calcula la densidad de recurso eólico

a partir de la velocidad promedio estimada, sino con las velocidades de viento,
conforme se van generando estos valores con la distribución correspondiente.

en C++
2.9 Esqueletos 189
2.9 Esqueletos
Aquı́ encontrarás partes de programas que pueden servir.
Solamente necesitas copiar y pegar.
• Declaración de variables y constantes.

double aumento=0.076;
int meses;
char respuesta = ’c’;
const double pi = 3.141592654;
char nombre[15];
// el [15] indica la longitud de la cadena <<nombre>>
• Ingresar una variable.

cout << "\nIngresa una variable: ";
cin >> variable;
• Ciclo infinito.
for (;;)
{
// Aquı́ va el procedimiento...
}
• Preguntar si desea continuar...

// No olvides declarar la variable
// char respuesta;
// al inicio del programa...
// Cuando termine va a preguntar:

cin >> respuesta;
{
break; // Salir del ciclo...
}
cout <<"\n\n\n";

en C++
190 Códigos
• Los dos anteriores combinados.
// No olvides declarar la variable

// char respuesta;
// al inicio del programa...
for (;;)
{
// Aquı́ va el procedimiento...
// Cuando termine va a preguntar:

cin >> respuesta;
{
break; // Salir del ciclo...
}
cout << "\n\n\n";
}
• Manejo de archivos. I/O.
/*
ifstream -> Significa Input - File - Stream
ofstream -> Significa Ouput - File - Stream
Para trabajar con archivos se requiere incluir:

#include <fstream.h>
en el preámbulo del programa...
*/
// Paso 1. Abrir el archivo de encabezado
#include <fstream.h>
// Otras cosas que se requieren...

int x,y;
// Declaro las variables para el archivo
// desde el cual voy a leer la información...
// Paso 2. Declarar el Stream

ifstream in_file; // Desde aquı́ voy a leer...
ofstream out_file; // Aquı́ voy agrabar información...
// ifstream y ofstream están definidos en el
// archivo fstream.h
// Paso 3. Abrir el archivo para leer información...

in_stream.open("misdatos.dat");

en C++
2.9 Esqueletos 191
// Paso 4. Leo información desde el archivo...

in_stream >> x >> y;
// Paso 5. Abrir el archivo para grabar infomación...

out_stream.open("misdatos.dat");
// Paso 6. Escribo información en el archivo...

out_stream << x << y;
// Paso 7. Cierro los archivos...

in_stream.close();
out_stream.close();
/*
En C++ no se requiere cerrar los archivos, pero NO todos
los compiladores tienen esta caracterı́sitica...
Puede ser que en ANSI-C ó en C esto cambie...
*/
• Pregunto si se logró abrir el archivo...
in_stream.open("misdatos.dat");
if (in_stream.fail())
{
cout << " No se logró abrir el archivo..."
exit(1); // Finaliza el programa
}
out_stream.open("misdatos.dat");
if (out_stream.fail())
{
cout << " No se logró abrir el archivo..."
exit(1); // Finaliza el programa
}
/*
La función exit está definida en el archivo:
stdlib.h
de manera que debemos incluir en el preámbulo
del programa la instrucción:
#include <stdlib.h>
Utilizamos:
exit(1);
En caso de que el programa deba abortar debido
a un error en el programa o
exit(0);
En cualquier otro caso.
*/

en C++
192 Códigos
• Números de dı́gitos a grabar...
/*
Formato para los datos a grabar en los archivos...
En este caso se supone ue se graban datos tipo double.
*/
out_stream.setf(ios::fixed);
out_stream.setf(ios::showpoint);
out_stream.precision(2);
• Uso de manipuladores de formato de datos...
/*
Para utilizar los manipuladores en este código
se requiere incluir:
#include <iomanip.h>
*/
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout << "(" << setprecision(2) << x << "," << y << ")" << endl;
/*
Esto imprime en pantalla:
(x_val,y_val)
Donde
x_val -> es el valor de la variable x,
y_val -> es el valor de la variable y.
*/

en C++
2.10 Lecciones aprendidas 193
2.10 Lecciones aprendidas

1. No utilices dos apóstrofos seguidos cuando apliques la instrucción cout.
Debes usar comillas dobles (") en su lugar.
2. En la instruccion cout debes utilizar << sin dejar espacio entre ellos.
3. Podemos definir las variables justo antes de usarlas, igual que al principio.
4. Los identificadores (nombres de las variables y constantes) deben iniciar con

una letra o con un guión bajo.
5. Se requiere un punto y coma (;) por cada cout utilizado. No utilices varios
; aún si se extiende varios renglones.
6. La instrucción \n para indicar un salto de lı́nea siempre debe estar encerrado

dentro de las comillas. Posiblemente junto a una cadena de caracteres.
7. La instrucción endl; nunca debe estar encerrado dentro de las comillas.
8. Los números no deben contener comas. Usa punto (decimal) en su lugar.
9. Las constantes del tipo int no deben contener punto decimal.
10. Las constantes del tipo long equivale a long int.
11. Las constantes del tipo char deben encerrarse entre apóstrofos (’).
12. Las constantes del tipo string deben encerrarse entre comillas (").
’c’ es una constante del tipo char.

”c” es una constante del tipo string.
13. No podemos almacenar el valor de un tipo de dato en un otro tipo.
14. Si una variable del tipo bool tiene un valor distinto de cero, entonces tomará
el valor true. Si su valor es cero, entonces, tomará el valor false.
15. Si sumamos uno o dos datos del tipo double, el resultado será del tipo
double.
16. El operador % (módulo) debe ser usado con datos del tipo entero.
17. C++ siempre respeta la prioridad de las operaciones de acuerdo al álgebra

básica.
18. El operador para comparar la igualdad entre dos valores es: ==.
19. El operador para asignar un valor a un identificador es: =.

en C++
194 Códigos
• Si cometemos el error de escribir a = 5 en lugar de a == 5, C++ siem-

pre ejecuta la parte then{}, es decir, supone que la expresión booleana
es verdadera.
• lo anterior ocurrirá siempre que se asigne un valor distinto de cero.
• En caso de que se asigne cero al identificador, se ejecutará la parte
else{}.
20. Las expresiones booleanas deben ser encerradas entre paréntesis, para evitar
errores en el uso del if...then.
21. Es una buena idea empezar el programa imprimiendo en pantalla una pequeña
descripción de lo que realiza el mismo. Ası́ el usuario conocerá qué datos tiene
sentido dar al programa y además qué resultados esperar.
22. Debemos definir la función antes de llamarla... Debe hacerse después de las
instrucciones #include y antes del int main().
23. inline member functions no deben incluir ciclos (for, while...) porque
al compilar las va a enviar como out of line functions. lo más que se
debe hacer con inline member functions es asignar valores o leerlos.7
7 Disculpa esta nota... Sé que solamente la entiendo yo.

en C++
End matter
3

en C++
196 End matter
3.1 Fuentes bibliográficas

Actualmente estoy aprendiendo a programar en el lenguaje C++ por medio de
varios libros que he encontrado muy buenos, sobre todo para los principiantes,
como yo.
Te recomiendo que los adquieras.
Los libros enlistados son los que más he consultado, aunque leo otros más para
conocer varias explicaciones de una misma herramienta y poder adquirir una
visión más clara del arte llamado C++ .
C++ for dummies Stephen Randy Davis. Wiley Publishing Co. 2004. New
m Jersey, USA. (5th Edition)
Problem solving with C++ Walter Savitch. Ed. Addison Wesley. 1999.
m (2nd Edition)
C++ for mathematicians Edward Scheinerman. Ed. Chapman & Hall. 2006.
C++ Demystified: A Self-Teaching Guide Jeff Kent McGraw-Hill/Osborne.
2004
C++ for Business Programming John C. Molluzzo Prentice Hall. 2005.

en C++
Indice alfabético
Algoritmo, 8 Funciones
Asignación, 13 Predefinidas, 22
Trigonométricas, 22
Código, 8
Caracteres especiales, 12 Identificador, 10
Ciclo, 16 If then else, 15
do... while, 16
for, 16 Operaciones
while, 16 Booleanas, 21
Comparaciones, 15 Unitarias, 15
Compilador, 8 Operadores
Compilar, 9 de comparación, 15
Constantes, 12
Correr, 9 Palabras reservadas, 11
Programa, 8
Datos
Tipos de, 11 Sintaxis, 9
Fórmulas matemáticas, 14
Ejemplo
Cadenas de caracteres, 41 Variable
Ciclo for, 49, 50, 55–58 Definición, 10
Ciclo while, 58 Variables
Condicional If, 46, 51–53, 58 Declaración, 12
Declarar constantes, 41
Fórmulas matemáticas, 42, 43, 45
Funciones matemáticas, 54, 55
Error
de Sintaxis, 9
Lógico, 10
Mensajes de, 9

en C++
198 INDICE ALFABÉTICO
3.2 Términos de uso

Utiliza los códigos como una guı́a para aprender a programar.
No hay ninguna garantı́a de que los códigos estén libres de cualquier tipo de
error.
Efraı́n Soto Apolinar no es responsable por cualesquiera daños ocasionados por

el uso de este material.
Tienes derecho de leer el material y de divulgarlo a otras personas, con la única

condición de que no modifiques el documento en ninguna forma.
Si deseas utilizar alguna parte del material, puedes hacerlo, con la única condición
de que menciones la fuente, i.e., este material y a Efraı́n Soto Apolinar como el
autor.
Espero que este material pueda ser de ayuda a muchas personas que desean
aprender a programar en C++.
Con estos programas estoy aprendiendo junto contigo.
En realidad el material que estas leyendo lo estoy generando como un resumen

de lo que voy aprendiendo. Voy a utilizarlo en lo futuro como una referencia.
Este material está siendo actualizado continuamente.
Te agradeceré que me envı́es un mensaje en caso de que encuentres errores en

los códigos, en las definiciones o en la ortografı́a y/o gramática del mismo.
El material no ha tenido ninguna revisión. Agradezco infinitamente tu ayuda.
Efraı́n Soto Apolinar.

en C++
3.3 Créditos
Este documento se preparó con el software de tipografı́a cientı́fica LATEX 2ε .
Créditos
Autor: Efraı́n Soto Apolinar.
Edición: Efraı́n Soto Apolinar.
Composición tipográfica: Efraı́n Soto Apolinar.
Productor general: Efraı́n Soto Apolinar.

Revisión técnica: Pendiente.
Compilador: Dev–C++ Ver. 4.9.9.2. (http://www.bloodshed.net/)
Año de edición: 2007
Año de publicación: Pendiente

Última revisión: August 19, 2008 7:59pm
Agradezco tus sugerencias, comentarios, correcciones, reclamos y todo lo que se

le parezca a la cuenta de correo electrónico:
efra.soto.a@gmail.com @
200 INDICE ALFABÉTICO
3.4 Simbologı́a utilizada

i Cuando encuentres un párrafo con este sı́mbolo en el margen del texto,
debes considerarlo como información importante que puede ayudarte a evitar
problemas futuros.
! Un párrafo con este sı́mbolo indica que debes poner especial atención y
metabolizarla bien. Es muy importante.

Este párrafo tiene información que te guı́a de manera que no te confundas
con conceptos parecidos y vayas a entender una cosa por otra.
@ Indica que busques más información relativa al tema en Internet, o bien

envı́es un mensaje de correo electrónico al autor de este material.
j Indica que el párrafo incluye un procedimiento que debes realizar bajo tu

propio riesgo.
L Indica que el párrafo incluye un procedimiento que debes realizar bajo tu

propio riesgo.
A Indica que nunca debes realizar ese procedimiento, a menos que desees que
la memoria de tu computadora se sature o el programa se cicle y nunca termine.
m Indica que eso todo el mundo lo sabe. Tú también deberı́as saberlo.
o Indica que debes ponerte a practicar. Tienes que intentarlo por tı́ mismo
y desarrollar algunas cosas. Nadie aprende en cabeza ajena.
Indica que este código puedes copiarlo y usarlo libremente.
ÿ Cuando veas esta imagen, piensa en el compa que está elaborando estas
notas.
Siempre que aparezca una de estas imagenes a lo largo del texto aparecerá en
el margen. Por ejemplo, en este párrafo se incluye la imagen referente a los
i párrafos que dan información.
Espero que esto sea de ayuda.

en C++

Tutorial de C++

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tutorial de C++

Uploaded by

Copyright:

Available Formats

Códigos de Programas

Efraı́n Soto Apolinar

Efraı́n Soto Apolinar ÿ

Monterrey, N.L., México. 2007

1.1 Conceptos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.1.1 Conceptos de programación . . . . . . . . . . . . . . . . . 8

1.2 Sintaxis del lenguaje C++ . . . . . . . . . . . . . . . . . . . . . . 11

1.2.1 Palabras reservadas . . . . . . . . . . . . . . . . . . . . . 11

1.2.2 Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . 11

1.2.3 Tipos de constantes . . . . . . . . . . . . . . . . . . . . . 12

1.2.4 Caracteres especiales . . . . . . . . . . . . . . . . . . . . . 12

1.2.5 Declaración de variables . . . . . . . . . . . . . . . . . . . 12

1.2.7 Operaciones matemáticas . . . . . . . . . . . . . . . . . . 14

1.2.10 Ejemplos de control de flujo . . . . . . . . . . . . . . . . . 17

Códigos Este material NO está listo para su publicación. Efraı́n Soto A.

1.2.11 Operaciones lógicas . . . . . . . . . . . . . . . . . . . . . . 21

1.3 Funciones en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 22

1.3.1 Funciones predefinidas . . . . . . . . . . . . . . . . . . . . 22

1.3.2 Funciones definidas por el usuario . . . . . . . . . . . . . 23

2.1 Mis primeros programas . . . . . . . . . . . . . . . . . . . . . . . 32

2.2 Programas con funciones . . . . . . . . . . . . . . . . . . . . . . . 38

2.3 Funciones cin, cout . . . . . . . . . . . . . . . . . . . . . . . . . . 39

2.4 if, for, while and the like... . . . . . . . . . . . . . . . . . . . . . . 46

2.5 Mis tareas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

2.5.2 Cálculo analı́tico . . . . . . . . . . . . . . . . . . . . . . . 64

2.5.10 Simulación de la distribución binomial . . . . . . . . . . . 84

2.5.11 Introducción a la dinámica de poblaciones . . . . . . . . . 87

2.6.1 Regresión lineal . . . . . . . . . . . . . . . . . . . . . . . . 89

2.6.2 Regresión cuadrática . . . . . . . . . . . . . . . . . . . . . 91

2.7 Librerı́a Estadı́stica . . . . . . . . . . . . . . . . . . . . . . . . . . 96

Efraı́n Soto A. Este material NO está listo para su publicación. Códigos

2.8.1 Ejemplos de uso . . . . . . . . . . . . . . . . . . . . . . . 139

2.8.1.1 funiforme(total, archivo) . . . . . . . . . . . . . 139

2.8.1.2 funiforme(total, archivo, A, B) . . . . . . . . . . 140

2.8.1.3 fnormal(total, archivo) . . . . . . . . . . . . . . 142

2.8.1.4 fnormal(total, archivo, media, SD) . . . . . . . . 143

2.8.1.5 fexponencial(total, lambda, archivo) . . . . . . . 144

2.8.1.6 fgeometrica(total, p, archivo) . . . . . . . . . . . 145

2.8.1.7 fpoisson(total, alpha, archivo) . . . . . . . . . . 145

2.8.1.8 fweibull(total, archivo, c, k) . . . . . . . . . . . . 146

2.8.1.9 frayleigh(total, archivo, media) . . . . . . . . . . 147

2.8.1.10 histograma(archivo, intervalos) . . . . . . . . . . 148

2.8.1.11 PchiUniforme(archivo, No Int) . . . . . . . . . . 154

2.8.1.12 PchiNormal(archivo, No Int) . . . . . . . . . . . 156

2.8.1.13 PchiExponencial(archivo, Num Int, lambda) . . 157

2.8.1.14 PchiWeibull(Archivo, Num Int, C, K) . . . . . . 159

2.8.1.15 PchiRayleigh(archivo, Num Int, media) . . . . . 161

2.8.1.16 RL(archivo) . . . . . . . . . . . . . . . . . . . . 162

2.8.1.17 RC(archivo) . . . . . . . . . . . . . . . . . . . . 163

2.8.2 Otras funciones . . . . . . . . . . . . . . . . . . . . . . . . 165

2.8.2.1 uniforme() . . . . . . . . . . . . . . . . . . . . . 165

2.8.2.2 uniforme(a,b) . . . . . . . . . . . . . . . . . . . . 166

2.8.2.3 weibull(c,k) . . . . . . . . . . . . . . . . . . . . . 167

2.8.2.4 rayleigh(media) . . . . . . . . . . . . . . . . . . 168

2.8.2.5 normal() . . . . . . . . . . . . . . . . . . . . . . 169

2.8.2.6 normal(media, desviacionStd) . . . . . . . . . . 170

2.8.2.7 exponencial(lambda) . . . . . . . . . . . . . . . . 171

Códigos Este material NO está listo para su publicación. Efraı́n Soto A.

2.8.2.9 poisson(alpha) . . . . . . . . . . . . . . . . . . . 173

2.8.2.10 media(archivo), desviacionStd(archivo) . . . . . 174

2.8.3 Simulación del recurso eólico . . . . . . . . . . . . . . . . 176

2.8.3.1 Energı́a extraida del viento . . . . . . . . . . . . 176

2.8.4 Distribución del viento . . . . . . . . . . . . . . . . . . . . 178

• Un ejemplo donde se generan las tablas de multiplicar: