Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Co
en el lenguaje C++
en el lenguaje C++
Compilados por
PISIS
Monterrey, N.L., M
exico. 2007
Indice
1 Introducci
on 7
1.1 Conceptos b
asicos . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.5 Declaraci
on de variables . . . . . . . . . . . . . . . . . . . 12
1.2.6 Asignaci
on . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.2.8 Comparaciones . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.9 Ciclos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.4 Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2 C
odigos 31
2.5.1 Simulacion 1 . . . . . . . . . . . . . . . . . . . . . . . . . 60
2.5.2 C
alculo analtico . . . . . . . . . . . . . . . . . . . . . . . 64
2.5.3 Simulacion 2 . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.5.4 Simulacion 3 . . . . . . . . . . . . . . . . . . . . . . . . . 68
2.5.5 Simulacion 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.6 Proyectos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
2.8 Implementaci
on . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
1.1 sicos
Conceptos ba
En este apartado se dan algunos conceptos que necesitas conocer para poder
aprovechar la lectura de este material.
Definici
on 1.1.1.
Algoritmo
Una sucesi
on 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 especfico.
Definici
on 1.1.2.
Compilador
Es el programa de computadora que traduce las instrucciones que nosotros le
damos en un lenguaje especfico.
Definici
on 1.1.3.
Programa fuente
Es el c
odigo que t
u vas a escribir. En este texto encontraras el programa fuente
para resolver muchos problemas. El programa fuente tambien se conoce como
c
odigo fuente.
Definici
on 1.1.4.
Co digo
Es un conjunto de instrucciones en alg
un lenguaje de alto nivel. En este material
solamente encontraras codigo en C++ .
El c
odigo no necesariamente es un programa completo, puede tratarse solamente
de una parte del programa.
Definici
on 1.1.5.
Sintaxis
Son las reglas de acuerdo a las cuales debes escribir el programa fuente. Cada
lenguaje de programacion tiene su sintaxis. Puedes imaginar que la sintaxis son
las reglas de gram
atica de ese lenguaje.
Definici
on 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).
Definici
on 1.1.7.
Correr (un programa)
Ordenar a la computadora que ejecute las instrucciones indicadas por el codigo
de un programa. Evidementemente, un programa en C++ debe correrse en un
compilador de ese lenguaje. (Yo utilizo el Dev-C++ , que es gratuito.)
Definici
on 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 codigo.
Definici
on 1.1.9.
Error de sinta xis
Ocurre cuando el c odigo no est
a 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 sintaxis del lenguaje GWBasic).
Definici
on 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 sintaxis... simplemente no realiza la tarea que debe realizar. Cuidado
con esto.
1.1.2 Variables
Definici
on 1.1.11.
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 smbolo: y los demas
caracteres deben ser letras, dgitos o el smbolo .
Definici
on 1.1.12.
Variable
Es una herramienta de programacion utilizada para asignar valores (no nece-
sariamente numericos) a letras o cadenas de letras. Las variables se clasifican
de acuerdo al tipo de valor que almacenan.
Definici
on 1.1.13.
Constante
Es un valor que no cambia durante la ejecucion del programa. Una constante
puede ser de cualquiera de los tipos de datos definidos en C++ .
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 Precisi on 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 1038 a 1038 7 dgitos 3.1416
double 10308 a 10308 15 dgitos 3.141592654
long double 104932 a 104932 19 dgitos 2.718281828
char No aplica No aplica a
string No aplica No aplica Hola Amigo.
bool False/True No aplica False
Tipos de datos.
Decidir c
omo 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
ejecuci
on del programa.
Si cambia de un da 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. Ademas, existe tambien la posibilidad de que otra constante
tenga el mismo valor y eso pueda ocasionar mas errores todava.
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 enganar 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.5 Declaraci
on de variables
Tipo_de_variable variable1;
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 Asignaci
on
La sint
axis 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;
o Ejemplos:
En el caso de la f
ormula:
1 2
yf = a t + v0 t + yi
2
o se codifica como:
1 M
as sobre funciones y libreras en los siguientes temas.
En la programaci
on es muy com un utilizar la operacion incremento. Es decir,
incrementamos el valor de una variable en 1, digamos un contador.
1.2.8 Comparaciones
If then else
if (Expresi
on Booleana){
// Aqu
van las instrucciones que
}
else{
// Aqu
van las instrucciones que
// debe realizar en caso de que la
// expresi
on Booleana sea falsa
1.2.9 Ciclos
While
while (Expresi
on Booleana){
// Algo debe ocurrir aqu
// Varias veces para que el ciclo
// cumpla con su funci
on...
do...while
do{
// Algo debe ocurrir aqu
// Varias veces para que el ciclo
// cumpla con su funci
on...
} while (Expresi
on Booleana);
// Nota el punto y coma al final...
for
for (incializaci
on ; Expresi
on booleana ; Incremento){
// Algo debe ocurrir aqu
// Varias veces para que el ciclo
// cumpla con su funci
on...
}
// Este ciclo tampoco requiere punto y coma al final...
if...then...else
1 #include <stdio.h>
2 #include <iostream>
3
for
1 #include <stdio.h>
2 #include <iostream>
3
while
Codigos Este material NO est a listo para su publicaci
on. Efran Soto A.
Prohibida la reproducci
on sin permiso previo del autor.
en C++
18 Introducci
on
1 #include <stdio.h>
2 #include <iostream>
3
do...while
1 #include <stdio.h>
2 #include <iostream>
3
switch
1 #include <stdio.h>
2 #include <iostream>
3
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 << "\nPor qu
e?";
16 break;
17 case 2:
18 cout << "\nQu
e te pas
o?";
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 qu
e no estudiaste?";
28 break;
29 case 6:
30 cout << "\nDebes echarle m
as 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 calificaci
on,";
46 cout << "\nno tu edad!!!\n";
47 }
48 cout << "\n\n\n";
49 system ("PAUSE");
50 return 0;
51 }
1 #include <stdio.h>
2 #include <iostream>
3
1 #include <stdio.h>
2 #include <iostream>
3
1.2.11 Operaciones l
ogicas
A las operaciones l
ogicas tambien se les conocen en programacion como opera-
ciones booleanas.
}
//...
}
...
La sintaxis es la siguiente.
Ejemplo:
pi = 3.1416;
radio = sqrt(area /pi);
edad = abs(year de nac - year actual);
base = 5;
exponente = 3;
potencia = pow(base,exponente);
Primero indicamos que tipo de valor nos devolvera. Despues indicamos el nom-
bre de la funci
on. Inmediatamente despues se encierra entre parentesis los ar-
gumentos de la funcion, 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 funci
on sobre la informaci
on que se le entregue.
La sintaxis es la siguiente:
Ejemplo:
La misma funci
on anterior pudo definirse de la siguiente manera:
126 }
127 /**************************************
128 Declaro la funci
on potencia...
129 ***************************************/
130 int potencia(int e)
131 {// para calcular la potencia 2e
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 }
1.4 Clases
Yo me imagino las clases como tipos de datos que defino por comodidad.
Por ejemplo, si necesito trabajar con numeros complejos, mejor defino un nuevo
tipo de variable con una clase. as, podre definir n
umeros complejos como si se
tratara de un tipo de variable que ya estuviera definido en C++ .
La idea es que ademas de declarar tipos de datos tambien podre definir funciones
y realizar operaciones con ellos, por ejemplo, sumarlos, multiplicarlos, etc.
1 /*
2 Este programa crea una clase
3 que se llama n
umero complejo
4 */
5 #include <iostream> // Funciones para input/output
6 #include <cstdlib> //
7
El siguiente c
odigo muestra funciones pertenecientes a una clase.
1 /*
2 Este programa crea una clase
3 que se llama n
umero complejo.
4 Se muestra adem
as el uso de funciones
5 definidas para las clases.
6 */
7 #include <iostream> // Funciones para input/output
8 #include <cstdlib> //
9 using namespace std;
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
54 double complejo::LeerReal(void){
55 return(real);
56 }
57
Debes notar que en el primer codigo se han definido las variables real e imaginary
como variables publicas, pero en el segundo ejemplo se han definido como vari-
ables privadas. De esta forma, no se puede tener acceso a ellas, salvo a traves
de las funciones que se definen en la clase.
Observa tambien que las funciones de clase se definen con el siguiente codigo:
Estructura b
asica del programa.
Las reglas b
asicas del lenguaje C++ .
#include <stdio.h>
int main()
{
printf("\n Los par
entesis siempre aparecen en pares!");
printf("\n Los comentarios en una lnea se indican con //");
printf("\n O bien, se inician don /*");
printf("\n y se terminan con */");
printf("\n cuando abarcan varias lneas...");
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 codigo");
printf("\n para hacerlo m
as legible");
printf("\n Debe contener la funcion main()");
printf("\n C++ usa mayormente minusculas.");
printf("\n En C++ las letras may
usculas y las minusculas");
printf("\n no dan los mismos resultados en las instrucciones...");
return(0);
}
Calcula el
area de un tri
angulo.
1 #include <iostream>
2 using namespace std;
3 int main(void)
4 {
5 double area, base, altura;
6 string unidad;
7 cout << "Que unidad de medida usaras? ";
8 cin >> unidad;
9 cout << "Cuantos " << unidad <<
10 "mide la base del triangulo? ";
11 cin >> base;
12 cout << "Cuantos " << unidad <<
13 "mide la altura del triangulo? ";
14 cin >> altura;
15 area = base*altura/2;
16 cout << "El area del triangulo es: "
17 << area << unidad << " cuadrados.";
18 system("PAUSE");
19 return 0;
20 }
1 /*
2 Nombre del Archivo: proyecto1.cpp
3 Descripci
on: En el encabezado...
4 Fecha de
ultima Modificaci
on: 18 de Noviembre del 2007 */
5 #include <iostream>
6 using namespace std;
7 int main(void)
8 {
9 double pesoOnzas, pesoTon, n;
10 double coef=35273.92;
11 char respuesta = c;
12 for (;;)
13 {
14 cout << "Cual 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 M etricas.\n\n";
19 cout << "Se requieren " << n << "cajas de cereal\n";
20 cout << "para que pesen una Tonelada Metrica,\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;
24 if ((respuesta == S)||(respuesta == s))
25 { break; // Salir del ciclo...
26 }
27 cout <<"\n\n\n";
28 }
29 return 0; // Le indico que devuelva cero la funci
on "main()"
30 }
26 // Declaro la funci
on 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 }
Calcular el promedio. o
1 /* Nombre del archivo: UnoUno.cpp
2 Descripci
on:
3 Escribir un programa que calcule la media real de 3
4 n
umeros enteros dados por el usuario.
5 Fecha de ultima Modificaci
on: 03 de enero del 2008
6 ----------------------------------
7 ----------------------------------
8 */
9 #include <iostream> // Funciones basicas para input/output
10 using namespace std;
11 int main(void){
12 int a,b,c;
13 double promedio;
14 cout << "\nEscribe el primer numero entero: ";
15 cin >> a;
16 cout << "\nEscribe el segundo numero entero: ";
17 cin >> b;
18 cout << "\nEscribe el tercer numero 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 }
12 int a,b;
13 cout << "\nEscribe el primer n
umero entero: ";
14 cin >> a;
15 cout << "\nEscribe el segundo n
umero entero: ";
16 cin >> b;
17 cout << (a + b) << endl;
18 system("PAUSE");
19 return 0;
20 }
19 system("PAUSE");
20 return 0;
21 }
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 }
24 }
Calcular
area del crculo y permetro de circunferencia. o
1 /* Nombre del archivo: UnoOcho.cpp
2 Descripci
on:
3 rea de un c
El a rculo es :
4 A = Pi * r2
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 area.
9
Realizar c
alculos relacionados con un viaje. o
1 /* Nombre del archivo: UnoNueve.cpp
2 Descripci
on:
3 Escribir un programa que pida el total de kil
ometros
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, adem
as:
9 - Consumo de gasolina por cada 100 Km
10 - Consumo de gasolina por cada Km
11 - Velocidad media
12
1 /*
2 Nombre del archivo: DosUno.cpp
3 Descripci
on:
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 a
nos cumplidos.
8
7 ltima Modificaci
Fecha de u on: 04 de enero del 2008
8 ----------------------------------
9 ----------------------------------
10 */
11 #include <iostream> // Funciones b
asicas input/output
12 using namespace std;
13 int main(void){
14 int mes;
15 cout << "\nEste programa imprime el nombre del mes ";
16 cout << "\na partir del n
umero que le corresponde... ";
17 cout << "\nIndique el n
umero 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 g
uey...
10 ltima Modificaci
Fecha de u on: 23 de marzo de 2008
11 *****************************************************/
12 #include <iostream> // Funciones basicas input/output
13 using namespace std;
14 int main(void){
15 int mes;
16 cout << "\nEste programa imprime el nombre del mes ";
17 cout << "\na partir del numero que le corresponde... ";
18 cout << "\nIndique el numero 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" ;
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 }
5 ltima Modificaci
Fecha de u on: 05 Enero 2008
6 ----------------------------------
7 ----------------------------------
8 */
9 #include <iostream> // Funciones b
asicas input/output
10 using namespace std;
11 int main(void){
12 int i, exponente, base;
13 double potencia;
14 cout << "\nEste programa calcula la potencia de un n
umero ";
15 cout << "\nsiendo la base y el exponente n
umeros enteros ";
16 cout << "\nIngresa el valor de la base: ";
17 cin >> base;
18 cout << "\nIngresa el valor del exponente: ";
o Pedir dos n
umeros y su suma.
1 /***************************************************
2 Nombre del archivo: DosCuatro.cpp
3 Descripci
on:
4 Escribir un programa que pida dos n
umeros a, b
5 y despu
es 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
9 ltima Modificaci
Fecha de u on: 04 Enero 2008
10 ****************************************************/
11 #include <iostream> // Funciones b
asicas input/output
12 using namespace std;
13 int main(void){
14 int a,b,suma;
15 char respuesta;
16 cout << "\nEste pide dos n
umeros enteros ";
17 cout << "\ny solicita su suma ";
18 cout << "\nEn caso de error te permite volver a intentar.";
19 cout << "\nIntroduce el primer n
umero entero: ";
20 cin >> a;
21 cout << "\nIntroduce el segundo n
umero entero: ";
22 cin >> b;
23 for (;;){
24 cout << "\nIntroduce la suma de los n
umeros: ";
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...";
36 cin >> respuesta;
37 if ((respuesta == S)||(respuesta == s)){
38 break; // Salir del ciclo...
39 }
40 cout <<"\n\n\n";
41 }
42 system("PAUSE");
43 return 0;
44 }
Pedir dos n
umeros y un operador para realizar el calculo. o
1 /* Nombre del archivo: DosCinco.cpp
2 Descripci
on:
3 Escribir un programa que solicite al usuario dos
4 n
umeros y una operaci
on y mostrar el resultado
5 de esa operaci
on con esos dos n
umeros.
6
7 ltima Modificaci
Fecha de u on: 05 Enero 2008
8 ----------------------------------
9 ----------------------------------
10 */
11 #include <iostream> // Funciones b
asicas input/output
12 using namespace std;
13 int main(void){
14 double a,b,resultado;
15 char operacion;
16 cout << "\nEste pide dos n
umeros enteros ";
17 cout << "\ny solicita un operador ";
18 cout << "\nDespu
es te muestra el resultado... ";
19 cout << "\nIntroduce el primer n
umero entero: ";
20 cin >> a;
21 cout << "\nIntroduce el segundo n
umero entero: ";
22 cin >> b;
23 cout << "\nIntroduce el operador: ";
28 }
29 cout << "\nEl valor absoluto del n
umero real: " << a
30 << " es: " << "\t" << absa << endl;
31 system("PAUSE");
32 return 0;
33 }
Decidir si un n
umero entero positivo dado es par o impar.
o
1 /* Nombre del archivo: DosNueve.cpp
2 Descripci
on:
3 Escribir un programa que determine si el n
umero
4 positivo introducido por el usuario es par o impar.
5
o Encontrar el mayor de 3 n
umeros enteros dados.
6 ltima Modificaci
Fecha de u on: 05 enero de 2008
7 ----------------------------------
8 ----------------------------------
9 */
10 #include <iostream>
11 using namespace std;
12 int main(void){
13 int a,b,c,max;
14 char respuesta;
15 cout << "\nEste programa pide tres n
umeros enteros";
16 cout << "\ne indica el mayor de los tres.";
17 //
18 for (;;){
19 cout << "\nIntroduce el primer n
umero ";
20 cin >> a;
21 cout << "\nIntroduce el segundo n
umero ";
22 cin >> b;
23 cout << "\nIntroduce el tercer n
umero ";
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 n
umeros es: " << max << endl;
35 //
36 cout << "Presione < S > para salir...";
37 cin >> respuesta;
38 if ((respuesta == S)||(respuesta == s)){
39 break; // Salir del ciclo...
40 }
41 cout <<"\n\n\n";
42 }
43 return 0;
44 }
6 ltima Modificaci
Fecha de u on: 05 enero de 2008
7 ----------------------------------
8 ----------------------------------
9 */
10 #include <iostream> // Funciones b
asicas input/output
5 m
nimo. La lista finalizar
a cuando se introduzca el
6 n
umero cero (0).
7
2.5.1 Simulaci
on 1
Se lanza un alfiler de longitud L a una mesa que tiene dibujadas lneas paralelas
equidistantes separadas a L unidades una de la otra. Calcular la probabilidad
de que el alfiler toque lnea.
Consideraciones
1
`i+1
`i
0
Ahora definimos y como la posicion de la punta del alfiler (el extremo opuesto
a la cabeza del alfiler).
y = x + sin (2 )
El alfiler tocar
a lnea siempre y cuando se cumpla alguna de las siguientes condi-
ciones:
i. y > 1,
o
ii. y < 0
Simulaci
on por computadora
En seguida se muestra el c
odigo del programa que simula este experimento.
{
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 angulo que forma el alfiler con
las rectas paralelas dibujadas sobre
la mesa
si --> es el n umero de veces que el alfiler
toca l
nea
no --> es el n umero de veces que el alfiler
NO toca lnea
p --> es la probabilidad de que toque...
total --> es el n umero 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 numero 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 lnea, \nmientras que " << no ;
cout << " no tocaron l nea.\n";
cout << "\nDe aqu que la probabilidad de que el alfiler";
cout << "\ntoque lnea es: " << p;
cout << "\n\n\n";
//
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
varan ligeramente.
De hecho, aun si se dan los mismos valores al programa, este arrojara diferentes
resultados cada vez, dado que los valores que van tomando las variables x (que
representa la distancia desde la recta `i a la cabeza del alfiler) y (que representa
el
angulo que forma el alfiler con cualquiera de las lneas dibujadas sobre la mesa)
son variables aleatorias con distribucion contnua.
Esto se puede verificar realizando los calculos de nuevo con el programa ali-
mentandolo con los mismos valores.
2.5.2 C
alculo analtico
Para hacer el calculo analtico podemos definir las siguientes coordenadas: Sea
d la distancia del centro del alfiler a la recta mas cercana.
Sea ` esta recta, y sea como el menor angulo formado entre ` y el alfiler. De
aqu se deduce que:
1
0d , y 0
2 2
Tambien es claro que el alfiler tocara la recta ` si la hipotenusa del triangulo es
menor a 0.5, es decir:
d 1
<
sin 2
Entonces, al lanzar el alfiler, las coordenadas (d, ) tienen distribucion uniforme
en los intervalos antes definidos, que se pueden representar mediante el siguiente
rect
angulo:
1
2
La probabilidad de que el alfiler toque lnea es igual a la fraccion del area del
1
rect
angulo que yace debajo de la grafica de la funcion: d = sin .
2
El
area del rect
angulo es: /4 y el area debajo de la grafica de la funcion en
cuesti
on es:
Z/2
1 1
sin d =
2 2
0
y as obtenemos:
1
p(A) = 2 = 2 0.6366197724
4
As que la simulaci
on codificada en C++ es correcta.
2.5.3 Simulaci
on 2
Se elabor
o un programa que requiere de la siguiente informacion:
El c
odigo en el lenguaje C++ se enlista en seguida.
2.5.4 Simulaci
on 3
Se elabor
o un programa que requiere de la siguiente informacion:
El c
odigo en el lenguaje C++ se enlista en seguida.
//
// Muestro los resultados...
cout << "\n\n\nIntentos con Poisson: " << i-1;
cout << "\n\n\nTotal de errores: " << errores;
//
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == S)||(respuesta == s)){
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
}
return 0;
}
/**************************************
Declaro la funcion 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 rebas
o la memoria...";
fi = 1;
errores++;
break;
}
i++;
}
return fi;
}
2.5.5 Simulaci
on 4
El c
odigo en el lenguaje C++ se enlista en seguida.
Descripci
on:
Este programa simula el lanzamiento de dos dados...
----------------------------------------------------
----------------------------------------------------
Autor: Efra
n Soto Apolinar
Email: efrain@yalma.fime.uanl.mx
efra.soto.a@gmail.com
Webpage: http://yalma.fime.uanl.mx/efrain/
Fecha de
ultima Modificaci
on: 08 de febrero de 2008
Lenguaje de Programaci
on: C++
Compilador: Dev - C++ Version 4.9.9.2.
----------------------------------------------------
----------------------------------------------------
*/
#include <iostream> // Funciones basicas para input/output
#include <stdlib.h> // para usar la funcion rand()
#include <conio.h> // para usar: getche, getch
#include <ctime> // clock_t = clock();
suma += x+y;
if ((resp == S)||(resp == s)){
// Muestro los resultados...
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\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == S)||(respuesta == s)){
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
}
return 0;
}
2.5.6 Simulacion 5
*/
#include <iostream> // Funciones b
asicas input/output
#include <stdlib.h> // para la funci
on rand()
#include <math.h> // funciones matem aticas
#include <conio.h> // para usar getche, getch
#include <ctime> // clock();
return 0;
}
/**************************************
Declaro la funci
on 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 rebas
o la memoria...";
fi = 1;
errores++;
break;
}
i++;
}
return fi;
}
2.5.7 Simulacion 6
approx = normal(x);
/**************************************
Declaro la funci
on normal...
***************************************/
double normal(double x){
double u = 0;
double un, ua, temp;
int i;
if (x < -4){
return 0;
}
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 funci
on normal...
***************************************/
double intnormal(double x){
double u = 0;
double ua, up, ac;
double xi, step;
// xi es la iteracion actual
// step es el tama
no del paso...
int i;
step = 0.00000001; // El paso es 1 / 107
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 funci
on rfactorial...
***************************************/
double rfactorial(int n){
double fi, i;
int j;
fi = i = 1.0;
j = 1;
//
while (j <= n){
fi /=i;
i = i + 1;
j++;
}
return fi;
}
2.5.8 Simulacion 7
/*************************************
Defino la funci
on f(y)
**************************************/
double f(double y){
return 0.39894228 * exp(- y * y / 2) ;
// el factor
// 0.39894228 = 1 / sqrt(2 * 3.141592653);
}
/*************************************
Defino la funci
on g(y)
**************************************/
double g(double y){
return exp(-fabs(y)) / 2;
2.5.9 Simulacion 8
Puede encontrar un PDF con una animacion de los resultados generados por
este programa en: http://yalma.fime.uanl.mx/~efrain/project.html
// funci
on para generar los n
umeros pseudoaleatorios
// con distribuci
on normal...
double dnormal(double media, double sigma);
double dnormal(void);
// Funci
on para generar un n
umero pseudoaleatorio
// con distribuci
on uniforme en el intervalo (0,1)
double uniforme(void);
int i = 0;
//
for (;;){ // for infinito...
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{ // ingres
o un step positivo...
break;
cout << "\n\n\n";
}
} // end for...
// No requiero los siguientes renglones porque
// se defini
o 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...";
break; // salir del for infinito
}
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...
/**************************************
Declaro la funcion DNORMAL...
***************************************/
double dnormal(double media, double sigma){
/*
Esta funci
on genera numeros pseudoaleatorios
con distribucion uniforme a partir de su media
y su desviaci
on estandar.
*/
double u, v, x, y, z;
u = uniforme();
y = uniforme();
/**************************************
Declaro la funci
on DNORMAL...
***************************************/
double dnormal(void){
/*
Esta funci
on genera n
umeros pseudoaleatorios
con distribuci
on uniforme.
*/
double u, x, y, z;
// Defino la media y desviacion est
andar...
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 funci
on UNIFORME...
***************************************/
double uniforme(void){
// Esta funci
on genera un n
umero pseudoaleatorio
// con distribuci
on uniforme en el intervalo (0,1).
return (double(rand())/double(RAND_MAX));
}
2.5.10 Simulaci
on de la distribuci
on binomial
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 */
16 #include <stdio.h>
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));
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){
79 int i; // contador
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
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 }
2.5.11 Introducci
on a la din
amica de poblaciones
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
18 double uniforme(void);
19
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 }
2.6 Proyectos
En esta secci
on encontrar
as c
odigos de problemas que he resuelto para incre-
mentar mi biblioteca de programas.
2.6.1 Regresi
on lineal
/* Nombre del archivo: LR.cpp
----------------------------------
----------------------------------
Autor: Efra
n Soto Apolinar
Email: efra.soto.a@gmail.com
efrain@yalma.fime.uanl.mx
Fecha de
ultima Modificaci
on: 21 de marzo de 2008
----------------------------------
----------------------------------
*/
#include <cstdio> //
#include <cstdlib> //
#include <iostream> // Funciones b
asicas input/output
#include <math.h> // funciones matematicas
#include <conio.h> // para usar: getche, getch
#include <fstream> // para grabar datos generados...
//
using namespace std;
int main(void){
char respuesta, letra;
// char file_name[15];
int i, j, n; // contadores
double b, m; // par
ametros...
double xi, yi; // datos
double Sx, Sy, Sxs, Sxy; // sumas de datos...
for(;;){ // for infinito...
Sx = 0; Sy = 0; Sxs = 0; Sxy = 0;
// Informaci
on sobre el programa...
cout << "\n\nEste programa pide un grupo de datos ";
cout << "\nque corresponden a las coordenadas de n";
2.6.2 Regresi
on cuadr
atica
/* Nombre del archivo:CR.cpp
ambos por el m
etodo de m
nimos cuadrados.
----------------------------------
----------------------------------
Autor: Efra
n Soto Apolinar
Email: efra.soto.a@gmail.com
efrain@yalma.fime.uanl.mx
Fecha de
ultima Modificaci
on: 21 de marzo de 2008
----------------------------------
----------------------------------
*/
#include <cstdio> //
#include <cstdlib> //
#include <iostream> // Funciones b
asicas input/output
#include <conio.h> // para usar getche, getch
#include <fstream> // para grabar los datos generados...
//
using namespace std;
int main(void){
char respuesta, letra;
// char file_name[15];
int i, j, n; // contadores
double a, b, c; // par
ametros para par
abola...
double m, beta; // par
ametros 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;
for(;;){ // for infinito...
Sx = 0; Sy = 0; Sxy = 0;
Sx2 = 0; Sx3 = 0; Sx4 = 0; Sx2y = 0;
// Informaci
on 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 informacion";
cout << "\nen un archivo y despu
es lee esa informacion";
cout << "\npara encontrar la par
abola de regresi
on";
cout << "\n\n\nPor favor, introduce las coordenadas de ";
cout << "\nlos puntos conocidos, ingresando primero";
cout << "\nlacoordenada en x y despu
es la coordenada en y";
cout << "\nCuando hayas terminado introduce el n
umero ";
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...
2.8 n
Implementacio
Puede accesar al archivo estadistica.h con un clc derecho y elija Open File
A continuaci
on est
a el codigo del mismo archivo.
1 /*
2 Nombre del archivo: "estadistica.h"
3 Descripci
on:
4 Este archivo contiene funciones y clases
5 para trabajar con cuestiones de probabilidad.
6
10
11 ltima Modificaci
Fecha de u on: 02 de junio de 2008.
12
13 A CONSULTADA:
BIBLIOGRAFI
14 -----------------------------------------
15 STICA...
CUESTIONES DE ESTADI
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
29 -----------------------------------------
30 N...
CUESTIONES DE PROGRAMACIO
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
49 -----------------------------------------
50 Sitios de Internet Consultados...
51 -----------------------------------------
52 - Algoritmo para generar n
umeros
53 pseudoaleatorios con distribuci
on Rayleigh:
54 http://www.brighton-webs.co.uk/distributions/rayleigh.asp
55
56 */
57
58 #ifndef PROBABILITY_H
59 #define PROBABILITY_H
60
61 #include <math.h>
62 #include <time.h>
63 #include <stdlib.h>
64 #include <stdio.h>
65 #include <wchar.h>
66 #include <ctype.h>
67 #include <assert.h>
68
69
109
116 /***************************************************
117 double uniforme(void)
118 Descripci
on:
119 Esta funci
on genera un n
umero pseudo-aleatorio
120 con distribuci
on 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 Descripci
on:
135 Esta funci
on genera un n
umero pseudo-aleatorio
136 con distribuci
on uniforme en el intervalo (a,b).
137 /////////////////////////////////////////////////////
138 BUGS:
139 Ninguno conocido...
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 Descripci
on:
150 Esta funci
on guarda N n
umeros pseudoaleatorios
151 con distribuci
on 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;
180 /***************************************************
181 void funiforme(int N, char filename[], float a, float b)
182 Descripcion:
183 Esta funcion guarda N n
umeros pseudoaleatorios
184 con distribucion 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){
196 printf ("\nNo se puede abrir el archivo %s\n",
197 filename);
198 printf("\nPor favor, verifique el nombre archivo");
199 return;
200 }
201 fprintf(stream_unif, "# Este archivo contiene %i
202 n
umeros\n", N);
203 fprintf(stream_unif, "# pseudoaletorios con distribucion
204 uniforme\n");
205 fprintf(stream_unif, "# en el intervalo [%.3f,%.3f]\n",
206 a, b);
207 // Aqu va el c
odigo para grabar...
208 for(int i = 1 ; i <= N ; i++){
215
216 /***************************************************
217 double lpuniforme(void)
218 Descripci
on:
219 Esta funcion genera n
umeros pseudoaleatorios
220 con distribucion normal con media 0.0
221 y desviacion est
andar 1.0.
222 /////////////////////////////////////////////////////
223 BUGS:
224 * Este generador de numeros seudoaleatorios
225 solamente ha sido probado dibujando histogramas
226 y parece presentar distribuci on uniforme.
227 NO se ha sometido a ninguna prueba estad stica
228 formal.
229 * Se sugiere utilizar para requerimientos de
230 grandes cantidades de numeros pseudoaleatorios.
231 * Cuando se utiliza para generar n
umeros
232 pseudoaleatorios con distribuci on normal
233 el histograma aparece con sesgo negativo
234 (corrido hacia la derecha). [Instancia de
235 10,000 numeros generados]
236 ****************************************************/
237 double lpuniforme(void){
238 double u;
239 int primo1 = 8191; // = 213 - 1; N umero primo
240 int primo2 = 524287; // = 219 - 1; Otro n umero 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
259 /***************************************************
260 double normal(void)
261 Descripci
on:
262 Esta funci
on genera n
umeros pseudoaleatorios
263 con distribuci
on normal con media 0.0
264 y desviaci
on est
andar 1.0.
265 /////////////////////////////////////////////////////
266 BUGS:
267 Ninguno conocido...
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 Descripci
on:
287 Esta funci
on genera n
umeros pseudoaleatorios
288 con distribuci
on normal con media << media >>
289 y desviaci
on est
andar << desviacionStd >>
290 /////////////////////////////////////////////////////
291 BUGS:
292 Ninguno conocido...
293 ****************************************************/
294 double normal(double media, double desviacionStd){
295 /*** [tested] ***/
296 if (desviacionStd <= 0){
297 errorDNormal();
298 return 0.0;
299 }
300 double u, x, v, z;
301 u = uniforme();
302 v = uniforme();
303 x = sqrt(-2 * log(u)) * cos(2 * PI * v);
304 if (u >= 0.5){
305 z = media + desviacionStd * x;
306 }
307 else{
308 z = media - desviacionStd * x;
309 }
310 return z;
311 }
312
313 /***************************************************
314 void fnormal(int N, char filename[15])
315 Descripcion:
316 Esta funcion guarda N numeros pseudoaleatorios
317 con distribuci on normal con media 0.0 y
318 desviacion est andar 1.0 en el archivo con
319 nombre <<filename>>.
320 /////////////////////////////////////////////////////
321 BUGS:
322 Ninguno conocido...
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){
329 printf ("\nNo se puede abrir el archivo %s\n",
330 filename);
331 printf("\nPor favor, verifique el nombre archivo");
332 return;
333 }
334 fprintf(stream_normal, "# Este archivo contiene %i
335 n
umeros\n", N);
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");
340 // Aqu va el codigo para grabar...
341 for(int i = 1 ; i <= N ; i++){
342 x = normal(); // generamos un numero
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 Descripcion:
351 Esta funcion guarda N numeros pseudoaleatorios
352 con distribuci on normal con media << med >> y
353 desviacion est andar << desvStd >> en el archivo
354 de nombre <<filename>>.
355 /////////////////////////////////////////////////////
356 BUGS:
357 Ninguno conocido...
358 **********************************************/
390 /***************************************************
391 double lnormal(void)
392 Descripci
on:
393 Esta funci
on genera n
umeros pseudoaleatorios
394 con distribuci
on normal con media 0.0
395 y desviaci
on est
andar 1.0.
396 /////////////////////////////////////////////////////
397 BUGS:
398 Esta funci
on genera n
umeros que presentan un sesgo
399 hacia la derecha cuando se grafican su histograma
400 de frecuencias. Sin embargo, los calculos de media
401 y desciaci
on est
andar est
an cercanos a 0.0 y 1.0,
402 respectivamente.
403 ****************************************************/
404 double lnormal(void){/*** [tested] ***/
405 double media = 0.0, desviacionStd = 1.0;
406 double u, x, v, z;
407 u = lpuniforme();
408 v = lpuniforme();
419
432 /**************************************
433 float exponencial(float lambda)
434 Descripci
on:
435 Esta funci
on genera n
umeros pseudoaleatorios
436 con distribuci
on exponencial de par
ametro
437 lambda.
438 /////////////////////////////////////////////////////
439 BUGS:
440 Ninguno conocido...
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 Descripci
on:
451 Esta funci
on genera N n
umeros pseudoaleatorios
452 con distribuci
on exponencial, con par
ametro
453 << Lambda >>, y los graba en el archivo de nombre
454 << filename >>
455 /////////////////////////////////////////////////////
456 BUGS:
457 Ninguno conocido...
458 ***************************************/
485
486 /**************************************
487 float geometrica(float p)
488 Descripci
on:
489 Esta funci
on genera n
umeros pseudoaleatorios
490 con distribuci
on geometrica de par
ametro p.
491 /////////////////////////////////////////////////////
492 BUGS:
493 Ninguno conocido...
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 Descripci
on:
507 Esta funci
on genera N n
umeros pseudoaleatorios
508 con distribuci
on geometrica, con par
ametro
541
542 /**************************************
543 int poisson(float alpha)
544 Descripci
on:
545 Esta funci
on genera n
umeros pseudoaleatorios
546 con distribuci
on Poisson de par
ametro alpha.
547 /////////////////////////////////////////////////////
548 BUGS:
549 Ninguno conocido...
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;
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 Descripcion:
568 Esta funcion genera N n umeros pseudoaleatorios
569 con distribuci on poisson, con parametro
570 << a >>, y los graba en el archivo de nombre
571 << filename >>.
572 /////////////////////////////////////////////////////
573 BUGS:
574 Ninguno conocido...
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){
582 printf ("\nNo se puede abrir el archivo %s\n",
583 filename);
584 printf("\nPor favor, verifique el nombre archivo");
585 return;
586 }
587 fprintf(stream_poisson, "# Este archivo contiene %i
588 n
umeros\n", N);
589 fprintf(stream_poisson, "# pseudoaletorios con
590 distribucion geometrica\n");
591 fprintf(stream_poisson, "# con par ametro p = %.3f\n",
592 a);
593 // Aqu va el c odigo para grabar...
594 for(int i = 1 ; i <= N ; i++){
595 x = poisson(a); // generamos un n umero
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)
606 Esta funci
on genera n
umeros pseudoaleatorios
607 con distribuci
on Weibull.
608 Los par
ametros c y k corresponden a la forma
620 /***************************************************
621 void fweibull(int N, char filename[15], float C, float K)
622 Descripcion:
623 Esta funcion genera N numeros pseudoaleatorios
624 con distribuci on weibull, con par
ametros
625 << C >> y << K >>, y los graba en el archivo de
626 nombre << filename >>.
627 /////////////////////////////////////////////////////
628 BUGS:
629 Ninguno conocido...
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){
637 printf ("\nNo se puede abrir el archivo %s\n",
638 filename);
639 printf("\nPor favor, verifique el nombre archivo");
640 return;
641 }
642 fprintf(stream_weib, "# Este archivo contiene %i
643 numeros\n", N);
644 fprintf(stream_weib, "# pseudoaletorios con distribucion
645 Weibull\n");
646 fprintf(stream_weib, "# con parametros C = %.3f y K =
647 %.3f\n", C, K);
648 // Aqu va el codigo para grabar...
649 for(int i = 1 ; i <= N ; i++){
650 x = weibull(C, K); // generamos un numero
651 fprintf(stream_weib, "%f\n", x); // grabamos...
652 }
653 fclose(stream_weib); // cerrar archivo...
654 }
655
656 /**************************************
657 double rayleigh(float media)
658 Descripci
on:
674 /***************************************************
675 void frayleigh(int N, char filename[15], float M)
676 Descripcion:
677 Esta funcion genera N numeros pseudoaleatorios
678 con distribuci on rayleigh, con media
679 << M >> y los graba en el archivo de
680 nombre << filename >>.
681 /////////////////////////////////////////////////////
682 BUGS:
683 Ninguno conocido...
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){
691 printf ("\nNo se puede abrir el archivo %s\n",
692 filename);
693 printf("\nPor favor, verifique el nombre archivo");
694 return;
695 }
696 fprintf(stream_rayl, "# Este archivo contiene %i
697 n
umeros\n", N);
698 fprintf(stream_rayl, "# pseudoaletorios con distribucion
699 Rayleigh\n");
700 fprintf(stream_rayl, "# con media = %.3f\n", M);
701 // Aqu va el codigo para grabar...
702 for(int i = 1 ; i <= N ; i++){
703 x = rayleigh(M); // generamos un n
umero
704 fprintf(stream_rayl, "%f\n", x); // grabamos...
705 }
706 fclose(stream_rayl); // cerrar archivo...
707 }
708
709
710 /***************************************************
711 double triangular(double media)
712 Esta funci
on genera numeros pseudoaleatorios
713 con distribuci
on triangular con parametro << media >>
714 /////////////////////////////////////////////////////
715 BUGS:
716 Al dibujar el histograma la distribucion en realidad
717 no parece triangular...
718 NO USAR...
719 MO SIMULARLA...
BUSCAR EN INTERNET CO
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 Descripcion:
736 Esta funcion genera N numeros pseudoaleatorios
737 con distribuci on rayleigh, con media
738 << M >> y los graba en el archivo de
739 nombre << filename >>.
740 /////////////////////////////////////////////////////
741 BUGS:
742 Ninguno conocido...
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){
750 printf ("\nNo se puede abrir el archivo %s\n",
751 filename);
752 printf("\nPor favor, verifique el nombre archivo");
753 return;
754 }
755 fprintf(stream_tria, "# Este archivo contiene %i
756 numeros\n", N);
757 fprintf(stream_tria, "# pseudoaletorios con distribuci
on
758 Rayleigh\n");
768
769
770
771
772
773 /**************************************
774 double media(char filename[])
775 Descripci on:
776 Esta funci on calcula la media aritmetica de
777 los datos contenidos en el archivo de nombre
778 << filename >>.
779 /////////////////////////////////////////////////////
780 BUGS:
781 Ninguno conocido...
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){
794 printf ("\nNo se puede abrir el archivo %s\n",
795 filename);
796 printf("\nPor favor, verifique el nombre archivo");
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)){
805 break; // Salir del ciclo...
806 }
807 switch(letra){
808 case \n: // lleg
o a un nuevo rengl
on
856 /**************************************
857 double desviacionStd(char filename[15])
858 Descripci
on:
909 break;
910 case : // espacio en blanco...
911 if (i > 1){
912 dato[i] = \0; // fin del arreglo
913 x = atof(dato); // convierto a float
914 Sx += x; // Suma de x
915 Sx2 += x * x; // Suma de x2
916 i = 0;
917 n++;
918 break;
919 }
920 case #: // comentario...
921 do{ // leer todos los alfanum
ericos
922 letra = fgetc(stream_sd);
923 if (letra == feof(stream_sd)){
924 break;
925 }
926 } while (letra!=\n);
927 i = 1;
928 dato[0] = letra;
929 break;
930 default:
931 dato[i] = letra;
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 Descripci
on:
948 Esta funci
on genera un histograma en la pantalla
949 a partir de los datos le
dos en el archivo de
950 nombre filename.
951 /////////////////////////////////////////////////////
952 BUGS:
953 Ninguno conocido...
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
1009 }
1010 if (x < vmin){
1011 vmin = x;
1012 }
1013 i = 0;
1014 n++;
1015 break;
1016 case : // espacio en blanco...
1017 if (i > 1){
1018 dato[i] = \0; // fin del arreglo
1019 x = atof(dato); // convierto a float
1020 i = 0;
1021 n++;
1022 // encuentro el m
nimo y el m
aximo...
1023 if (x > vmax){
1024 vmax = x;
1025 }
1026 if (x < vmin){
1027 vmin = x;
1028 }
1029
1030
1031 break;
1032 }
1033 case #: // comentario...
1034 do{ // leer todos los alfanum
ericos
1035 letra = fgetc(stream_histo);
1036 if (letra == feof(stream_histo)){
1037 break;
1038 }
1039 } while (letra!=\n);
1040 i = 1;
1041 dato[0] = letra;
1042 break;
1043 default:
1044 dato[i] = letra;
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{
1054 letra = fgetc(stream_histo); // leer un char
1055 if (letra == feof(stream_histo)){
1056 break; // Salir del ciclo...
1057 }
1058 switch(letra){
1159
1160 /**************************************
1161 void histograma(char filename[], int No_Int)
1162 Descripci on:
1163 Esta funci on 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:
1168 Ninguno conocido...
1169 ***************************************/
1170 void histograma(char filename[], int No_Int){
1171 /*** [tested] ***/
1172 int I[No_Int - 1]; // los intervalos...
1173 int errores = 0, max =0, min = 1000000;
1174 int n = 0, j = 1, i = 0; // contadores
1175 int imax, imin;//
1176 double vmax = -2147483647, vmin = 2147483647;
1177 double anchoIntervalo; // = vmax - vmin
1178 char dato[15]; // cada dato en forma de string
1179 float x; // el n
umero generado...
1180 double escala; // para hacer la gr afica...
1181 int factor; // para hacer la gr
afica...
1182 char letra = ;
1183 //
1184 // limpio la memoria del array para el histograma...
1185 for (i = 0 ; i < No_Int ; i++){
1186 I[i] = 0;
1187 }
1188 // Histograma
1189 FILE *stream_histo; //
1190 stream_histo = fopen(filename, "r+"); // abrir archivo
1191 if (stream_histo == NULL){
1192 printf ("\nNo se puede abrir el archivo %s\n", filename);
1193 printf("\nPor favor, verifique el nombre archivo");
1194 return;
1195 }
1196 // Ahora leemos los datos...
1197 do{
1198 letra = fgetc(stream_histo); // leer un char
1199 if (letra == feof(stream_histo)){
1200 break; // Salir del ciclo...
1201 }
1202 switch(letra){
1203 case \n: // lleg
o a un nuevo rengl
on
1204 if (i > 1){
1205 dato[i] = \0; // fin del arreglo
1206 x = atof(dato); // convierto a float
1207 // encuentro el m
nimo y el m
aximo...
1208 if (x > vmax){
1209 vmax = x;
1210 }
1211 if (x < vmin){
1212 vmin = x;
1213 }
1214 i = 0;
1215 n++;
1216 }
1217 break;
1218 case \t: // para el caso de varias columnas...
1219 dato[i] = \0; // fin del arreglo
1220 x = atof(dato); // convierto a float
1221 // encuentro el m
nimo y el m
aximo...
1222 if (x > vmax){
1223 vmax = x;
1224 }
1225 if (x < vmin){
1226 vmin = x;
1227 }
1228 i = 0;
1229 n++;
1230 break;
1231 case : // espacio en blanco...
1232 if (i > 1){
1233 dato[i] = \0; // fin del arreglo
1234 x = atof(dato); // convierto a float
1235 i = 0;
1236 n++;
1237 // encuentro el m
nimo y el m
aximo...
1238 if (x > vmax){
1239 vmax = x;
1240 }
1241 if (x < vmin){
1242 vmin = x;
1243 }
1244
1245
1246 break;
1247 }
1248 case #: // comentario...
1249 do{ // leer todos los alfanum
ericos
1250 letra = fgetc(stream_histo);
1251 if (letra == feof(stream_histo)){
1252 break;
1253 }
1254 } while (letra!=\n);
1255 i = 1;
1256 dato[0] = letra;
1257 break;
1258 default:
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;
1372 } // Fin de la funci
on HISTOGRAMA
1373
1374
1375
1389
1390
1391 /**************************************
1392 void histograma(char filename[15])
1393 Descripci
on:
1394 Esta funci
on 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:
1400 Ninguno conocido...
1401 ***************************************/
1402 hist Phistograma(char filename[], int No_Int){
1403 /*** [tested] ***/
1404 int errores = 0, max =0, min = 1000000;
1405 int n = 0, j = 1, i = 0; // contadores
1406 int imax, imin;//
1407
1486
1487 break;
1488 }
1489 case #: // comentario...
1490 do{ // leer todos los alfanum
ericos
1491 letra = fgetc(stream_histo);
1492 if (letra == feof(stream_histo)){
1493 break;
1494 }
1495 } while (letra!=\n);
1496 i = 1;
1497 dato[0] = letra;
1498 break;
1499 default:
1500 dato[i] = letra;
1501 i++;
1502 }
1503 } while(!feof(stream_histo));
1504 anchoIntervalo = h.vmax - h.vmin;
1505 // regreso al inicio del archivo
1506 fseek(stream_histo, 0, SEEK_SET);
1507 // Volvemos a leer los datos...
1508 // Ahora para generar el histograma
1509 do{
1510 letra = fgetc(stream_histo); // leer un char
1511 if (letra == feof(stream_histo)){
1512 break; // Salir del ciclo...
1513 }
1514 switch(letra){
1515 case \n: // lleg
o a un nuevo rengl
on
1516 if (i > 1){
1517 dato[i] = \0; // fin del arreglo
1518 x = atof(dato); // convierto a float
1519 i = 0;
1520 n++;
1521 // Asigno al arreglo para el histograma
1522 for(j = 0 ; j < No_Int ; j++){
1523 if ((x > (j * anchoIntervalo / No_Int
1524 + h.vmin)) && (x <= ((j+1) *
1525 anchoIntervalo / No_Int + h.vmin))){
1526 h.I[j]++;
1527 break;
1528 }
1529 }
1530 }
1531 break;
1532 case \t: // para el caso de varias columnas...
1533 dato[i] = \0; // fin del arreglo
1534 x = atof(dato); // convierto a float
1535 i = 0;
1536 n++;
1537 // Asigno al arreglo para el histograma
1538 for(j = 0 ; j < No_Int ; j++){
1539 if ((x > (j * anchoIntervalo / No_Int
1540 + h.vmin)) && (x <= ((j+1) *
1541 anchoIntervalo / No_Int + h.vmin))){
1542 h.I[j]++;
1543 break;
1544 }
1545 }
1546 break;
1547 case : // espacio en blanco...
1548 if (i > 1){
1549 dato[i] = \0; // fin del arreglo
1550 x = atof(dato); // convierto a float
1551 i = 0;
1552 n++;
1553 // Asigno al arreglo para el histograma
1554 for(j = 0 ; j < No_Int ; j++){
1555 if ((x > (j * anchoIntervalo / No_Int
1556 + h.vmin)) && (x <= ((j+1) *
1557 anchoIntervalo / No_Int + h.vmin))){
1558 h.I[j]++;
1559 break;
1560 }
1561 }
1562 break;
1563 }
1564 case #: // comentario...
1565 do{ // leer todos los alfanum
ericos
1566 letra = fgetc(stream_histo);
1567 if (letra == feof(stream_histo)){
1568 break;
1569 }
1570 } while (letra!=\n);
1571 i = 1;
1572 dato[0] = letra;
1573 break;
1574 default:
1575 dato[i] = letra;
1576 i++;
1577 }
1578 } while(!feof(stream_histo));
1579 fclose(stream_histo); // cerrar archivo...
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;
1591 } // Fin de la funcion HISTOGRAMA
1592
1593
1594
1595
1596 /******************************************************
1597 void PchiUniforme(char filename[], int Num_Int)
1598 Descripci
on:
1599 Esta funci
on prueba que los datos contenidos en el
1600 archivo de nombre << filename >> presenten una
1601 distribuci
on normal, calculando el valor de Chi2.
1602 /////////////////////////////////////////////////////
1603 BUGS:
1604 Ninguno conocido...
1605 ------------------------------------------------------
1606 NOTAS:
1607 A. El algoritmo es el siguiente:
1608 1. Se leen los datos del archivo para contar
1646 /******************************************************
1647 void PchiNormal(char filename[], int Num_Int)
1648 Descripci
on:
1649 Esta funci
on prueba que los datos contenidos en el
1650 archivo de nombre << filename >> presenten una
1651 distribuci
on uniforme.
1652 Devuelve el n
umero de datos leidos del archivo,
1653 la media de esos datos y su desviaci
on est
andar.
1654 Tambi
en despliega el valor de Chi2.
1655 /////////////////////////////////////////////////////
1656 BUGS:
1657 Ninguno conocido...
1658 ********************************************************/
1699 /******************************************************
1700 void PchiExponencial(char filename[], int Num_Int,
1701 float lambda)
1702 Descripci
on:
1703 Esta funci
on prueba que los datos contenidos en el
1704 archivo de nombre << filename >> presenten una
1705 distribuci
on exponencial con par
ametro << lambda >>.
1706 Devuelve el n
umero de datos leidos del archivo,
1707 la media de esos datos el valor de Chi2.
1708 /////////////////////////////////////////////////////
1709 BUGS:
1710 Ninguno conocido...
1711 ********************************************************/
1712 void PchiExponencial(char filename[], int Num_Int,
1713 float lambda){
1714 float discrepancia = 0.0;
1715 hist observado; // datos leidos
1716 hist teorico; // datos generados
1717 float m;
1718 float pt, po;
1719 int i;
1720 // Primero generamos el histograma
1721 // a partir de los datos contenidos en el archivo
1722 observado = Phistograma(filename, Num_Int);
1723 // Calculamos los par
ametros de la distribuci
on...
1724 m = media(filename);
1725 // Ahora generamos n
umeros pseudoaleatorios...
1726 fexponencial(100000, lambda, "ChiExpo.txt");
1727 teorico = Phistograma("ChiExpo.txt", Num_Int);
1728 // Comparamos los dos histogramas...
1729 for(i = 0 ; i < Num_Int ; i++){
1730 po = (float)(observado.I[i]) /
1731 (float)(observado.total_datos);
1732 pt = (float)(teorico.I[i]) /
1733 (float)(teorico.total_datos);
1734 discrepancia += (po - pt) * (po - pt) / (pt);
1735 }
1736 printf("\nEl archivo %s contiene %i datos.", filename,
1737 observado.total_datos);
1738 printf("\nMedia calculada: %f", m);
1739 printf("\n\nChi2 = %f\n", discrepancia);
1740 if (discrepancia < 0.15 && teorico.total_datos > 1000){
1741 printf("\nLos datos contenidos en el archivo %s",
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 Descripci
on:
1753 Esta funci
on prueba que los datos contenidos en el
1754 archivo de nombre << filename >> presenten una
1755 distribuci
on Weibull con par
ametro << promedio >>.
1756 Devuelve el n
umero de datos leidos del archivo,
1757 la media de esos datos el valor de Chi2.
1758 /////////////////////////////////////////////////////
1759 BUGS:
1760 Ninguno conocido...
1761 ********************************************************/
1762 void PchiWeibull(char filename[], int Num_Int, float c,
1763 float k){
1764 float discrepancia = 0.0;
1765 hist observado; // datos leidos
1766 hist teorico; // datos generados
1767 float m; // media calculada
1768 float pt, po;
1769 int i;
1770 // Primero generamos el histograma
1771 // a partir de los datos contenidos en el archivo
1772 observado = Phistograma(filename, Num_Int);
1773 // Calculamos los par
ametros de la distribuci
on...
1774 m = media(filename);
1775 // Ahora generamos n
umeros pseudoaleatorios...
1776 fweibull(100000, "ChiWeib.txt", c, k);
1777 teorico = Phistograma("ChiWeib.txt", Num_Int);
1778 // Comparamos los dos histogramas...
1779 for(i = 0 ; i < Num_Int ; i++){
1780 po = (float)(observado.I[i]) /
1781 (float)(observado.total_datos);
1782 pt = (float)(teorico.I[i]) /
1783 (float)(teorico.total_datos);
1784 discrepancia += (po - pt) * (po - pt) / (pt);
1785 }
1786 printf("\nEl archivo %s contiene %i datos.", filename,
1787 observado.total_datos);
1788 printf("\nMedia calculada: %f", m);
1789 printf("\n\nChi2 = %f\n", discrepancia);
1790 if (discrepancia < 0.15 && teorico.total_datos > 1000){
1791 printf("\nLos datos contenidos en el archivo %s",
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 Descripci
on:
1801 Esta funci
on prueba que los datos contenidos en el
1802 archivo de nombre << filename >> presenten una
1803 distribuci
on exponencial con par
ametro << lambda >>.
1804 Devuelve el n
umero de datos leidos del archivo,
1805 la media de esos datos el valor de Chi2.
1806 /////////////////////////////////////////////////////
1807 BUGS:
1808 Ninguno conocido...
1809 ********************************************************/
1810 void PchiRayleigh(char filename[], int Num_Int, float Media){
1811 float discrepancia = 0.0;
1812 hist observado; // datos leidos
1813 hist teorico; // datos generados
1814 float m;
1815 float pt, po;
1816 int i;
1817 // Primero generamos el histograma
1818 // a partir de los datos contenidos en el archivo
1819 observado = Phistograma(filename, Num_Int);
1820 // Calculamos los par
ametros de la distribuci
on...
1821 m = media(filename);
1822 // Ahora generamos n
umeros pseudoaleatorios...
1823 frayleigh(100000, "ChiExpo.txt", Media);
1824 teorico = Phistograma("ChiExpo.txt", Num_Int);
1825 // Comparamos los dos histogramas...
1826 for(i = 0 ; i < Num_Int ; i++){
1827 po = (float)(observado.I[i]) /
1828 (float)(observado.total_datos);
1829 pt = (float)(teorico.I[i]) /
1830 (float)(teorico.total_datos);
1831 discrepancia += (po - pt) * (po - pt) / (pt);
1832 }
1833 printf("\nEl archivo %s contiene %i datos.", filename,
1834 observado.total_datos);
1835 printf("\nMedia calculada: %f", m);
1836 printf("\n\nChi2 = %f\n", discrepancia);
1837 if (discrepancia < 0.15 && teorico.total_datos > 1000){
1838 printf("\nLos datos contenidos en el archivo %s",
1839 filename);
1840 printf("\nparecen presentar distribucion Rayleigh.");
1841 return;
1842 }
1843 }
1844
1845
1846 /******************************************************
1847 void RL(char filename[])
1848 Descripci
on:
1849 Esta funci
on calcula la recta de mejor ajuste a los
1850 datos contenidos en el archivo << filename >>.
1851 /////////////////////////////////////////////////////
1852 BUGS:
1853 Ninguno conocido...
1854 ********************************************************/
1855 void RL(char filename[]){
1856 char letra;
1857 char dato[15]; // cada dato en forma de string
1858 float x, y; // coordenadas del punto
1967 /******************************************************
1968 void RC(char filename[])
1969 Descripci
on:
1970 Esta funci
on calcula la recta de mejor ajuste a los
1971 datos contenidos en el archivo << filename >>.
1972 /////////////////////////////////////////////////////
1973 BUGS:
1974 Ninguno conocido...
1975 ********************************************************/
1976 void RC(char filename[]){
1977 char letra;
1978 char dato[15]; // cada dato en forma de string
1979 float x, y; // coordenadas del punto
1980 int i, j = 0; // contadores
1981 float a, b, c; // par
ametros para par
abola...
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
2009 punto = 0;
2010 }
2011 else{
2012 y = atof(dato);
2013 punto = 1;
2014 }
2015 j++;
2016 i = 0;
2017 }
2018 break;
2019 case \t:// para el caso de varias columnas...
2020 dato[i] = \0; // fin del arreglo
2021 if (j % 2 == 0){
2022 x = atof(dato); // convierto a un float
2023 punto = 0;
2024 }
2025 else{
2026 y = atof(dato);
2027 punto = 1;
2028 }
2029 j++;
2030 i = 0;
2031 break;
2032 case : // espacio en blanco...
2033 if (i > 1){
2034 dato[i] = \0; // fin del arreglo
2035 if (j % 2 == 0){
2036 x = atof(dato); // convierto a un float
2037 punto = 0;
2038 }
2039 else{
2040 y = atof(dato);
2041 punto = 1;
2042 }
2043 j++;
2044 i = 0;
2045 break;
2046 }
2047 case #: // comentario...
2048 do{ // leer todos los alfanum
ericos
2049 letra = fgetc(stream_RC);
2050 if (letra == feof(stream_RC)){
2051 break;
2052 }
2053 } while (letra!=\n);
2054 i = 0;
2055 dato[0] = letra;
2056 break;
2057 default:
2058 dato[i] = letra;
2059 punto = 0;
2060 i++;
2061 }
2062 if (punto == 1){
2063 // Realizamos los c
alculos...
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 c
ubica
2069 Sx4 += x * x * x * x; // Suma x cuarta
2070 Sx2y += x * x * y;
2071 punto = 0;
2072 }
2073 } while(!feof(stream_RC));
2074
2100
2101
En esta secci
on se muestra como utilizar dentro de programas las funciones que
se definieron anteriormente.
Despues de cada c
odigo se muestra el resultado que imprimio cada programa.
Funci
on 2.8.1
void funiforme(int N, char filename[])
Descripci on: Esta funci on guarda N n umeros pseudoaleatorios con dis-
tribuci
on uniforme en el intervalo (0.0, 1.0) en el archivo con nombre filename.
39 printf("\n\n\n");
40 system("PAUSE");
41 return 0;
42 }
Funci
on 2.8.2
void funiforme(int N, char filename[], float a, float b)
Descripci on: Esta funcion guarda N n umeros pseudoaleatorios con dis-
tribuci
on uniforme en el intervalo (a, b) en el archivo con nombre filename.
1 #include "estadistica.h"
2
3 using namespace std;
4 int main(void){
5 int total; // n
umeros a generar...
6 char archivo[15]; // nombre del archivo...
7 float A, B; // parametros de la distribucion
8 printf("\nEste programa verifica que las funciones");
9 printf("\nincluidas en el codigo del archivo");
10 printf("\n<< estadistica.h >>");
11 printf("\nfuncionen correctamente...");
12 printf("\n\nEstamos probando las funciones: \n");
13 printf("- funiforme(int N, char filename[], float a, float b),\n");
14 printf("- histograma(char filename[]),\n");
15 printf("- media(char filename[]),\n");
16 printf("- desviacionStd(char filename[]),\n");
17 printf("\n\nCuantos numeros desea generar: ");
18 scanf("%i", &total);
19 printf("\n\nLimite inferior de la distribucion: ");
20 scanf("%f", &A);
21 printf("\n\nLimite superior de la distribucion: ");
22 scanf("%f", &B);
23 printf("\nNombre del archivo: [Incluye extension] ");
24 scanf("%s", &archivo);
25 funiforme(total, archivo, A, B);
26 histograma(archivo);
27 printf("\n\nMedia calculada: %f", media(archivo));
28 printf("\n\nDesviacion Estandar calculada: %f", desviacionStd(archivo));
29 printf("\n\n\n");
30 system("PAUSE");
31 return 0;
32 }
Note que se agregaron algunas lneas de codigo para pedir los parametros A
y B, que corresponden a los lmites inferior y superior del intervalo donde se
generar
an los n
umeros pseudoaleatorios con distribucion uniforme.
...
Cuantos numeros desea generar: 10000
Funci
on 2.8.3
void fnormal(int N, char filename[])
Descripcion: Esta funcion guarda N n umeros pseudoaleatorios con dis-
tribuci
on normal con media 0.0 y desviacion estandar 1.0 en el archivo con
nombre filename.
1 #include "estadistica.h"
2
3 using namespace std;
4 int main(void){
5 int total; // n
umeros a generar...
6 char archivo[15]; // nombre del archivo...
7 printf("\nEste programa verifica que las funciones");
8 printf("\nincluidas en el codigo del archivo");
9 printf("\n<< estadistica.h >>");
10 printf("\nfuncionen correctamente...");
11 printf("\n\nEstamos probando las funciones: \n");
12 printf("- fnormal(int N, char filename[]),\n");
13 printf("- histograma(char filename[]),\n");
14 printf("- media(char filename[]),\n");
15 printf("- desviacionStd(char filename[]),\n");
16 printf("\n\nCuantos numeros desea generar: ");
17 scanf("%i", &total);
18 printf("\nNombre del archivo: [Incluye extension] ");
19 scanf("%s", &archivo);
20 fnormal(total, archivo);//, A, B
21 histograma(archivo);
22 printf("\n\nMedia calculada: %f", media(archivo));
23 printf("\n\nDesviacion Estandar calculada: %f", desviacionStd(archivo));
24 printf("\n\n\n");
25 system("PAUSE");
26 return 0;
27 }
El programa arroja:
Funci
on 2.8.4
void fnormal(int N, char filename[], float med, float desvStd)
Descripci on: Esta funcion guarda N n umeros pseudoaleatorios con dis-
tribuci
on normal con media med y desviacion estandar desvStd en el archivo de
nombre filename.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // n
umeros a generar...
5 float mean, SD;
6 char archivo[15]; // nombre del archivo...
7 printf("\nEste programa verifica que las funciones");
8 printf("\nincluidas en el codigo del archivo");
9 printf("\n<< estadistica.h >>");
10 printf("\nfuncionen correctamente...");
11 printf("\n\nEstamos probando las funciones: \n");
12 printf("- fnormal(int N, char filename[], float med, float desvStd),\n");
13 printf("- histograma(char filename[]),\n");
14 printf("- media(char filename[]),\n");
15 printf("- desviacionStd(char filename[]),\n");
16 printf("\n\nCuantos numeros desea generar: ");
17 scanf("%i", &total);
18 printf("\n\nMedia de la distribucion: ");
19 scanf("%f", &mean);
20 printf("\n\nDesviacion estandar de la distribucion: ");
21 scanf("%f", &SD);
22 printf("\nNombre del archivo: [Incluye extension] ");
23 scanf("%s", &archivo);
24 fnormal(total, archivo, mean, SD);//
25 histograma(archivo);
26 printf("\n\nMedia calculada: %f", media(archivo));
27 printf("\n\nDesviacion Estandar calculada: %f", desviacionStd(archivo));
28 printf("\n\n\n");
29 system("PAUSE");
30 return 0;
31 }
Funci
on 2.8.5
void fexponencial(int N, float Lambda, char filename[])
Descripcion: Esta funcion genera N n umeros pseudoaleatorios con dis-
tribuci
on exponencial, con parametro Lambda, y los graba en el archivo de
nombre filename.
1 #include "estadistica.h"
2
3 using namespace std;
4 int main(void){
5 int total; // n
umeros a generar...
6 char archivo[15]; // nombre del archivo...
7 float L; // parametro de la distribucion
8 printf("\nEste programa verifica que las funciones");
9 printf("\nincluidas en el codigo del archivo");
10 printf("\n<< estadistica.h >>");
11 printf("\nfuncionen correctamente...");
12 printf("\n\nEstamos probando las funciones: \n");
13 printf("- fexponencial(int N, float Lambda, char filename[]),\n");
14 printf("- histograma(char filename[]),\n");
15 printf("- media(char filename[]),\n");
16 printf("- desviacionStd(char filename[]),\n");
17 printf("\n\nCuantos numeros desea generar: ");
18 scanf("%i", &total);
19 printf("\n\nParametro Lambda de la distribucion: ");
20 scanf("%f", &L);
21 printf("\nNombre del archivo: [Incluye extension] ");
22 scanf("%s", &archivo);
23 fexponencial(total, L, archivo);//, mean, SD
24 histograma(archivo);
25 printf("\n\nMedia calculada: %f", media(archivo));
26 printf("\n\nDesviacion Estandar calculada: %f", desviacionStd(archivo));
27 printf("\n\n\n");
28 system("PAUSE");
29 return 0;
30 }
Funci
on 2.8.6
void fgeometrica(int N, float p, char filename[15])
Descripci on: Esta funcion genera N n umeros pseudoaleatorios con dis-
tribuci
on geometrica, con par
ametro p, y los graba en el archivo de nombre
filename.
1 #include "estadistica.h"
2
3 using namespace std;
4 int main(void){
5 int total; // n
umeros a generar...
6 char archivo[15]; // nombre del archivo...
7 float p; // parametro de la distribucion
8 printf("\n\nCuantos numeros desea generar: ");
9 scanf("%i", &total);
10 printf("\n\nParametro p de la distribucion: ");
11 scanf("%f", &p);
12 printf("\nNombre del archivo: [Incluye extension] ");
13 scanf("%s", &archivo);
14 fgeometrica(total, p, archivo);//, mean, SD
15 printf("\n\nMedia calculada: %f", media(archivo));
16 printf("\n\nDesviacion Estandar calculada: %f", desviacionStd(archivo));
17 printf("\n\n\n");
18 system("PAUSE");
19 return 0;
20 }
Funci
on 2.8.7
void fpoisson(int N, float a, char filename[])
Descripcion: Esta funci on genera N numeros pseudoaleatorios con dis-
tribuci
on poisson, con par
ametro , y los graba en el archivo de nombre
filename.
1 #include "estadistica.h"
2
Funci
on 2.8.8
void fweibull(int N, char filename[], float C, float K)
Descripci on: Esta funcion genera N n umeros pseudoaleatorios con dis-
tribuci
on weibull, con parametros C y K, y los graba en el archivo de nombre
filename.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // de n
umeros a generar...
5 char archivo[15]; // nombre del archivo...
6 float C, K; // parametros de la distribucion
7 printf("\nEste programa verifica que las funciones");
8 printf("\nincluidas en el codigo del archivo");
9 printf("\n<< estadistica.h >>");
10 printf("\nfuncionen correctamente...");
11 printf("\n\nEstamos probando las funciones: \n");
12 printf("- fweibull(int N, char filename[], float C, float K),\n");
13 printf("- histograma(char filename[]),\n");
14 printf("- media(char filename[]),\n");
15 printf("- desviacionStd(char filename[]),\n");
16 printf("\n\nCuantos numeros desea generar: ");
17 scanf("%i", &total);
Funci
on 2.8.9
void frayleigh(int N, char filename[], float M)
Descripci on: Esta funci on genera N n umeros pseudoaleatorios con dis-
tribuci
on rayleigh, con media M y los graba en el archivo de nombre filename.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // n
umeros a generar...
5 char archivo[15]; // nombre del archivo...
6 float mean;
7 printf("\nEste programa verifica que las funciones");
8 printf("\nincluidas en el codigo del archivo");
9 printf("\n<< estadistica.h >>");
10 printf("\nfuncionen correctamente...");
11 printf("\n\nEstamos probando las funciones: \n");
12 printf("- frayleigh(int N, char filename[], float M),\n");
13 printf("- histograma(char filename[]),\n");
14 printf("- media(char filename[]),\n");
Funci
on 2.8.10
histograma(char filename[], int No Int)
Descripci on: Esta funcion genera un histograma de No Int intervalos en la
pantalla a partir de los datos ledos en el archivo de nombre filename.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // n
umeros a generar...
5 char archivo[15]; // nombre del archivo...
6 float mean; // parametro de la distribucion
7 printf("\nEste programa verifica que las funciones");
8 printf("\nincluidas en el codigo del archivo");
9 printf("\n<< probability.h >>");
10 printf("\nfuncionen correctamente...");
11 printf("\n\nEstamos probando las funciones: \n");
12 printf("- funiforme(int N, char filename[]),\n");
13 printf("- histograma(char filename[]),\n");
14 printf("- media(char filename[]),\n");
Entonces, distribuci
on mas suave nos permite calcular un pronostico de la en-
erga producida por un generador eolico con mayor precision.
1 #include <iostream>
2 #include "estadistica.h"
3 using namespace std;
4 int main(void){
5 int total; // numeros a generar...
6 char archivo[15]; // nombre del archivo...
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);
19 cout << "\nHistograma con 20 intervalos:";
20 histograma(archivo,20);
21 cout << "\nHistograma con 30 intervalos:";
22 histograma(archivo,30);
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 }
Como la energa producida depende del cubo de la velocidad del viento, ten-
dremos una diferencia considerable al realizar el pronostico. Tomando el punto
medio de cada intervalo, elevandolo al cubo y multiplicando por la probabilidad
que le corresponde a ese intervalo, tendremos una aproximacion simplificada del
resultado (falta considerar cuestiones tecnicas relativas al generador eolico, al-
Funci
on 2.8.11
void PchiUniforme(char filename[], int Num Int)
Descripci on: Esta funcion sirve de apoyo en la prueba de bondad de ajuste
que los datos contenidos en el archivo de nombre filename presenten una dis-
on uniforme, calculando el valor de 2 .
tribuci
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // n
umeros a generar...
5 char archivo[15]; // nombre del archivo...
6 int i; // contador
7 printf("\nEste programa verifica que la funcion");
8 printf("\nChiUniforme(char filename[], int Num_Int)");
9 printf("\nfuncione correctamente...");
10 printf("\n\nCuantos numeros desea generar: ");
11 scanf("%i", &total);
12 printf("\nNombre del archivo: [Incluye extension] ");
13 scanf("%s", &archivo);
14 funiforme(total, archivo); // genero uniformes...
15 PchiUniforme(archivo, 15); // prueba chi2
16 printf("\nHistograma Observado...");
17 histograma(archivo, 15); // dibujar histograma...
18 printf("\n\n\n");
19 system("PAUSE");
20 return 0;
21 }
Chi2 = 0.001277
Histograma Observado...
El siguiente prueba un archivo que tiene datos con distribucion normal estandar.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 char archivo[15]; // nombre del archivo...
5 printf("\nEste programa verifica que la funcion");
6 printf("\nChiUniforme(char filename[], int Num_Int)");
7 printf("\nfuncione correctamente...");
8 printf("\nNombre del archivo: [Incluye extension] ");
9 scanf("%s", &archivo);
10 PchiUniforme(archivo, 15);
11 printf("\nHistograma Observado...");
12 histograma(archivo,15);
13 printf("\n\n\n");
14 system("PAUSE");
15 return 0;
16 }
Chi2 = 1.339906
Histograma Observado...
Funci
on 2.8.12
void PchiNormal(char filename[], int Num Int)
Descripci on: Esta funcion sirve de apoyo en la prueba de bondad de ajuste
que los datos contenidos en el archivo de nombre filename presenten una dis-
on normal, calculando el valor de 2 . La funcion calcula la media y
tribuci
la desviacion est
andar de los datos contenidos en el archivo y los utiliza para
alculo de 2 .
realizar el c
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 char archivo[15]; // nombre del archivo...
5 printf("\nEste programa verifica que la funcion");
6 printf("\nPchiNormal(char filename[], int Num_Int)");
7 printf("\nfuncione correctamente...");
8 printf("\nNombre del archivo: [Incluye extension] ");
9 scanf("%s", &archivo);
10 PchiNormal(archivo, 15);
11 printf("\nHistograma Observado...");
12 histograma(archivo,15);
13 printf("\n\n\n");
14 system("PAUSE");
15 return 0;
16 }
Chi2 = 0.000004
Histograma Observado...
Chi2 = 79.591026
Histograma Observado...
Funci
on 2.8.13
void PchiExponencial(char filename[], int Num Int, float lambda)
Descripci on: Esta funci on sirve de apoyo en la prueba de bondad de ajuste
que los datos contenidos en el archivo de nombre filename presenten una dis-
on normal, calculando el valor de 2 . La funcion calcula la media y
tribuci
la desviacion est
andar de los datos contenidos en el archivo y los utiliza para
alculo de 2 .
realizar el c
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // n
umeros a generar...
5 char archivo[15]; // nombre del archivo...
6 float L;
7 printf("\nEste programa verifica que la funcion");
8 printf("\nPchiExponencial(char filename[], int Num_Int, float lambda)");
9 printf("\nfuncione correctamente...");
10 printf("\n\nCuantos numeros desea generar: ");
11 scanf("%i", &total);
12 printf("\n\nParametro Lambda de la distribucion: ");
13 scanf("%f", &L);
14 printf("\nNombre del archivo: [Incluye extension] ");
15 scanf("%s", &archivo);
16 fexponencial(total, 3.0, archivo); // genero numeros pseudoaleatorios
17 PchiExponencial(archivo, 15, 3); // prueba de bondad de ajuste
18 printf("\nHistograma Observado...");
19 histograma(archivo,15);
20 printf("\n\n\n");
21 system("PAUSE");
22 return 0;
23 }
Chi2 = 0.762427
Histograma Observado...
En la lnea 10 del c
odigo se indica a la funcion que suponemos que el archivo
contiene datos con distribucion exponencial con parametro = 3.0
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 char archivo[15]; // nombre del archivo...
5 float L; // parametro lambda
6 printf("\nEste programa verifica que la funcion");
7 printf("\nChiUniforme(char filename[], int Num_Int, float alpha)");
8 printf("\nfuncione correctamente...\n");
9 printf("\nNombre del archivo: [Incluye extension] ");
10 scanf("%s", &archivo);
11 printf("\nParametro Lambda supuesto: ");
12 scanf("%f", &L);
13 PchiExponencial(archivo, 15, L);
14 printf("\n\n\n");
15 system("PAUSE");
16 return 0;
17 }
Chi2 = 288.591888
Funci
on 2.8.14
void PchiWeibull(char filename[], int Num Int, float c, float k)
Descripcion: Esta funci
on prueba que los datos contenidos en el archivo de
nombre filename presenten una distribucion Weibull con parametro promedio.
Devuelve el n
umero de datos leidos del archivo, la media de esos datos el valor
de 2 .
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 char archivo[15]; // nombre del archivo...
5 float C, K; // intervalo para generar uniformes
6 printf("\nEste programa verifica que la funcion");
7 printf("\nChiUniforme(char filename[], int Num_Int, float alpha)");
8 printf("\nfuncione correctamente...");
9 printf("\nNombre del archivo: [Incluye extension] ");
10 scanf("%s", &archivo);
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);
16 printf("\nHistograma Observado...");
17 histograma(archivo,15);
18 printf("\n\n\n");
19 system("PAUSE");
20 return 0;
21 }
Chi2 = 0.000090
Chi2 = 1.659585
Histograma Observado...
Funci
on 2.8.15
void PchiRayleigh(char filename[], int Num Int, float Media)
Descripci on: Esta funci
on prueba que los datos contenidos en el archivo de
nombre filename presenten una distribucion exponencial con parametro . De-
vuelve el n
umero de datos leidos del archivo, la media de esos datos el valor de
2 .
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 char archivo[15]; // nombre del archivo...
5 float mean; // intervalo para generar uniformes
6 printf("\nEste programa verifica que la funcion");
7 printf("\nChiUniforme(char filename[], int Num_Int, float alpha)");
8 printf("\nfuncione correctamente...");
9 printf("\nNombre del archivo: [Incluye extension] ");
10 scanf("%s", &archivo);
11 printf("\nMedia de la distribucion: ");
12 scanf("%f", &mean);
13 PchiRayleigh(archivo, 15, mean);
14 printf("\nHistograma Observado...");
15 histograma(archivo,15);
16 printf("\n\n\n");
17 system("PAUSE");
18 return 0;
19 }
Media de la distribucion: 12
Chi2 = 0.541957
Histograma Observado...
2.8.1.16 RL(archivo)
Funci
on 2.8.16
void RL(char filename[])
Descripci on: Esta funcion calcula la recta de mejor ajuste a los datos con-
tenidos en el archivo filename.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 char archivo[15]; // nombre del archivo...
5 printf("\nNombre del archivo: [Incluye extension] ");
6 scanf("%s", &archivo);
7 RL(archivo);
8 system("PAUSE");
9 return 0;
10 }
2.8.1.17 RC(archivo)
Funci
on 2.8.17
void RC(char filename[])
Descripcion: Esta funci on calcula la parabola de mejor ajuste a los datos
contenidos en el archivo filename.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 char archivo[15]; // nombre del archivo...
5 printf("\nNombre del archivo: [Incluye extension] ");
6 scanf("%s", &archivo);
7 RC(archivo);
8 system("PAUSE");
9 return 0;
10 }
Para las dos funciones anteriores, se utilizo el archivo test.txt que contiene la
siguiente informaci
on:
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
2.8.2.1 uniforme()
Funci
on 2.8.18
double uniforme(void)
Descripcion: Esta funci on genera un n
umero pseudoaleatorio con distribucion
uniforme en el intervalo (0, 1).
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // numeros a generar...
5 int i; // contador
6 printf("\n\nCuantos numeros desea generar: ");
7 scanf("%i", &total);
8 for(i = 1 ; i <= total ; i++){
9 printf("\n %i,\t %f", i, uniforme()); //
10 }
11 printf("\n\n\n");
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
Presione una tecla para continuar . . .
2.8.2.2 uniforme(a,b)
Funci
on 2.8.19
double uniforme(float a, float b)
Descripcion: Esta funcion genera un n
umero pseudo-aleatorio con distribucion
uniforme en el intervalo (a, b).
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // numeros a generar...
5 float A, B; // intervalo para generar uniformes
6 int i; // contador
7 printf("\n\nCuantos numeros desea generar: ");
8 scanf("%i", &total);
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 }
16 printf("\n\n\n");
17 system("PAUSE");
18 return 0;
19 }
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
Presione una tecla para continuar . . .
2.8.2.3 weibull(c,k)
Funci
on 2.8.20
double weibull(double c, double k)
Descripci on: Esta funcion genera n
umeros pseudoaleatorios con distribucion
Weibull. Los par ametros c y k corresponden a la forma y escala de la dis-
tribuci
on, respectivamente.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // numeros a generar...
5 float C, K; // intervalo para generar uniformes
6 int i; // contador
7 printf("\n\nCuantos numeros desea generar: ");
8 scanf("%i", &total);
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 }
16 printf("\n\n\n");
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
Presione una tecla para continuar . . .
2.8.2.4 rayleigh(media)
Funci
on 2.8.21
double rayleigh(float media)
Descripcion: Esta funcion genera n
umeros pseudoaleatorios con distribucion
Rayleigh con media media.
1 #include "estadistica.h"
2
3 using namespace std;
4 int main(void){
5 float mean; // parametro de la distribucion
6 int total, i;
7 printf("\nEste programa verifica que la funcion");
8 printf("\nfloat rayleigh(float media)");
9 printf("\nfuncione correctamente...\n");
10 printf("Cuantos numeros deseas generar? ");
11 scanf("%i", &total);
12 printf("\nMedia de la distribucion: ");
13 scanf("%f", &mean);
14 for(i = 1 ; i <= total ; i++){
15 printf("\nGenerado: %f", rayleigh(mean));
16 }
17 printf("\n\n\n");
18 system("PAUSE");
19 return 0;
20 }
Media de la distribucion: 12
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
Generado: 29.418927
2.8.2.5 normal()
Funci
on 2.8.22
double normal(void)
Descripcion: Esta funci
on genera numeros pseudoaleatorios con distribucion
uniforme con media = 0.0 y desviacionStd = 1.0, es decir, distribucion normal
estandarizada.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // n
umeros a generar...
5 int i; // contador
6 printf("\n\nCuantos numeros desea generar: ");
7 scanf("%i", &total);
8
9 for(i = 1 ; i <= total ; i++){
10 printf("\n %i,\t %f", i, normal()); //
11 }
12 printf("\n\n\n");
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
25, 0.136725
Funci
on 2.8.23
double normal(double media, double desviacionStd)
Descripci on: Esta funcion genera n
umeros pseudoaleatorios con distribucion
uniforme con media media y desviacion estandar desviacionStd, definidas por
el usuario.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // n
umeros a generar...
5 float mean, SD; // intervalo para generar uniformes
6 int i; // contador
7 printf("\n\nCuantos numeros desea generar: ");
8 scanf("%i", &total);
9 printf("\n\nMedia de la distribucion: ");
10 scanf("%f", &mean);
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)); //
16 printf("\n\n\n");
17 system("PAUSE");
18 return 0;
19 }
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
19, 102.721846
20, 95.598887
2.8.2.7 exponencial(lambda)
Funci
on 2.8.24
float exponencial(float lambda)
Descripcion: Esta funci
on genera n
umeros pseudoaleatorios con distribucion
exponencial y par
ametro lambda definido por el usuario.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 int total; // numeros a generar...
5 int i; // contador
6 float L; // Parametro de la distribucion
7 printf("\n\nCuantos numeros desea generar: ");
8 scanf("%i", &total);
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 }
14 printf("\n\n\n");
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
23, 0.253584
24, 0.009361
25, 0.017903
Presione una tecla para continuar . . .
2.8.2.8 geometrica(p)
Funci
on 2.8.25
int geometrica(float p)
Descripcion: Esta funcion genera n
umeros pseudoaleatorios con distribucion
geometrica de par
ametro p.
1 #include "estadistica.h"
2
3 using namespace std;
4 int main(void){
5 float p; // parametro de la distribucion
6 int total, i;
7 printf("\nEste programa verifica que la funcion");
8 printf("\nint geometrica(float p)");
9 printf("\nfuncione correctamente...\n");
10 printf("Cuantos numeros deseas generar? ");
11 scanf("%i", &total);
12 printf("\nParametro p supuesto: ");
13 scanf("%f", &p);
14 for(i = 1 ; i <= total ; i++){
15 printf("\nGenerado: %i", geometrica(p));
16 }
17 printf("\n\n\n");
18 system("PAUSE");
19 return 0;
20 }
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
Generado: 0
Generado: 1
Generado: 0
Generado: 0
Generado: 15
Generado: 1
Generado: 0
Generado: 0
Generado: 0
2.8.2.9 poisson(alpha)
Funci
on 2.8.26
int poisson(float alpha)
Descripcion: Esta funci
on genera n
umeros pseudoaleatorios con distribucion
Poisson de par
ametro .
1 #include "estadistica.h"
2
3 using namespace std;
4 int main(void){
5 float a; // parametro de la distribucion
6 int total, i;
7 printf("\nEste programa verifica que la funcion");
8 printf("\nint poisson(float alpha)");
9 printf("\nfuncione correctamente...\n");
10 printf("Cuantos numeros deseas generar? ");
11 scanf("%i", &total);
12 printf("\nParametro Alpha supuesto: ");
13 scanf("%f", &a);
14 for(i = 1 ; i <= 25 ; i++){
15 printf("\nGenerado: %i", poisson(a));
16 }
17 printf("\n\n\n");
18 system("PAUSE");
19 return 0;
20 }
Generado: 1
Generado: 598
Generado: 593
Generado: 579
Generado: 655
Generado: 585
Generado: 611
Generado: 604
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
Funci
on 2.8.27
double media(char filename[])
Descripci on: Esta funcion calcula la media aritmetica de los datos contenidos
en el archivo de nombre filename.
Funci
on 2.8.28
double desviacionStd(char filename[])
Descripci on: Esta funcion calcula la desviacion estandar de los datos con-
tenidos en el archivo de nombre filename.
1 #include "estadistica.h"
2 using namespace std;
3 int main(void){
4 char archivo[15]; // nombre del archivo...
5 printf("\nNombre del archivo: [Incluye extension] ");
6 scanf("%s", &archivo);
7 histograma(archivo, 20);
8 printf("\n\nMedia calculada: %f", media(archivo));
9 printf("\n\nDesviacion Estandar calculada: %f", desviacionStd(archivo));
10 printf("\n\n\n");
11 system("PAUSE");
12 return 0;
13 }
2.8.3 Simulaci
on del recurso e
olico
Un generador e
olico utiliza la energa cinetica del viento para generar electrici-
dad.
Por definici
on, 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 eolico
como el cilindro de altura v t y area de base igual al area A [m2 ] que barren las
aspas del generador. Entonces, por unidad de tiempo, el volumen de aire que
atraviesan las aspas del generador eolico es:
As que la energa cinetica del viento con velocidad v puede expresarse como:
1
P = Av 3 potencia (W)
2
El recurso e olico de dos sitios distintos se compara en base a la potencia eolica
especfica, es decir, por cada metro cuadrado de area que barren sus aspas.
Sabemos que la potencia eolica especfica vara con el cubo de la velocidad del
viento.
4 Puede accesar a mi p agina de Internet en: http://yalma.fime.uanl.mx/ efrain/
Para encontrar las notas vaya a Descargas, despues a Notas de mis Cursos, y finalmente a Mis
Notas
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.
Tambien, 3 3 1.4422 nos indica que si la velocidad del viento crece un 44.22%,
la potencia electrica generada aumentara al triple, mientras que si la velocidad
del viento disminuye en esa misma cantidad, la potencia generada disminuira a
la tercera parte.
Para velocidades de entrada del viento a las aspas del generador eolico, los
valores de Cp dependen de la proporcion v0 /v, alcanzando un maximo cuando
este cociente es igual a 1/3. Entonces, Cp = 16/27 0.5926.
La m
axima 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 disenos pr
acticos de aspas, el valor maximo 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 mas aspas.
2.8.4 Distribuci
on 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 atmosferico, con
la colaboraci
on del movimiento rotativo de la tierra, los patrones de viento
generalmente se repiten con periodicidad de un a no.
Las variaciones de la velocidad del viento se pueden describir por una funcion
de distribuci
on de probabilidad.
2.8.4.1 Distribuci
on Weibull
Para la distribuci
on Weibull con valor de k = 1 tenemos la distribucion expo-
nencial. En el caso k = 2 la distribucion se conoce como distribucion Rayleigh.
Este tipo de distribuci
on es el que presenta la velocidad de viento en muchos
sitios.
2.8.4.2 Distribuci
on Rayleigh
Distribuci
on Rayleigh:
2
2 xex para x > 0
f (x) =
0 para x 0
donde: > 0
2u u 2
(u) = 2
exp
c c
Para esta distribuci
on:
r
1
=
2
1
2 = 1
4
2.8.4.3 Distribuci
on de energa
Si definimos la funci
on de densidad de energa como:
Contribuci
on en kWh al a
no por las velocidades entre v y v + v
e=
v
podremos graficar esta distribucion y la distribucion de probabilidad de la ve-
locidad y conocer a partir de que velocidad el numero de horas que el viento
presenta esa velocidad, decrece mas rapido que v 3 . Este valor nos indicara un
decremento neto en la contribucion energetica anual global.
2.8.4.4 Anem
ometros digitales
La expresion anterior no toma en cuenta la densidad del aire, que tambien afecta
la cantidad de energa producida por el viento. Para calcular el recurso eolico
de un sitio se recomienda utilizar la siguiente formula:
n
1 X
Prmc = i vi3
2 n i=1
2.8.4.5 Predicci
on del recurso e
olico
Sin embargo, si la velocidad del viento puede pronosticarse con varias horas
de anticipaci on, podemos despachar la energa de una manera comoda. Alexi-
adis, et al5 , han propuesto una nueva tecnica para pronosticar la velocidad del
viento y la cantidad de energa producida con muchas horas de anticipacion. La
tecnica est
a basada en correlacion cruzada en sitios vecinos y redes artificiales
neuronales. La tecnica propuesta puede mejorar significativamente la precision
de las predicciones comparado con el modelo com unmente usado. El modelo
propuesto se calibra en diferentes sitios en un periodo de un ano.
2.8.6 Implementaci
on
Enseguida se muestra el c
odigo de la implementacion elaborada en el lenguaje
C++ .
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: Evaluaci
on del recurso e
olico de La Venta, Juchitan, Oaxaca. M. A. Borja, O. A.
Jaramillo, M. F. Morales. Instituto de Investigaciones Electricas. Temixco, Morelos, Mexico.
----------------------------------
----------------------------------
*/
#include <cstdio> // Librera b
asica...
#include <cstdlib> // Otra Librer a...
#include <iostream> // Funciones basicas: input/output
#include <math.h> // funciones matem aticas
#include <conio.h> // para usar: getche, getch
#include <fstream> // para grabar los datos generados...
//
double uniforme (void);
double weibull(double c, double k);
//
void duniforme(void);
void drayleigh(void);
void dweibull(void);
float windPower(double windSpeed);
/**************************************
Declaro la funci
on UNIFORME...
***************************************/
double uniforme(void){
// Esta funci
on genera un n
umero pseudoaleatorio
// en el intervalo (0,1) con distribuci
on uniforme.
return (1.0 * rand()/(1.0 * RAND_MAX));
}
/**************************************
Declaro la funci
on WEIBULL...
***************************************/
double weibull(double c, double k){
// Esta funci
on genera numeros pseudoaleatorios
// con distribucion Weibull
double x;
x = c * pow(-log(1 - uniforme()), 1/k);
return x;
}
/**************************************
Declaro la funci
on RAYLEIGH...
***************************************/
double rayleigh(double media){
// Esta funci
on genera numeros pseudoaleatorios
// con distribucion 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 funci
on DWEIBULL..
***************************************/
void dweibull(void){
/*
Para simular viento con distribucion Weibull...
*/
int I[24]; // los intervalos...
int max =0, min = 1000000;
//int total; // cuantos vamos a generar...
int i = 0, j; // contadores
double x; // el numero generado...
double escala; // para hacer la gr afica...
int factor; // para hacer la grafica...
//double k = 0.0, c = 1.0; // parametros
return;
} // Fin de la funci
on DWEIBULL
/**************************************
Declaro la funci
on DRAYLEIGH..
***************************************/
void drayleigh(void){
int I[24]; // los intervalos...
int max =0, min = 1000000;
int total; // cuantos vamos a generar...
int i, j; // contadores
int imax, imin;
double t;
double x; // el numero generado...
float sv3 = 0.0;
float densidadEnergetica;
float energia = 0; // Energia anual
float media; // parametro de la distribucion
double escala; // para hacer la gr afica...
int factor; // para hacer la grafica...
FILE* f = fopen("speedray.txt", "w+");
/**************************************
Declaro la funci
on WINDPOWER..
***************************************/
float windPower(double windSpeed){
/*
Esta funci
on calcula la energa producida por el generador
considerando la el teorema de Weltz, Densidad del aire = 1,000 kg/m3,
Area de rotor = 1 m2, v ---> generada por el programa,
windspeed (con distribuci
on 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
[R] Rayleigh.
[W] Weibull.
[C] Cancelar...
Ingrese una opcion: w
2.9 Esqueletos
Aqu encontrar
as partes de programas que pueden servir.
Declaraci
on 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>>
Ciclo infinito.
for (;;)
{
// Aqu
va el procedimiento...
}
/*
ifstream -> Significa Input - File - Stream
ofstream -> Significa Ouput - File - Stream
Pregunto si se logr
o abrir el archivo...
in_stream.open("misdatos.dat");
if (in_stream.fail())
{
cout << " No se logr
o abrir el archivo..."
exit(1); // Finaliza el programa
}
out_stream.open("misdatos.dat");
if (out_stream.fail())
{
cout << " No se logr
o abrir el archivo..."
exit(1); // Finaliza el programa
}
/*
La funci
on exit est
a definida en el archivo:
stdlib.h
de manera que debemos incluir en el pre
ambulo
del programa la instrucci
on:
#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.
*/
N
umeros de dgitos 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);
/*
Para utilizar los manipuladores en este c
odigo
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.
*/
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.
5. Se requiere un punto y coma (;) por cada cout utilizado. No utilices varios
; a
un si se extiende varios renglones.
6. La instrucci
on \n para indicar un salto de lnea siempre debe estar encerrado
dentro de las comillas. Posiblemente junto a una cadena de caracteres.
7. La instrucci
on endl; nunca debe estar encerrado dentro de las comillas.
8. Los n
umeros no deben contener comas. Usa punto (decimal) en su lugar.
11. Las constantes del tipo char deben encerrarse entre apostrofos ().
12. Las constantes del tipo string deben encerrarse entre comillas (").
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 % (m
odulo) debe ser usado con datos del tipo entero.
18. El operador para comparar la igualdad entre dos valores es: ==.
3.1 ficas
Fuentes bibliogra
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.
Los libros enlistados son los que mas he consultado, aunque leo otros mas para
conocer varias explicaciones de una misma herramienta y poder adquirir una
visi
on mas 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
Algoritmo, 8 Funciones
Asignaci
on, 13 Predefinidas, 22
Trigonometricas, 22
C
odigo, 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 comparacion, 15
Constantes, 12
Correr, 9 Palabras reservadas, 11
Programa, 8
Datos
Tipos de, 11 Sintaxis, 9
Formulas matematicas, 14
Ejemplo
Cadenas de caracteres, 41 Variable
Ciclo for, 49, 50, 5558 Definicion, 10
Ciclo while, 58 Variables
Condicional If, 46, 5153, 58 Declaracion, 12
Declarar constantes, 41
Formulas matem aticas, 42, 43, 45
Funciones matem aticas, 54, 55
Error
de Sintaxis, 9
Logico, 10
Mensajes de, 9
No hay ninguna garanta de que los codigos esten libres de cualquier tipo de
error.
Espero que este material pueda ser de ayuda a muchas personas que desean
aprender a programar en C++.
A
no de publicaci
on: Pendiente
Ultima revisi
on: August 19, 2008 7:59pm
efra.soto.a@gmail.com @
200
INDICE ALFABETICO
! Un p arrafo con este smbolo indica que debes poner especial atencion y
metabolizarla bien. Es muy importante.
Este p
arrafo tiene informacion que te gua de manera que no te confundas
con conceptos parecidos y vayas a entender una cosa por otra.
j Indica que el p
arrafo incluye un procedimiento que debes realizar bajo tu
propio riesgo.
L Indica que el p
arrafo 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.
o Indica que debes ponerte a practicar. Tienes que intentarlo por t mismo
y desarrollar algunas cosas. Nadie aprende en cabeza ajena.
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 parrafo se incluye la imagen referente a los
i p
arrafos que dan informacion.