simulacion con c++

Universidad Nacional Federico Villarreal

Facultad de Ingeniería Electrónica e Informática Escuela de Ingeniería Informática

Taller de Simulación de Sistemas

Informáticos y Empresariales

Prof. Ing. Ciro Rodríguez

------------------- 26 -------------------

ALEATORIOS

------------------- 26 -------------------

------------------- 26 -------------------

//Numero aleatorio estatico

#include <iostream.h>

#include <iomanip.h>

#include <cstdlib>

int main()

{

for ( int contador = 1; contador <= 20; contador++ )

{

cout << setw( 10 ) << ( 1 + rand() % 6 );

if ( contador % 5 == 0 )

cout << endl;

}

return 0;

}

------------------- 27 -------------------

//



#include <cstdlib>

int main()

{

int frecuencia1 = 0;






int cara;

for ( int tiro = 1; tiro <= 6000; tiro++ )

{

cara = 1 + rand() % 6;

switch ( cara ) {

case 1:

++frecuencia1;

break;

case 2:

++frecuencia2;

break;

case 3:

++frecuencia3;

break;

case 4:

++frecuencia4;

break;

case 5:

++frecuencia5;

break;

case 6:

++frecuencia6;

break;

default:

cout << "¡El programa no debe llegar hasta aquí!";

}

}

cout << "Cara" << setw( 13 ) << "Frecuencia"

<< "\n 1" << setw( 13 ) << frecuencia1





<< "\n 6" << setw( 13 ) << frecuencia6 << endl;

return 0;

}

------------------- 28 -------------------



#include <cstdlib>// contiene srand y rand

int main()

{

unsigned semilla;

cout << "Introduzca semilla: ";

cin >> semilla;

srand( semilla );

for ( int contador = 1; contador <= 10; contador++ )

{

cout << setw( 10 ) << ( 1 + rand() % 6 );

if ( contador % 5 == 0 )

cout << endl;

}

return 0;

}

------------------- 29 -------------------


#include <cstdlib>

#include <ctime> // contiene prototipo de función time

int tiraDados( void ); // prototipo de la función

int main()

{

enum Status { CONTINUA, GANA, PIERDE };

int suma;

int miPunto;

Status estadoJuego; // CONTINUA, GANA o PIERDE

srand( time( 0 ) ); // randomiza números mediante time

suma = tiraDados(); // primer tiro de dados

switch ( suma )

{

case 7:

case 11:

estadoJuego = GANA;

break;

case 2:

case 3:

case 12:

estadoJuego = PIERDE;

break;

default:

estadoJuego = CONTINUA;

miPunto = suma;

cout << "El punto es " << miPunto << endl;

break; // opcional

}

while ( estadoJuego == CONTINUA )

{

suma = tiraDados(); // tira dados nuevamente

if ( suma == miPunto ) // gana por puntos

estadoJuego = GANA;

else

if ( suma == 7 ) // pierde por obtener 7

estadoJuego = PIERDE;

}

if ( estadoJuego == GANA )

cout << "El jugador gana" << endl;

else

cout << "El jugador pierde" << endl;

return 0;

}

int tiraDados( void )

{

int dado1;

int dado2;

int sumaTrabajo;

dado1 = 1 + rand() % 6; // aleatorio del dado1

dado2 = 1 + rand() % 6; // aleatorio del dado2

sumaTrabajo = dado1 + dado2;

cout << "El jugador tiro " << dado1 << " + " << dado2

<< " = " << sumaTrabajo << endl;

return sumaTrabajo; // devuelve suma de los dados

}

------------------- 31 -------------------



unsigned long factorial( unsigned long ); // prototipo de la función

int main()

{

for ( int i = 0; i <= 10; i++ )

cout << setw( 2 ) << i << "! = "

<< factorial( i ) << endl;

return 0; // indica terminació exitosa

}

unsigned long factorial( unsigned long numero )

{

if ( numero <= 1 )

return 1;

else

return numero * factorial( numero - 1 );

}

------------------- 32 -------------------


unsigned long fibonacci( unsigned long );

int main()

{

unsigned long resultado, numero;

cout << "Introduzca un entero: ";

cin >> numero;

resultado = fibonacci( numero );

cout << "Fibonacci(" << numero << ") = " << resultado << endl;

return 0;

}

unsigned long fibonacci( unsigned long n )

{

if ( n == 0 || n == 1 )

return n;

else

return fibonacci( n - 1 ) + fibonacci( n - 2 );

}

------------------- 33 -------------------



int main()

{

const int tamanoArreglo = 10;

int n[ tamanoArreglo ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };

cout << "Elemento" << setw( 13 ) << "Valor"

<< setw( 17 ) << "Histograma" << endl;

for ( int i = 0; i < tamanoArreglo; i++ )

{

cout << setw( 7 ) << i << setw( 13 )

<< n[ i ] << setw( 9 );

for ( int j = 0; j < n[ i ]; j++ )

cout << '*';

cout << endl;

}

return 0;

}

------------------- 52 -------------------

// Tiro de un dado de seis lados 6000 veces



#include <cstdlib>

#include <ctime>

int main()

{

const int tamanoArreglo = 7;

int frecuencia[ tamanoArreglo ] = { 0 };

srand( time( 0 ) );

// tira los dados 6000 veces

for ( int tiro = 1; tiro <= 6000; tiro++ )

++frecuencia[ 1 + rand() % 6 ];

cout << "Cara" << setw( 13 ) << "Frecuencia" << endl;

// muestra la frecuencia de los elementos 1 a 6 en formato tabular

for ( int cara = 1; cara < tamanoArreglo; cara++ )

cout << setw( 4 ) << cara

<< setw( 13 ) << frecuencia[ cara ] << endl;

return 0;

}

