Instituto Tecnológico de los Mochis

Nombre: Soberanes López Carmen

Johana
Numero de control:20440834
Carrera: Ingeniería química
Grupo: c3k
Materia: programación
Profesor: Edgard Gómez
Evidencia: unidad 5
5.1. Biblioteca matemática.
5.2. Biblioteca de números aleatorios.
5.3. Biblioteca gráfica.
5.4. Biblioteca definida por el programador.
La biblioteca cmath nos da una serie de
funciones para poder realizar operaciones
matemáticas complejas (potencias, raíces
cuadradas, senos, cosenos…). Algunas de las
más usadas:

• Podemos asignar a una variable el

valor de retorno de una función.
• Podemos mostrar el valor de
retorno de una función de manera
directa sin necesidad de
asignarlo a una variable.
• Las funciones trigonométricas
requieren que les pasen por
parámetro el valor del ángulo en
radianes

En la biblioteca Cmath también encontramos que contiene varias constantes

ya definidas y que por lo general ignoramos y que son muy útiles para facilitar
el trabajo.
Entre las constantes que contiene esta biblioteca podemos encontrar las
siguientes:

#include <iostream>
#include <cmath>

using namespace std;

int main()
{//Inicio Función Main
double cateto_1;
double cateto_2; //Declaración de Variables
double hipotenusa;

cout<<"ingrese cateto 1:"<<endl; //Pedir Cateto 1

cin>>cateto_1; //Guardar Cateto 1
cout<<"ingrese el cateto 2:"<<endl; //Pedir Cateto 2
cin>>cateto_2; //Guardar Cateto 2
hipotenusa=sqrt((cateto_1*cateto_1+cateto_2*cateto2)); //Uso de la
función sqrt Obtener Raíz Cuadrada
//Suma y multiplicación de catetos
cout<<"la hipotenusa es: "<<hipotenusa<<endl<<"adiós :D"; //Mostr
ar en pantalla el resultado obtenido

return 0;
}//Fin Función Main
 Los números aleatorios son de gran importancia en la
programación. Necesitas números aleatorios para hacer girar
unos dados, repartir cartas, posicionar enemigos en la
pantalla y tal vez hasta controlar sus movimientos. A veces
queremos que nuestro programa obtenga números de forma
aleatoria, por ejemplo, para simular una tirada de dados o el
reparto de cartas en un juego. En C de linux tenemos varias
funciones que nos permiten obtener estos valores aleatorios.

USO BASICO DE ESTAS FUNCIONES:

Algunas de las cosas que contamos aquí no son útiles para

aplicaciones más serias, en las que se requiere que la
secuencia de números aleatorios sea muy aleatoria,
impredecible, que no se repita hasta pasado muchos números,
etc, etc. Sin embargo, las explicaciones aquí presentadas
servirán para la mayoría de nuestros programas.

C++ define la función rand() para generar números

aleatorios, Esta función, cada vez que la llamamos, nos
devuelve un número entero aleatorio entre 0 y
el RAND_MAX (un número enorme, como de 2 mil
millones).
Sintaxis
int rand (void);

Como puedes observar, para usar rand() solo se invoca

la función y se asigna a cualquier variable entera, no
requiere parámetros.

De forma predeterminada rand() genera una valor pseudo aleatorio

comprendido entre 0 y el valor de RAND_MAX, RAND_MAX está definido
también el cstdlib.

Si queremos conocer el valor de RAND_MAX en nuestro sistema, simplemente

hacemos una llamada a dicha constante.
 cout << "El valor de RAND_MAX es este sistema es: " << RAND_MAX;

A continuación se muestra el uso de rand(), además se muestra como

obtener el valor de RAND_MAX para tu sistema.
// cpp_72_pseudoaleatorio.cpp
// Se ilustra el uso de la función rand() para generar números pseudoaleatorios
// 2019, Por http://about.me/carlosgbr
// Versión 1
// Revisa todo el código del tutorial en: https://github.com/carlosgbr/
// Compilado en https://www.onlinegdb.com/online_c++_compiler
#include <iostream>
#include <cstdlib>
using namespace std;

int main()
{
int a;

a = rand(); // Genera un valor entre 0 y RAND_MAX

cout << a << endl;
cout << "RAND_MAX para este equipo tiene un valor de: " << RAND_MAX;
return 0;
}

Podemos limitar el rango de números

aleatorios que entrega rand(), podemos
definir el valor inicial (el
predeterminado es 0) y el límite
superior.