------------------- 52 -------------------

// Análisis de encuestas.media,mediana y moda de datos.

#include <iostream>

using std::fixed;

using std::showpoint;


void media( const int [], int );

void mediana( int [], int );

void moda( int [], int [], int );

void ordenaBurbuja( int[], int );

void despliegaArreglo( const int[], int );

int main()

{

const int tamanoRespuestas = 99; // tamaño del arreglo respuestas

int frecuencia[ 10 ] = { 0 }; // inicializa el arreglo frecuencia

// inicializa el arreglo respuestas

int respuestas[ tamanoRespuestas ] =

{ 6, 7, 8, 9, 8, 7, 8, 9, 8, 9,

7, 8, 9, 5, 9, 8, 7, 8, 7, 8,

6, 7, 8, 9, 3, 9, 8, 7, 8, 7,

7, 8, 9, 8, 9, 8, 9, 7, 8, 9,

6, 7, 8, 7, 8, 7, 9, 8, 9, 2,

7, 8, 9, 8, 9, 8, 9, 7, 5, 3,

5, 6, 7, 2, 5, 3, 9, 4, 6, 4,

7, 8, 9, 6, 8, 7, 8, 9, 7, 8,

7, 4, 4, 2, 5, 3, 8, 7, 5, 6,

4, 5, 6, 1, 6, 5, 7, 8, 7 };

// procesa las respuestas

media( respuestas, tamanoRespuestas );

mediana( respuestas, tamanoRespuestas );

moda( frecuencia, respuestas, tamanoRespuestas );

return 0; // indica terminación exitosa

} // fin de main

// calcula el promedio de todos los valores correspondientes a las respuestas

void media( const int resp[], int tamanoArreglo )

{

int total = 0;

cout << "********\n Media\n********\n";

// total del valor de las respuestas

for ( int i = 0; i < tamanoArreglo; i++ )

total += resp[ i ];

// da formato y despliega los resultados

cout << fixed << setprecision( 4 );

cout << "La media es el valor promedio de los elementos\n"

<< "de datos. La media es igual al total de todos \n"

<< "los elementos de datos divididos entre el numero\n"

<< "de elementos de datos (" << tamanoArreglo

<< "). El valor de la media para \nesta ejecución es: "

<< total << " / " << tamanoArreglo << " = "

<< static_cast< double >( total ) / tamanoArreglo

<< "\n\n";

} // fin de la función media

// ordena el arreglo y determina el valor de la mediana de los elementos

void mediana( int resp[], int tamano )

{

cout << "\n********\n Mediana\n********\n"

<< "El arreglo desordenado de respuestas es";

despliegaArreglo( resp, tamano ); // muestra el arreglo desordenado

ordenaBurbuja( resp, tamano ); // ordena el arreglo

cout << "\n\nEl arreglo ordenado es";

despliegaArreglo( resp, tamano ); // muestra el arreglo ordenado

// displiega la mediana

cout << "\n\nLa mediana es el elemento " << tamano / 2

<< " del\narreglo ordenado de " << tamano

<< " elementos.\nPara esta ejecucion la mediana es "

<< resp[ tamano / 2 ] << "\n\n";

} // fin de la función mediana

// determina la respuesta más frecuente

void moda( int frec[], int resp[], int tamano )

{

int masGrande = 0; // representa la frecueancia más grande

int valorModa = 0; // representa la respuesta más frecuente

cout << "\n********\n Moda\n********\n";

// inicializa las frecuencias en 0

for ( int i = 1; i <= 9; i++ )

frec[ i ] = 0;

// resume las frecuencias

for ( int j = 0; j < tamano; j++ )

++frec[ resp[ j ] ];

// muestra los encabezados para las columnas de resultados

cout << "Respuestas" << setw( 11 ) << "Frecuencia"

<< setw( 19 ) << "Histograma\n\n" << setw( 55 )

<< "1 1 2 2\n" << setw( 56 )

<< "5 0 5 0 5\n\n";

// despliega resultados

for ( int rating = 1; rating <= 9; rating++ )

{

cout << setw( 8 ) << rating << setw( 11 )

<< frec[ rating ] << " ";

// da seguimiento al valor de la moda y al valor de la frecuencia más grande

if ( frec[ rating ] > masGrande )

{

masGrande = frec[ rating ];

valorModa = rating;

} // fin de if

// muestra las barras del histograma que representa los valores de frecuencia

for ( int k = 1; k <= frec[ rating ]; k++ )

cout << '*';

cout << '\n'; // comienza una nueva línea de salida

} // fin del for externo

// despliega el valor de la moda

cout << "La moda es el valor mas frecuente.\n"

<< "Para esta ejecucion la moda es " << valorModa

<< " la cual tiene una ocurrencia de " << masGrande << " veces." << endl;

} // fin de la función moda

// función que ordena el arreglo mediante el algoritmo del método de la burbuja

void ordenaBurbuja( int a[], int tamano )

{

int mantiene; // ubicación temporal utilizada para intercambiar elementos

// ciclo para controlar el número de pasadas

for ( int pasada = 1; pasada < tamano; pasada++ )

// ciclo para controlar el número de comparaciones por pasada

for ( int j = 0; j < tamano - 1; j++ )

// intercambia elementos desordenados

if ( a[ j ] > a[ j + 1 ] )

{

mantiene = a[ j ];

a[ j ] = a[ j + 1 ];

a[ j + 1 ] = mantiene;

} // fin de if

} // fin de la función ordenaBurbuja

// muestra el contenido del arreglo (20 valores por fila)

void despliegaArreglo( const int a[], int tamano )

{

for ( int i = 0; i < tamano; i++ )

{

if ( i % 20 == 0 ) // comienza una nueva línea cada 20 valores

cout << endl;

cout << setw( 2 ) << a[ i ];

} // fin de for

} // fin de la función despliegaArreglo

------------------- 60 -------------------

// Búsqueda lineal en un arreglo.

#include <iostream>

using std::cout;

using std::cin;

using std::endl;

int busquedaLineal( const int [], int, int ); // prototipo

int main()

{

const int tamanoArreglo = 100; // tamaño del arreglo a

int a[ tamanoArreglo ]; // crea el arreglo a

int claveBusqueda; // valor a localizar dentro de a

for ( int i = 0; i < tamanoArreglo; i++ ) // crea algunos datos

a[ i ] = 2 * i;

cout << "Introduce la clave de busqueda entera: ";

cin >> claveBusqueda;

// intenta localizar claveBusqueda dentro del arreglo a

int elemento = busquedaLineal( a, claveBusqueda, tamanoArreglo );

// despliega los resultados

if ( elemento != -1 )

cout << "Encontre valor en el elemento " << elemento << endl;

else

cout << "Valor no encontrado" << endl;


} // fin de main

// compara la clave con cada elemento del arreglo hasta encontrar su

// ubicación o hasta que se alcanza el final del arreglo; devuelve el subíndice

// del elemento si es la clave o -1 si ésta no se encontró

int busquedaLineal( const int arreglo[], int clave, int tamanoDelArreglo )

{

for ( int j = 0; j < tamanoDelArreglo; j++ )

if ( arreglo[ j ] == clave ) // si se encuentra ,

return j; // devuelve la ubicación de la clave

return -1; // la clave no se encontró

} // fin de la función busquedaLineal

------------------- 61 -------------------

// Búsqueda binaria dentro de un arreglo.

#include <iostream>

using std::cout;

using std::cin;

using std::endl;

#include <iomanip>

using std::setw;

// prototipo de la función

int busquedaBinaria( const int [], int, int, int, int );

void despliegaEncabezado( int );

void despliegaFila( const int [], int, int, int, int );

int main()

{

const int tamanoArreglo = 15; // tamaño del arreglo a

int a[ tamanoArreglo ]; // crea el arreglo a

int clave; // valor a localizar en a

for ( int i = 0; i < tamanoArreglo; i++ ) // crea algunos datos

a[ i ] = 2 * i;

cout << "Introduzca un numero entre 0 y 28: ";

cin >> clave;

despliegaEncabezado( tamanoArreglo );

// búsqueda de la clave en el arreglo a

int resultado =

busquedaBinaria( a, clave, 0, tamanoArreglo - 1, tamanoArreglo );

// despliega resultados

if ( resultado != -1 )

cout << '\n' << clave << " se encuentra en el elemento del arreglo "

<< resultado << endl;

else

cout << '\n' << clave << " no se encontro" << endl;


} // fin de main

// función para realizar la búsqueda binaria dentro de un arreglo

int busquedaBinaria( const int b[], int claveBusqueda, int bajo, int alto, int tamano )

{

int central;

// repetición hasta que el subíndice bajo sea mayor que el subíndice alto

while ( bajo <= alto )

{

// determina el elemento central del subarreglo en el que se busca

central = ( bajo + alto ) / 2;

// despliega el subarreglo utilizado en este ciclo de la iteración

despliegaFila( b, bajo, central, alto, tamano );

// si claveBusqueda coincide con el elemento central, devuelve el elemento central

if ( claveBusqueda == b[ central ] ) // coincide

return central;

else

// si claveBusqueda es menor que el elemento central,

// establece el nuevo elemento alto

if ( claveBusqueda < b[ central ] )

alto = central - 1; // busca bajo hasta el final del arreglo

// si claveBusqueda es mayor que el elemento central,

// establece el nuevo elemento bajo

else

bajo = central + 1; // busca bajo hasta el final del arreglo

}

return -1; // no se encontró claveBusqueda

} // fin de la función busquedaBinaria

// despliega el encabezado de salida

void despliegaEncabezado( int tamano )

{

cout << "\nSubindices:\n";

// muestra encabezados de columnas

for ( int j = 0; j < tamano; j++ )

cout << setw( 3 ) << j << ' ';

cout << '\n'; // comienza nueva línea de salida

// despliega línea de caracteres -

for ( int k = 1; k <= 4 * tamano; k++ )

cout << '-';

cout << endl; // comienza nueva línea de salida

} // fin de la función despliegaEncabezado

// imprime despliega una fila de salida resultados que muestra la paerte

// actual del arreglo que está en proceso

void despliegaFila( const int b[], int bajo, int cen, int alto, int tamano )

{

// repite a través de todo el arreglo

for ( int m = 0; m < tamano; m++ )

// despliega espacios si se encuentra fuera del rango del subarreglo

if ( m < bajo || m > alto )

cout << " ";

// despliega el elemento central marcado con un *

else

if ( m == cen ) // marca el elemento central

cout << setw( 3 ) << b[ m ] << '*';

// despliega otros elementos del subarreglo

else

cout << setw( 3 ) << b[ m ] << ' ';

cout << endl; // comienza nueva línea de salida

} // fin de la función despliegaFila

------------------- 26 -------------------

PERMUTACIONES

------------------- 26 -------------------

------------------- 26 -------------------

//Realiza todas las permutaciones posibles de las letras de la palabra ABCDE


#include <string.h>

void Permutaciones(char *, int l=0);

int main(int argc, char *argv[])

{

char palabra[] = "ABCDE";

Permutaciones(palabra);

return 0;

}

void Permutaciones(char * cad, int l)