Para definir un límite superior, se utiliza

la notación de módulo (%), a
continuación se indica el valor máximo
que se desea. por ejemplo.
valor = rand() % 2; //
Obtiene valores entre 0 y 1

Por ejemplo el código anterior permite simular el lanzamiento de una moneda, y en

general cualquier cosa que requiera un si o un no.
valor = rand() % 10; // Obtiene un número entre 0 y 9, nota que no incluye
el 10valorrnd = 10 + rand() % 20;
valor = rand() % 1500; // Obtiene un número entre 0 y 1499
valor = rand() % 65536 ; // Obtiene un número entre 0 y 65535, por ejemplo,
para elegir un puerto TCP/IP al azar
 Para definir el límite inicial utilizamos la
notación de suma, indicando el número desde el
cual se deben generar los números, por ejemplo:
valor = 10 + rand(); // Genera números
aleatorios a partir del 10
valor = 65 + rand(); // Genera números
aleatorios a partir del 65

Consideraciones al usar límites inferiores y superiores con rand()

Al definir un valor inicial ocurre un comportamiento que no se ve a primera vista

al usar un rango abierto, que sí es visible en rangos bien definidos, por ejemplo
considera la siguiente expresión:
valor = 10 + rand() % 20;

En este caso el rango inicia en 10, pero no termina en 20, termina en 30, de
modo que el rango de números generados comprenderá del 10 al 29

Si queremos que el rango de números generados comprenda del 1 al 10 la

expresión debe ser:
valor = 1 + rand() % 10;

Puedes observar ahora que cuando definimos un valor inicial y un valor final, el
valor final «se recorre» la cantidad del valor inicial, es decir, el valor final real
es la suma del valor inicial más el valor final.

EJEMPLO:

valor = 1 + rand() % 100; // Genera un valor entre 1 y 100

valor = 25 + rand() % 100; // Genera un valor entre 25 y 124
valor = rand() %51 ; // Genera un valor entre 0 y 50

Si requerimos, por ejemplo definir números aleatorios en el rango 10 al 25, lo

debemos expresar de la siguiente forma:
valor = 10 + rand() % (26-10) //Restamos la cantidad que se "recorre" el rango

de modo que podemos expresar todos los casos con una fórmula general que se
aplica a cualquier caso:
variable = limite_inferior + rand() % (limite_superior +1 - limite_inferior);
en donde, variable, variable entera para almacenar el número generado
limite_inferior, valor inicial del rango de valores generados, el número
generado puede incluir éste número rand(), función para generar números
pseudo aleatorios, requiere la librería cstdlib (limite_superior + 1 –
limite_inferior), define el valor superior del rango que se utilizará para obtener
números aleatorios.
límite superior + 1, límite superior del rango deseado de números aleatorios, el
«+ 1» es necesario debido a que por definición el límite superior es igual
a limite_superior – 1, de esta forma se «neutralizan» quedando el límite
superior como lo queremos.

Si ejecutamos varias veces nuestro programa, la

secuencia de números aleatorios se repite.
Imaginemos que tenemos un programa que escribe
3 número aleatorios entre 0 y 10. Lo ejecutamos
una vez y sale, por ejemplo 4, 7 y 9. Lo ejecutamos
por segunda vez y vuelve a salir 4, 7 y 9. La tercera
vez sale lo mismo y cuando ya nos hemos hartado
de ejecutar, vuelve a salir lo mismo. El problema es
que rand() "calcula" los números aleatorios. Parte
de un número inicial (llamado semilla), echa unas
cuentas y saca un número aleatorio. Para el
segundo número,

echa unas cuentas con el resultado anterior y saca

un segundo número y así sucesivamente. Si
volvemos a ejecutar el programa desde el principio,
el número inicial (la semilla) que usa rand() es el
mismo, con lo que la secuencia de números
aleatorios es la misma, ya que las cuentas son las
mismas.

Para evitar este problema tenemos la función srand(), a la que se le pasa de

parámetro un número que se utilizará como número inicial para las cuentas.
A esta función sólo debemos llamarla una vez en nuestro programa.

No podemos ponerle un número fijo, porque entonces no hemos hecho

nada. No podemos ponerle un número obtenido con rand(), porque la
primera vez siempre nos dará el mismo y el resultado será igual que si le
ponemos un número fijo.
Hay dos números que se utilizan habitualmente para ello:

La fecha/hora del sistema. Este valor cambia si ejecutamos el