{

char c; /* variable auxiliar para intercambio */

int i, j; /* variables para bucles */

int n = strlen(cad);

for(i = 0; i < n-l; i++)

{

if(n-l > 2) Permutaciones(cad, l+1);

else cout <<cad << ", ";

/* Intercambio de posiciones */

c = cad[l];

cad[l] = cad[l+i+1];

cad[l+i+1] = c;

if(l+i == n-1)

{

for(j = l; j < n; j++) cad[j] = cad[j+1];

cad[n] = 0;

}

}

}

------------------- PERMUTACIONES-------------------

------------------- 26 -------------------

// Programa para barajar y repartir cartas.

#include <iostream>

using std::cout;

using std::left;

using std::right;

#include <iomanip>

using std::setw;

#include <cstdlib> // prototipos para rand y srand

#include <ctime> // prototipos para time

// prototipos

void barajar( int [][ 13 ] );

void repartir( const int [][ 13 ], const char *[], const char *[] );

int main()

{

// inicializa el arreglo palo

const char *palo[ 4 ] =

{ "Corazones", "Diamantes", "Treboles", "Espadas" };

// inicializa el arreglo cara

const char *cara[ 13 ] =

{ "As", "Dos", "Tres", "Cuatro",

"Cinco", "Seis", "Siete", "Ocho",

"Nueve", "Diez", "Joto", "Quina", "Rey" };

// inicializa arreglo baraja

int baraja[ 4 ][ 13 ] = { 0 };

srand( time( 0 ) ); // semilla del generador de números aleatorios

barajar( baraja );

repartir( baraja, cara, palo );


} // fin de main

// baraja las cartas

void barajar( int wBaraja[][ 13 ] )

{

int fila;

int columna;

// para cada una de las 52 cartas, elige la posición de la baraja al azar

for ( int carta = 1; carta <= 52; carta++ ) {

// elije nueva ubicación al azar hasta encontrar una posición desocupada

do {

fila = rand() % 4;

columna = rand() % 13;

} while( wBaraja[ fila ][ columna ] != 0 ); // fin de do/while

// coloca el número de la carta en la posición elegida de la baraja

wBaraja[ fila ][ columna ] = carta;

} // fin del for

} // fin de la función barajar

// reparte las cartas de la baraja

void repartir( const int wBaraja[][ 13 ], const char *wCara[],

const char *wPalo[] )

{

// para cada una de las 52 cartas

for ( int carta = 1; carta <= 52; carta++ )

// ciclo a través de las filas en wBaraja

for ( int fila = 0; fila <= 3; fila++ )

// ciclo a través de las columnas de wBaraja para la fila actual

for ( int columna = 0; columna <= 12; columna++ )

// si wBaraja contiene la carta actual, despliega la carta

if ( wBaraja[ fila ][ columna ] == carta )

{

cout << setw( 6 ) << right << wCara[ columna ]

<< " de " << setw( 9 ) << left

<< wPalo[ fila ]

<< ( carta % 2 == 0 ? '\n' : '\t' );

} // fin de if

} // fin de la función repartir

---

---------------- DERIVADA ---------------

*************** DERIVADA ***************

---------------- DERIVADA ---------------

------------------- DERIVADA -------------------

// 4 3 2

//Desarrollo de derivadas de la forma ax + bx + cx + dx + e

#include<iostream.h>

#include<math.h>

double primer( double );

double segundo( double);

double tercer(double);

double cuarto(double );

double quinto(double );

double a,b,c,d,j;

double l;

double h,m;

void main()

{

cout<<" 4 3 2 "<<endl;

cout<<"Derivada de la forma ax + bx + cx + dx + e"<<endl;

cout<<"Ingrese valor a: ";

cin>>a;

cout<<"Ingrese valor b: ";

cin>>b;

cout<<"Ingrese valor c: ";

cin>>c;

cout<<"Ingrese valor d: ";

cin>>d;

cout<<"Ingrese valor e: ";

cin>>j;

cout<<"Ingrese el valor a derivar: ";

cin>>l;

h = primer(a)+ segundo(b)+ tercer(c)+ cuarto(d)+quinto(j);

cout<<"Valor de derivada: "<<h<<endl;

}

double primer( double a )

{

double s=pow(l,3);

double q=(a*s)*4;

return q;

}

double segundo( double b )

{

double t=pow(l,2);

double r=(b*t)*3;

return r;

}

double tercer( double c )

{

double u=pow(l,1);

double p=(c*u)*2;

return p;

}

double cuarto( double d )

{

double w=pow(l,0);

double v=(d*w)/1;

return v;

}

double quinto( double j )

{

double g=0;

double h=(j*g);

return h;

}

---------------- INTEGRALES ---------------

*************** INTEGRALES ***************

---------------- INTEGRALES ---------------

------------------- INTEGRALES -------------------


#include<math.h>

void main ()

{

cout<<endl<<endl;

cout<<" INTEGRALES DEFINIDAS"<<endl;

cout<<endl<<endl; cout<<endl;

cout<<" ___________________________________"<<endl;

cout<<" | b |"<<endl;

cout<<" | ( |"<<endl;

cout<<" | ) seno(x)coseno(x)dx | "<<endl;

cout<<" | a | "<<endl;

cout<<" |___________________________________|"<<endl;

cout<<endl; cout<<endl;

double s,a,b,n,i,delta;

cout <<"ingrese n el numero de particiones = ";

cin>>n;

cout <<"ingrese a el limite inferior = ";

cin>>a;

cout <<"ingrese b el limite superior = ";

cin>>b;

cout<<endl<<endl;cout<<endl;

delta = (b-a)/n;

s=0;

for (i=1;i<=n;i++)

{

s = s + sin(a + delta * i) * cos(a + delta * i) * delta;

}

cout<<"la integral es :"; cout<<endl<<endl;

cout<<" ___________________________________ "<<endl;


cout<<" | ( |"<<endl;

cout<<" | ) seno(x)coseno(x)dx | = "<<s<<endl;

cout<<" | a |"<<endl;

cout<<" |___________________________________|"<<endl;

cout<<endl; cout<<endl;

}

------------------- 275 -------------------

//Se desea desarrollar una aplicacion que permita calcular la integral

//definida de una funcion: g

// f(x) = Cx + Cx ......

// -- --

// T1 T2

// C = Coeficientes; g = Grado del Termino; T = Termino; i-n = intervalo de integral

//


#include<iomanip.h>

#include<cstdlib>

#include<math.h>

int main()

{

float matrizC[20];//Matriz de Coeficiente

float matrizg[20];//Matriz de Grado de Termino

double y;

int n,i,j,x1,x2;

cout<<" Calculo de Integral definida de una funcion"<<endl<<endl;

cout<<" n g "<<endl;

cout<<" f(x) = Cx + Cx ...... "<<endl;

cout<<" i -- -- "<<endl;

cout<<" T1 T2 "<<endl<<endl;

cout<<"C = Coeficiente; g = Grado de Termino; T = Termino; i-n= intervalo"<<endl<<endl;

cout<<"Ingrese cantidad de terminos (T) para f(x) a Integrar: ";

cin>>n;

for (i=1;i<=n;i++)

{

cout<<"Ingrese el coeficiente (C) y grado (g) del T"<<i<<": ";

cin>>matrizC[i]>>matrizg[i];

}

cout<<endl;

cout<<"La funcion f(x) definida es : ";

for (i=1;i<=n;i++)

{

if (i==1)

cout<<matrizC[i]<<"x"<<matrizg[i]<<setw(2);//se muestra funcion definida

else

cout<<" + "<<matrizC[i]<<"x"<<matrizg[i]<<setw(2);

}

cout<<endl;

cout<<"La integral desarrollada es : ";

for (i=1;i<=n;i++)

{

if (i==1)

cout<<matrizC[i]/(matrizg[i]+1)<<"x"<<matrizg[i]+1<<setw(2);

else

cout<<" + "<<matrizC[i]/(matrizg[i]+1)<<"x"<<matrizg[i]+1<<setw(2);

}

cout<<endl;

cout<<"Ingrese el intervalo (i-n) de la integral: ";

cin>>x1>>x2;

y=0;

for (j=x1;j<=x2;j++)

{

for(i=1;i<=n;i++)

{

y = y + matrizC[i] / ( matrizg[i]+1 )*pow( j,matrizg[i]+1 );

}

}

cout<<"El calculo de la integral es : "<<y<<endl;

return 0;

}

------------------- 276 -------------------

// 4 3 2

//Desarrollo de Integral de la forma ax + bx + cx + dx + e


#include<math.h>

double primer( double );

double segundo( double);

double tercer(double);

double cuarto(double );

double quinto(double );

double pri( double );

double segu( double );

double ter(double );

double cuar( double );

double quin(double );

double a,b,c,d,j;

double l,n;

double e,f,g,i,k;

double h,y,m;

void main()

{

cout<<" 4 3 2 "<<endl;

cout<<"Derivada de la forma ax + bx + cx + dx + e"<<endl;

cout<<"Ingrese valor a: ";

cin>>a;

cout<<"Ingrese valor b: ";

cin>>b;

cout<<"Ingrese valor c: ";

cin>>c;

cout<<"Ingrese valor d: ";

cin>>d;

cout<<"Ingrese valor e: ";

cin>>j;

cout<<"Intervalo i a integrar: ";

cin>>l;

cout<<"Intervalo n a integrar: ";

cin>>n;

h = primer(a)+ segundo(b)+ tercer(c)+ cuarto(d)+quinto(j);

cout<<"Valor final: "<<h<<endl;

y = pri(e)+ segu(f)+ ter(g)+ cuar(i)+quin(k);

cout<<"Valor inicial: "<<y<<endl;

m = (h-y);

cout<<"Valor de integral: "<<m<<endl;

}

double primer( double a )

{

double s=pow(n,5);

double q=(a*s)/5;

return q;

}

double segundo( double b )

{

double t=pow(n,4);

double r=(b*t)/4;

return r;

}

double tercer( double c )

{

double u=pow(n,3);

double p=(c*u)/3;

return p;

}

double cuarto( double d )

{

double w=pow(n,2);

double v=(d*w)/2;

return v;

}

double quinto( double j )

{

double g=pow(n,1);

double h=(j*g)/1;

return h;

}

double pri( double e )

{

double s=pow(l,5);

double q=(a*s)/5;

return q;

}

double segu( double f )

{

double t=pow(l,4);

double r=(b*t)/4;

return r;

}

double ter( double g )

{

double u=pow(l,3);

double p=(c*u)/3;

return p;

}

double cuar( double i )

{

double w=pow(l,2);

double v=(d*w)/2;

return v;

}

double quin( double k )

{

double g=pow(l,1);

double h=(j*g)/1;

return h;

}

------------------- 277 -------------------


#include <math.h>

void main ()