programa en distinto instante de tiempo. Tendriamos que
arrancar el programa dos veces en el mismo segundo para
obtener la misma secuencia de números aleatorios. En C de
linux esta fecha/hora se obtiene con la función time()

srand (time(NULL));

El número de proceso del programa. El primer programa que se

arranca cuando se enciende el ordenador con el sistema
operativo linux, tiene el número de proceso 1, el segundo el 2, el
tercero el 3 y así sucesivamente. Cuando arrancamos nuestro
programa, se le asignará el número que le toque, por ejemplo, el
215. Cuando lo volvamos a arrancar, se le asignará el que le toque
(puede ser 216 si no hemos ejecutado nada entre medias o 345, si
nos hemos entretenido con otras cosas). Después de ejecutar
nuestro programa varios miles de veces, el número de proceso
puede que se repita, pero ya no nos acordaremos de la secuencia
que se sacó la primera vez. El número de proceso se obtiene
con getpid()

srand (getpid());

A esta función sólo hay que llamarla una vez al principio de

nuestro programa. Cada vez que la llamemos, estaremos
reiniciando los cálculos de números aleatorios desde el principio,
con lo que se repetirá todo.

Tenemos la función drand48() que

¿Y si queremos un
número aleatorio con
decimales?
nos devuelve un número aleatorio
con decimales entre 0.0 (incluido,
puede salir el 0,0) y 1.0 (excluido,
nunca saldrá 1.0). A partir de ahí es
fácil transformarlo al rango que
queramos. Si queremos un rango
entre 10.0 y 20.0 (o
entre M y N siendo N mayor que M y
ambos con decimales, aunque sean
.0)
 #include <stdlib.h>
...
numero = drand48() * (20.0-10.0) + 10.0;
numero = drand48() * (N-M) + N;

De la misma forma que antes, la secuencia de números aleatorios se

repetirá cada vez que ejecutemos nuestro programa y de igual manera,
tenemos manera de cambiar la "semilla" de esa secuencia. Hay que llamar a
la función srand48() pasándole un entero que sea distinto en cada ejecución
del programa. Nuevamente, tenemos las dos opciones anteriores.

srand48(time(NULL));
srand48(getpid());

BIBLIOTECA GRAFICAC ++ Proporciona una biblioteca de funciones

gráficas (GRAFHISCS.H) como suplemento a las bibliotecas de los modelos
de memoria estándar, incorporado bibliotecas que son específicas del
modelo de memoria. Al utilizar el entorno de desarrollo integrado de c++.
Se produce la carga automática
delmodelo de memoria adecuado, que coincide con el modelo de memorias
eleccionado (consulte el menú que se abre abajo optians/copiler/Medel).
La biblioteca gráfica, sin embargo, está separada y no queda incluida
automáticamente en tiempo de compilación. Por este motivo existen otras
dos opciones de utilización de las funciones graficas con c++; la utilización
de los archivos.prj o la incorporación de GRAFHICS.LIB e una o más de la
biblioteca estándar.

Recuerde que el archivo de cabecera para gráficos debe ser referido en

cada uno de los códigos fuentes antes de utilizar cualquier función gráfica.
En ese caso la línea fuente #include<graphics.h> debería aprender en todos
los módulos del código. Además, las funciones gráficas no funcionarían si
se utiliza el modelo de memoria TINY, dada su limitación de memoria. Los
modelos con más memoria dejan mayor Cantidad de esta para los
programas del usuario.
 La Biblioteca de gráficos GD es una biblioteca de software para
manipular imágenes creada por Thomas Boutell y otros colaboradores.
Está programada en C, pero se han desarrollado interfaces para otros
lenguajes de programación. Puede crear y manipular imágenes en
formato GIF, JPEG, PNG, y WBMP.

xWidgets son unas bibliotecas multiplataforma y libres, con la ventaja

que nos permite producir o usar el código como privativo (cuando se
trata de software empresarial por ejemplo), hechos y creadas para el
desarrollo de interfaces gráficas en C++.Su interfaz gráfica se basa en
bibliotecas nativas, con lo que obtendrán gráficas casi idénticas al del
entorno que usen y resultan muy portables entre distintos sistemas
operativos. Están disponibles para Windows, MacOS, GTK+, Motif,
OpenVMS y OS/2.

Las funciones que se han utilizado hasta ahora son funciones que el
lenguaje de programación ha predefinido en sus bibliotecas o
librerías. Sin embargo, también es posible que el programador defina
y utilice sus propias funciones.

Las funciones definidas por el programador se escriben “fuera” de la

función main. Si se recuerda, uno de los objetivos del uso de las
funciones es la descomposición de problemas complejos y el trabajo
en grupo. El siguiente es un ejemplo de una definición de una
función. Se utiliza antes de presentar la sintaxis formal de modo que
nos podamos familiarizar con la terminología:

Double square(double numero)

{
Double cuadrado;
Cuadrado = numero * numero;
Return cuadrado;
}
El valor de dicha variable (o el valor de dicha constante) constituye el
valor de regreso de la función. El tipo del valor que regresa la función
debe ser consistente con el tipo del valor de regreso especificado en el
encabezado de la función. Observe que, en este ejemplo, el valor de
regreso de la función (tipo de la variable llamada cuadrado) es doublé,
al igual que el tipo de valor de regreso especificado en el encabezado.

Algo similar es necesario para funciones definidas por el programador.

Ese algo es que, después de las directivas include pero antes de la
función main, es necesario escribir el prototipo de la función. El
prototipo de la función no es más que el encabezado de la función
seguido de punto y coma.

#include<iostream>
#include<cmath>
#define PI 3.14159
Using namespace std;

Int main () {
Doublé raíz= sqrt (100.0);
Cout<<raíz<<endl;//raíz se 100
Cout<<pow(2.0,3.o)<<endl;//2^3
Cout<<sin(PI/6)<<endl;//Seno de 30
Return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
// Ejemplo aprenderaprogramar.com
int main() {
double M = -5.75; int N = 7; double Pi = 3.14159; //Equivale a 180
grados sexagesimales
printf ("El valor absolucto de M es %g y el de N es %g\n", fabs(M),
fabs(N));
printf ("El coseno de Pi es %g\n", cos(Pi)); printf ("2
elevado al cubo vale %g\n", pow(2, 3));
printf ("El numero pi redondeado con ceil vale %g\n", ceil(Pi));
printf ("M redondeado con ceil vale %g\n", ceil(M));
printf ("El numero pi redondeado con floor vale %g\n", floor(Pi));
printf ("M redondeado con floor vale %g\n", floor(M)); printf ("-M
redondeado con floor vale %g\n", floor(-M));
printf ("El numero e vale %g\n", exp(1)); printf ("El logaritmo
neperiano de e vale %g\n", log(exp(1)));
 printf ("El logaritmo decimal de 100 vale %g\n", log10(100));
printf ("La raiz cuadrada de 81 vale %g\n", sqrt(81));
return 0;
}

#include <iostream>
#include <cmath>

using namespace std;

int main()
{//Inicio Función Main
double cateto_1;
double cateto_2; //Declaración de Variables
double hipotenusa;

cout<<"ingrese cateto 1:"<<endl; //Pedir Cateto 1

cin>>cateto_1; //Guardar Cateto 1
cout<<"ingrese el cateto 2:"<<endl; //Pedir Cateto 2
cin>>cateto_2; //Guardar Cateto 2
hipotenusa=sqrt((cateto_1*cateto_1+cateto_2*cateto2)); //Uso de la
función sqrt Obtener Raíz Cuadrada
//Suma y multiplicación de catetos
cout<<"la hipotenusa es: "<<hipotenusa<<endl<<"adiós :D"; //Mostrar
en pantalla el resultado optenido

return 0;
}//Fin Función Main

// cpp_75_aleatorio_semilla.cpp
// Se ilustra el uso de la semilla srand y la generación de "verdaderos"
// números aleatorios
// 2019, Por http://about.me/carlosgbr
// Versión 1
// Revisa todo el código del tutoral en: https://github.com/carlosgbr/
// Compilado en https://www.onlinegdb.com/online_c++_compiler
#include <iostream>
#include <cstdlib> // rand, srand
#include <ctime> // time
using namespace std;
int main()
{
int valor = 0;
srand(time(NULL));

// Simulamos calificaciones en el rango de 5 a 10;

for (int i=1; i<=20; i++) {
valor = 5 + rand()%(11-5);

cout << "Calificación Simulada" << i << ": " << valor <<
"\t\t\t\t";
// cpp_76_adivinanumero.cpp
// Se implementa un sencillo juego de "Adivina el número, el usuario
tiene 2
// oportunidades en un rango de 1 a 10
// 2019, Por http://about.me/carlosgbr
// Versión 1
// Revisa todo el código del tutoral en:
https://github.com/carlosgbr/
// Compilado en https://www.onlinegdb.com/online_c++_compiler
#include <iostream>
#include <cstdlib> // rand, srand
#include <ctime> // time
using namespace std;
int main()
{
int valorrnd = 0; // Número que debemos adivinar
int valorusr = 0; // Número introducido por el usuario
int contador = 0; // Para registrar el número de
iteraciones
srand(time(NULL)); // Generamos semilla basada en el reloj

valorrnd = 1+rand()%10;
cout << "Este programa genera un valor entre 1 y 10, tienes 2
oportunidades" << endl;
cout << "para acertar el número correcto." << endl;
do {
contador += 1;
cout << "Escribe un número entre 1 y 10" << endl;
cin >> valorusr;
if (valorusr == valorrnd) {
cout << "Ganaste!, el número es correcto" << "(" <<
valorrnd << ")";
break;
} else {
cout << "Lo siento, el número no es ese." << endl <<
endl;
}
}
while (contador < 2)
if (contador = 2) {
cout << "Perdiste, más suerte para la próxima, el número es:
" << valorrnd;
}
return 0;
}
<?php

// create image
$image = imagecreatetruecolor(100, 100);

// allocate some colors

$white = imagecolorallocate($image, 0xFF, 0xFF, 0xFF);
$gray = imagecolorallocate($image, 0xC0, 0xC0, 0xC0);
$darkgray = imagecolorallocate($image, 0x90, 0x90, 0x90);
$navy = imagecolorallocate($image, 0x00, 0x00, 0x80);
$darknavy = imagecolorallocate($image, 0x00, 0x00, 0x50);
$red = imagecolorallocate($image, 0xFF, 0x00, 0x00);
$darkred = imagecolorallocate($image, 0x90, 0x00, 0x00);

// make the 3D effect

for ($i = 60; $i > 50; $i--) {
imagefilledarc($image, 50, $i, 100, 50, 0, 45, $darknavy,
IMG_ARC_PIE);
imagefilledarc($image, 50, $i, 100, 50, 45, 75 , $darkgray,
IMG_ARC_PIE);
imagefilledarc($image, 50, $i, 100, 50, 75, 360 , $darkred,
IMG_ARC_PIE);
}

imagefilledarc($image, 50, 50, 100, 50, 0, 45, $navy, IMG_ARC_PIE);

imagefilledarc($image, 50, 50, 100, 50, 45, 75 , $gray, IMG_ARC_PIE);
imagefilledarc($image, 50, 50, 100, 50, 75, 360 , $red, IMG_ARC_PIE);

// flush image
header('Content-type: image/png');
imagepng($image);
imagedestroy($image);
?>

#include<stdio.h>/* el header genérico de la biblioteca*/

#include<g2.h>/* el header especifico para manipular ventanas de
X11*/
#include<g2_X11.h>
Int main()
{
Int d;/*para identificar el d9ispositivo*/
d=g2_open_X11(100,100;/* abre una ventana de 100x100, referenciada
por d*/
getchard();/* espera antes de cerrar la centana*/
g2_close(d);/*cierra el dispositivo (ventana)*/
return0; }
 #include <iostream.h> #include <stdlib.h>
double square(double numero); int main()
/* Prototipo de la funcion*/
{
}
/* Este programa es solo un ejemplo de la definicion y uso de una
funcion definida por el programador*/
double x,y,z; cin>>x>>y;
z = square(x);/* Llamado a la funcion*/ z = z * y;
cout<<"n"; cout<<z; cout<<"n";
system("PAUSE"); return 0;
/* Esta funcion calcula el cuadrado de un numero*/ double
square(double numero)
{
double cuadrado; cuadrado = numero * numero; return cuadrado;
{

#include <winbgim.h>
int main()
{
initwindow(400,300); // Abre una ventana gráfica de
400x300 pixeles
moveto(0,0); // Pone el cursor en 0,0
lineto(50,50); // Dibuja una línea desde 0,0
hasta 50,50
while(!kbhit()); // Espera a que el usuario
presione una tecla
closegraph(); // Cierra la ventana gráfica
return 0;
}

using namespace std;

int main ()
{
// Se genera una semilla diferente cada vez (basada en el tiempo
exacto de ejecución)
// Se debe llamar siempre, para generar números realmente
diferentes cada vez
// La funciçon time viene de la libtrería time.h
srand (time(NULL));

cout << ("Se va a generar un numero aleatorio ....\n");

cout << ("El numero generado es : ");
cout << rand(); //Se genera el número con rand y se muestra en
pantalla
return 0;
}