{

cout<<endl<<endl<<endl<<endl;

cout<<" INTEGRALES DEFINIDAS"<<endl;

double A,B,C,D;

double s,a,b,n,i,delta;

cout<<endl<<endl;

cout<<" Integral de cualquier polinomio de tercer grado "<<endl;

cout<<" ___________________________________"<<endl;


cout<<" | ( 3 2 1 0 |"<<endl;

cout<<" | ) AX + BX + CX + DX |"<<endl;

cout<<" | a | "<<endl;

cout<<" |___________________________________|"<<endl;

cout<<endl;

cout<<"ingrese el coeficiente A = ";

cin>>A;

cout<<"ingrese el coeficiente B = ";

cin>>B;

cout<<"ingrese el coeficiente C = ";

cin>>C;

cout<<"ingrese el coeficiente D = ";

cin>>D;

cout<<endl<<endl;cout<<" El polinomio de tercer grado es : "<<endl;

cout<<" __________________________________"<<endl;

cout<<" | |"<<endl;

cout<<" | 3 2 1 0 |"<<endl;

cout<<" | "<<A<<"X + "<<B<<"X + "<<C<<"X + "<<D<<"X | "<<endl;

cout<<" | |"<<endl;

cout<<" |__________________________________|"<<endl;

cout<<endl;

cout<<endl<<endl;

cout <<"ingrese n el numero de particiones = ";

cin>>n;

cout <<endl;cout <<" DONDE a < b "<<endl<<endl;

cout <<"ingrese a el limite inferior = ";

cin>>a;

cout <<"ingrese b el limite superior = ";

cin>>b;

cout<<endl<<endl;

delta = (b-a)/n;

s=0;

for (i=1;i<=n;i++)

{

s=s+A*(a+delta*i)*(a+delta*i)*(a+delta*i)*delta+B*(a+delta*i)*(a+delta*i)*delta+C*(a+d

elta*i)*delta+D*delta;

}

cout<<"la integral es :"<<endl;

cout<<" ___________________________________"<<endl;

cout<<" | "<<b<<" |"<<endl;

cout<<" | ( 3 2 1 0 |"<<endl;

cout<<" | ) "<<A<<"X + "<<B<<"X + "<<C<<"X + "<<D<<"X | =

"<<s<<endl;

cout<<" | "<<a<<" |"<<endl;

cout<<" |___________________________________|"<<endl;

cout<<endl;

cout<<endl<<endl;

}

------------------- 278 -------------------

------------------- 279 -------------------

//Determinar mediante un mensaje si un numero ingresado es par, impar, cero, positivo,

//negativo.


int main()

{

int n;

cout<<"Ingresar un numero ";

cin>>n;

if((n<0))

{

cout<<"Negativo "<<endl;

if(n%2==0)

cout<<"Par "<<endl;

else

cout<<"Impar "<<endl;

}

else

{

if(n==0)

cout<<"Cero "<<endl;

else

{

cout<<"Positivo "<<endl;

if(n%2==0)

cout<<"Par "<<endl;

else

cout<<"Impar "<<endl;

}

}

return 0;

}

------------------- -------------------

// Mediante el uso de tres funciones (cubo, esfera, volumen) realice un programa en C++ //que

permita calcular el volumen de lo que queda de un cubo incrustado por una esfera //considere

para esto los siguientes volúmenes. E = 4πr3/3 C = (2r)3


#include<iomanip.h>

#include<math.h>

float r,rc;

double cubo (double);

double esfera(double);

double volumen(double);

void main()

{

cout<< "Ingrese el valor de r de la esfera ";

cin>> r;

cout<< "volumen de la esfera es "<< esfera(r);

cout<< endl;

cout<< "volumen del cubo es "<< cubo(r);

cout<< endl;

cout<< "El valor buscado es: "<< volumen(r);

cout << endl;

}

double cubo (double rc)

{

return pow((2*rc),3);

}

double esfera (double re)

{

return (4*3.141592*pow(re,3))/3;

}

double volumen(double rv)

{

return cubo(rv)-esfera(rv);

}

-=-=-=-

//El número de combinaciones con repetición de k elementos, que pueden formarse a //partir

de n elementos distintos ( Ckkn ) , es:

// ( n + k – 1 ) !

// Ckkn = –––––––––––––––

// k ! × ( n – 1 ) !


#include<iomanip.h>

#include<math.h>

long k,n;

long comb(long,long);

long factorial(long);

void main()

{

cout<< "Ingrese el valor de k ";

cin>> k;

cout<< "Ingrese el valor de n ";

cin >>n;

cout<< "El valor buscado es " << comb(k,n);

cout << endl;

}

long comb(long k1,long n1)

{

return(factorial(n1+(k1-1)))/factorial(k1)*factorial(n1-1);

}

long factorial(long f)

{

if (f<=1)

return 1;

else

return f*factorial(f-1);

}

-=-=-=-


#include<iomanip.h>

unsigned long factorial(unsigned long);

unsigned long fact1(unsigned long,unsigned long);

unsigned long fact2(unsigned long ,unsigned long);

unsigned long factT(unsigned long,unsigned long);

long main()

{

unsigned long n,k;

cout<<"****************************************"<<endl;

cout<<"* *"<<endl;

cout<<"* *"<<endl;

cout<<"****************************************"<<endl<<endl;

cout<<"Ingrese n y k seguidos de espacios: ";

cin>>n>>k;

if(n>k)

cout<<"el valor de la combinatoria es: "<<factT(n,k)<<endl;

else

cout<<"ERROR"<<endl;

return 0;

}

unsigned long factorial(unsigned long a)

{

if (a<=1)

return 1;

else

return a*factorial(a-1);

}

unsigned long fact1(unsigned long b,unsigned long c)

{

int i=b+c;

if(i<=1)

return 1;

else

return factorial(i-1);

}

unsigned long fact2(unsigned long d,unsigned long e)

{

return factorial(d)*factorial(e-1);

}

unsigned long factT(unsigned long f,unsigned long g)

{

return fact1(f,g)/fact2(f,g);

}

-=-=-=

//Asuma que Ud. tira tres dado especiales de ocho (08) caras y que sus resultados

//aleatoriamente dan valores entre 1 y 8 . Realice un programa en C++ que muestre el

//resultado variable de cada dado y muestre la sumatoria de los tres .

#include<math.h>

#include<stdlib.h>

int main()

{

cout<<"****************************************"<<endl;

cout<<"* *"<<endl;

cout<<"****************************************"<<endl<<endl;

srand( time( 0 ) );

int dado1;

int dado2;

int dado3;

int Sumadados;

dado1 = 1 + rand() % 8;

dado2 = 1 + rand() % 8;

dado3 = 1 + rand() % 8;

Sumadados = dado1 + dado2 + dado3;

cout <<"la suma de los dados es: "<<dado1 << " + " << dado2<<" + "<<dado3

<< " = " << Sumadados << endl;

return 0;

}

-=-=-=-

//Tabla de Akima que muestra la Funcion seno(X) con doble precision

/*******************************************************

* Akima spline fitting subroutine *

* ---------------------------------------------------- *

* The input table is X(i), Y(i), where Y(i) is the *

* dependant variable. The interpolation point is xx, *

* which is assumed to be in the interval of the table *

* with at least one table value to the left, and three *

* to the right. The interpolated returned value is yy. *

* n is returned as an error check (n=0 implies error). *

* It is also assumed that the X(i) are in ascending *

* order. *

*******************************************************/


#include <math.h>


#define SIZE 14

double X [SIZE+1];

double Y [SIZE+1];

double XM[SIZE+4];

double Z [SIZE+1];

double a,b,xx,yy;

int i,iv,n;

void Interpol_Akima()

{

//Labels: 100,200,300

int i;

n=1;

//special case xx=0

if (xx==0.0) {

yy=0.0; return;

}

//Check to see if interpolation point is correct

if (xx<X[1] || xx>=X[iv-3])

{

n=0 ; return;

}

X[0]=2.0*X[1]-X[2];

//Calculate Akima coefficients, a and b

for (i=1; i<iv; i++)

//Shift i to i+2

XM[i+2]=(Y[i+1]-Y[i])/(X[i+1]-X[i]);

XM[iv+2]=2.0*XM[iv+1]-XM[iv];

XM[iv+3]=2.0*XM[iv+2]-XM[iv+1];

XM[2]=2.0*XM[3]-XM[4];

XM[1]=2.0*XM[2]-XM[3];

for (i=1; i<iv+1; i++)

{

a=fabs(XM[i+3]-XM[i+2]);

b=fabs(XM[i+1]-XM[i]);

if (a+b!=0) goto e100;

Z[i]=(XM[i+2]+XM[i+1])/2.0;

goto e200;

e100: Z[i]=(a*XM[i+1]+b*XM[i+2])/(a+b);

e200: ;

}

//Find relevant table interval

i=0;

e300: i++;

if (xx>X[i]) goto e300;

i--;

//Begin interpolation

b=X[i+1]-X[i];

a=xx-X[i];

yy=Y[i]+Z[i]*a+(3.0*XM[i+2]-2.0*Z[i]-Z[i+1])*a*a/b;

yy=yy+(Z[i]+Z[i+1]-2.0*XM[i+2])*a*a*a/(b*b);

return;

}

void main()

{

iv=14; // Number of pooints in table

cout<<"\n Tabla Akima ordenada de SEN(X):\n";

/* Input sine table

-----------------------------------------------------------------

Sine table values from Handbook of mathematical functions

----------------------------------------------------------------- */

X[1]=0.000; Y[1]=0.00000000; X[2]=0.125; Y[2]=0.12467473;

X[3]=0.217; Y[3]=0.21530095; X[4]=0.299; Y[4]=0.29456472;

X[5]=0.376; Y[5]=0.36720285; X[6]=0.450; Y[6]=0.43496553;

X[7]=0.520; Y[7]=0.49688014; X[8]=0.589; Y[8]=0.55552980;

X[9]=0.656; Y[9]=0.60995199; X[10]=0.721; Y[10]=0.66013615;

X[11]=0.7853981634; Y[11]=0.7071067812;

X[12]=0.849; Y[12]=0.75062005; X[13]=0.911; Y[13]=0.79011709;

X[14]=0.972; Y[14]=0.82601466;

//----------------------------------------------------------------

cout<<"\n X MANUAL DE SEN(X) INTERPOLACION AKIMA ERROR \n";

cout<<"----------------------------------------------------\n";

xx=0.0;

for (i=1; i<17; i++)

{

Interpol_Akima();

cout<<setprecision(2)<<xx<<setprecision(7)<<setw(13)<<sin(xx)<<setprecision(7)<<setw(20)<<yy<

<setprecision(7)<<setw(22)<<(sin(xx)-yy)<<endl;

xx += 0.05;

}

cout<<"----------------------------------------------------\n";

}

-=-=-=-

/***************************************************

* Evaluacion eliptica de Integrales de 1er y 2do Or*

* integrals of first and second kinds (completa) *

* ------------------------------------------------ *

* EJEMPLO de CORRIDA *

* *

* K K(K) E(K) PASOS *

* ------------------------------------------- *

* 1.00 INFINITY 1.0000000 0 *

* *

* Complete elliptic integral of the first and second *

* kind. The input parameter is xk, which should be *

* between 0 and 1. Technique uses Gauss' formula for *

* the arithmogeometrical mean. e is a measure of the *

* convergence accuracy. The returned values are e1, *

* the elliptic integral of the first kind, and e2, *

* the elliptic integral of the second kind. *

*****************************************************/

#include <stdio.h>

#include <math.h>

double A[100], B[100];

double e,e1,e2,xk;

int i, n;

void CElliptic()

{

//Label: e100

int j, m; double pi;

pi = 4*atan(1);

A[0]=1.0+xk ; B[0]=1-xk;

n=0;

if (xk < 0) return;

if (xk > 1) return;

if (e <= 0) return;

e100: n++;

// Generate improved values

A[n]=(A[n-1]+B[n-1])/2.0;

B[n]=sqrt(A[n-1]*B[n-1]);

if (fabs(A[n]-B[n]) > e) goto e100;

e1=pi/2.0/A[n];

e2=2.0;

m=1;

for (j=1; j<n+1; j++) {

e2=e2-m*(A[j]*A[j]-B[j]*B[j]);

m=m*2;

}

e2 *= (e1/2.0);

}

void main()

{

e=1e-7;

printf(" K K(K) E(K) PASO \n");

printf("------------------------------------------\n");

xk=0.0;

for (i=1; i<21; i++) {

CElliptic();

printf(" %4.2f %9.7f %9.7f %d\n",xk,e1,e2,n);

xk += 0.05;

}

printf(" 1.00 INFINITY 1.0000000 0\n\n");

}

-=-=-=-

/*****************************************************************

* Program to demonstrate Lagrange derivative interpolation *

* -------------------------------------------------------------- *

* SAMPLE RUN: *

* *

* X 2COS(2X) YP YP1 ERROR 1 ERROR 2 *

* -------------------------------------------------------------- *

/****************************************************

* Lagrange derivative interpolation procedure Deriv *

* NL is the level of the interpolation ( ex. NL=3 ) *

* N is the total number of table values. *

* X[i], Y[i] are the coordinate table values, Y[i] *

* being the dependant variable. The X[i] may be *

* arbitrarily spaced. x1 is the interpolation point *

* which is assumed to be in the interval with at *

* least one table value to the left, and NL to the *

* right. Yp is returned as the desired derivative. *

* error is set at TRUE if x1 is not in the interval.*

****************************************************/

#include <stdio.h>

#include <math.h>

#define NMAX 100

#define pas 0.05

double X[NMAX],Y[NMAX];

double xx,yy,yy1;

int error,i,n,ndata;

void Deriv(int n, int nl, double *X, double *Y, double x1, double *Yp,int *error) {

int i,j,k,ll;

double L[10], M[10][10];

*error=0;

// x1 not in interval [1:N-NL]

if (x1<X[1] || x1>X[n-nl]) {

*error=1;

printf(" STOP: x not between X[1] or X[N-4].\n");

}

if (*error==0) {

i=0;

do {

i++;

} while (x1 >= X[i]);

i--;

for (j=0; j<nl+1; j++) {

L[j]=0.0;

for (k=0; k<nl+1; k++) M[j][k]=1.0;

}

*Yp=0.0;

for (k=0; k<nl+1; k++) {

for (j=0; j<nl+1; j++) {

if (j!=k) {

for (ll=0; ll<nl+1; ll++) {

if (ll!=k) {

if (ll==j)

M[ll][k]=M[ll][k]/(X[i+k]-X[i+j]);

else

M[ll][k]=M[ll][k]*(x1-X[j+i])/(X[i+k]-X[i+j]);

}

}

}

}

for (ll=0; ll<nl+1; ll++)

if (ll!=k) L[k]=L[k]+M[ll][k];

*Yp=*Yp+L[k]*Y[i+k];

}

}

} // Deriv()

/*********************************************************

CALCULE LES COEFFICIENTS A,B DE LA PARABOLE Y=A*X*X+B*X+C

PASSANT PAR LES 3 POINTS : (X1,Y1),(X2,Y2) ET (X3,Y3)

COEFFICIENT C NON UTILISE ICI.

---------------------------------------------------------

Calculates coefficients, a, b of parabola Y=A*X+X+B*X=C

passing through 3 points: (X1,Y1), (X2,Y2) and (X3,Y3).

Coefficient c is not used here.

*********************************************************/

void PARABOLE(double x1,double y1,double x2,double y2,

double x3,double y3,double *a,double *b) {

double alpha,beta,gamma,delta;

alpha=x1*x1-x2*x2;

beta=x1-x2;

gamma=x2*x2-x3*x3;

delta=x2-x3;

*a=(y1-2.0*y2+y3)/(alpha-gamma);

*b=(y1-y2-alpha**a)/beta;

}

/***************************************************

* Interpolation of order=2 ( parabola ) *

* by J-P Moreau *

***************************************************/

void Deriv1(int n, double *X, double *Y, double x1, double *Yp,

int *error) {

double a, b;

int i;

*error=0;

if (x1<X[1] || x1>X[n-2]) {

*error=1;

return;

}

i=0;

while (x1>=X[i]) i++;

i--;

PARABOLE(X[i],Y[i],X[i+1],Y[i+1],X[i+2],Y[i+2],&a,&b);

//Derivative in x1

*Yp=2*a*x1+b;

}

void main() { //derivative of 2*sin(x)*cos(x) between 0 and 1

n=4; //level of Lagrange interpolation

ndata=26; //number of table points

// building X & Y Tables

for (i=1; i<ndata+1; i++) {

X[i]=(double) pas*(i-1);

Y[i]=2*cos(X[i])*sin(X[i]);

}

xx=0.0;

printf(" X 2COS(2X) YP YP1 ERROR 1 ERROR 2\n"); //heading

printf("--------------------------------------------------------------\n");

//main loop of derivation

do {

Deriv(ndata,n,X,Y,xx,&yy,&error);

Deriv1(ndata,X,Y,xx,&yy1,&error);

if (error==0) {

printf("%4.2f %9.6f %9.6f %9.6f %10.7f %10.7f\n",xx,2*cos(2*xx),yy,yy1,

yy-2*cos(2*xx), yy1-2*cos(2*xx) );

}

xx=xx+pas;

} while(xx<1.0+pas);

printf("--------------------------------------------------------------\n");

}

-=-=-=-

-=-=-=-

-=-=-=-

-=-=-=-

-=-=-=-

-=-=-=-

-=-=-=-

simulacion con c++

Documents