BENEMRITA UNIVERSIDAD AUTNOMA DE PUEBLA

FACULTAD DE CIENCIAS FSICO MATEMTICAS

FSICA COMPUTACIONAL
OTOO 2015

PROYECTO FINAL

PROF. MARIO IVAN MARTNEZ

OSCAR ORDEZ ZAMORA

MATRICULA: 201433501

INTEGRACIN NUMRICA DE ROMBERG.

FUNCIN A INTEGRAR: FUNCIN ERROR EN EL VALOR 1

FECHA DE ENTREGA: 04 DE ENERO DE 2016

1. PLANTAMIENTO
Qu problema resuelve el proyecto?
La funcin error definida como
erf() =

proporciona la probabilidad de que cualquiera de serie de ensayos est a media de x unidades de la media, suponiendo que
los ensayos tienen una distribucin normal con media 0 y desviacin estndar 2/2. Esta integral no se puede evaluar en
trminos de funciones elementales, de modo que se debe usar una tcnica de aproximacin.

Grafica de la funcin a integrar en funcin de x

Como la funcin

no tiene una primitivas definidas, entonces para poder integral la funcin error es necesario

un mtodo numrico.
Qu problema resuelve el proyecto?
Sea la funcin error de distribucin normal que se define mediante:
erf() =
Aproxime erf(1) con una exactitud de

107 .

Teniendo que erf(1) es igual a

erf(1) =

Y por comodidad la integral anterior se puede trabajar haciendo la variable de integracin t igual a x (t=x), teniendo entonces:
erf(1) =

As por el mtodo de integracin numrica por Romberg calcularemos erf(1)como se defini anteriormente.
La exactitud la definimos como:
Sea A una aproximacin por una n iteracin y sea B una aproximacin de una n+1 iteracin, entonces dada la exactitud de
107 (se usara una cantidad de 10 cifras decimales), entonces definimos la solucin como | | 107 .

2. DESCRIPCION DE LA SOLUCIN
Explicacin del mtodo usado
La regla compuesta del trapecio tiene un error de truncamiento del orden de (2 ). Demostramos que para casa h=(b-a)/n
y = + tenemos:
1

( ) ()2
() = [() + ( ) + ()]
2
12

=1

para algn nmero en (a, b).

Mediante un mtodo alternativo, podemos demostrar que si [, ] (funcin continua en el intervalo cerrado [a,b]),
la regla compuesta del trapecio tambin puede escribirse con un trmino de error en la forma:
1

() = [() + 2 ( ) + ()] + 1 2 + 2 4 + 3 6 +
2

=1

donde cada K i es una constante que depende slo de (21) () y (21) ().
Recordando que en la interpolacin de Richardson puede efectuarse en cualquier procedimiento de aproximacin cuyo error
de truncamiento es de la forma:
1

( ) + ( )
=1

Para un conjunto de constante y cuando 1 < 2 < 3 < < . Se demuestra que la efectividad de esta tcnica cuando
el procedimiento tiene un error de truncamiento con solo potencias pares de h; es decir, cuando el error de truncamiento
tiene la forma
1

( 2 ) + (2 )
=1

Ya con esta forma da la tcnica de integracin numrica de Romberg.

Para aproximar la integral () usamos los resultados de la regla compuesta del trapecio con n=1, 2, 4, 8, 16, y se
denotan las aproximaciones resultantes, respectivamente, por 1,1 , 2,1 , 3,1 , Luego aplicamos la extrapolacin para
(4 ): 2,2 , 3,2 , 4,1 , mediante:
1
,2 = ,1 + (,1 1,1 ), = 2,3,
3
Luego las aproximaciones 0(6 ): 3,3 , 4,3 , 5,3 mediante:
,3 = ,2 +

1
( 1,2 ), = 3,4,
15 ,2

Sucesivamente desde de que las aproximaciones ,1 han sido obtenidas, se determina las aproximaciones (2 ) a partir
de:
, = ,1 +

1
4 1

(,1 1,1 ), = , + 1,

La ltima expresin es el mtodo de Integracin numrica de Romberg.

Ejemplo del uso del mtodo de Romberg para el manejo del clculo de nuestra funcin error evaluada en 1:
As calculamos
erf(1) =
Primeramente usamos la regla compuesta del trapecio para

2
1

0

con n=1,2,4,8 y 16: Posteriormente realizamos la

extrapolacin de Romberg en los resultados:

Resultados de la regla compuesta del trapecio para los varios valores de n dan como resultado las siguientes aproximaciones
al valor real de erf(1) 0.8427007929.

Usando: [() + 1
=1 ( ) + ()]
2

Con h=(b-a)/n, = + , a=0, b=1 y () =

Para n=1
1 2 02
1 + 1
2

[
+ 1 ] =
0.7717433321
2

Para n=2
1 2
1 2 02
2
( )
2,1 =
[
+ 2 2 + 1 ] 0.8252629555
4
Para n=4
1 2
1 2
3 2
1 2 02
2
( )
( )
( )
3,1 =
[
+ 2 ( 4 + 2 + 4 ) + 1 ] 0.8383677772
8
Para n=8
1 2
1 2
3 2
1 2
5 2
3 2
7 2
1
2 02
2
( )
( )
( )
( )
( )
( )
( )
4,1 =

[
+ 2 ( 8 + 4 + 8 + 2 + 8 + 4 + 8 ) + 1 ] 0.8416192214
16
Para n=16
1,1 =

5,1 =

1 2
1 2
3 2
1 2
5 2
3 2
7 2
1 2
9 2
5 2
11 2
1
2 02
)
)
)
)
)
)
)
)
)
)
)

+ 2 ( (16 + (8 + (16 + (4 + (16 + (8 + (16 + (2 + (16 + (8 + (16

[
32
3 2
)

13 2
)

7 2
)

15 2
)

+ (4 + (16 + (8 + (16 ) + 1 ] 0.8424305056

Las aproximaciones (4 ) son

1
2,2 = 2,1 + (2,1 1,1 ) = 0.8431028300
3
1
3,2 = 3,1 + (3,1 2,1 ) = 0.8427360511
3
1
4,2 = 4,1 + (4,1 3,1 ) = 0.8427030361
3
1
5,2 = 5,1 + (5,1 4,1 ) = 0.8427009337
3
Las aproximaciones (6 ) son
3,3 = 3,2 +

1
( 2,2 ) = 0.8427115992
15 3,2

4,3 = 4,2 +

1
( 3,2 ) = 0.8427008351
15 4,2

5,3 = 5,2 +

1
( 4,2 ) = 0.8427007935
15 5,2

Las aproximaciones (8 ) son

4,4 = 4,3 +

1
( 3,3 ) = 0.8427006642
63 4,3

5,4 = 5,3 +

1
( 4,3 ) = 0.8427007928
63 5,3

Y la aproximacin (10 ) es
5,5 = 5,4 +

1
( 4,4 ) = 0.8427007933
255 5,4

Colocando los resultados en una tabla se tiene que

erf(1) 0.8427007929
(6 )
(8 )

Valor Exacto
(4 )
0.7717433321
0.8252629555
0.8383677772
0.8416192214

0.8431028300
0.8427360511
0.8427030361
0.8427009337

0.8424305056

0.8427115992
0.8427008351
0.8427007935

(10 )

0.8427006642
0.8427007928

Se us la regla compuesta del trapecio cada aproximacin consecutiva incluye todas las evaluaciones de funciones desde la
aproximacin anterior, es decir 1,1 utiliza las evaluaciones en 0 y 1, 2,1 usa esa evaluacin y aade una evaluacin en el
punto medio . Luego 3,1 usa las evaluaciones de 2,1 y agrega dos evaluaciones intermedias en y . Continuando as
con 4,1 utilizando las mismas evaluaciones que en 3,1 pero aadiendo evaluaciones en los cuatro puntos intermedios 1/8,
3/8, 5/8, 7/8 continuando as sucesivamente. Esta regla es vlida para una integral en [a, b].
La regla compuesta del trapecio dada por +1,1 utilizando evaluaciones que ,1 , pero agrega evaluaciones en los 22
puntos intermedios, as los clculos eficientes de estas aproximaciones pueden hacerse de manera recursiva.

Para obtener aproximaciones con la regla compuesta del trapecio para () , sea =
1,1 =

21

[() + ()] =
[( + ()]
2
2

Y
2,1 =

2
[() + () + 2( + 2 )]
2

Al re expresar este resultado para 2,1 , se puede incorporar la aproximacin para 1,1 previamente determinada
2,1 =

1
[() + () + 2 ( +
)] = [(1,1 + 1 ( + 2 )]
4
2
2

Rescribiendo
1
3,1 = {2,1 + 2 [( + 3 ) + ( + 33 )]}
2
En general
22

,1

1
= [1,1 + 1 ( + (2 1) )] = 2,3,
2
=1

Entonces se usa la extrapolacin para producir aproximaciones ( ) mediante

, = ,1 +

1
(
1,1 ), = , + 1,
4 1 1 ,1

Analizando la siguiente tabla para una mejor compresin de esto:

K
1
2
3
4

(2 )
1,1
2,1
3,1
4,1

,1

(4 )

(6 )

(8 )

2,2
3,2
4,2

,2

3,3
4,3

,3

4,4

,4

(2 )

Mtodo efectivo para construir la tabla de Romberg utilizando la aproximacin de orden ms alto en cada paso, calcular las
entradas o elementos rengln por rengln completo en orden 1,1 , 2,1 , 2,2 , 3,1 , 3,2 , 3,3 , esto nos da un nuevo rengln
completo en la tabla para ser calculado haciendo solo una aplicacin extra de la regla compuesta del trapecio. sta usa
despus el promedio de los valores calculados previamente para obtener los elementos restantes del rengln.
Ejemplo:
Se agrega un rengln adicional a la extrapolacin de la tabla de valores para aproximar erf(1) =
24

6,1

2 1 2

0

(21)1
1
1 2
(
)
32
= [5,1 +

] = 0.8426332280
2
16
=1

Los valores dados son

1
6,2 = 6,1 + (6,1 5,1 ) = 0.8427008021
3
6,3 = 6,2 +

1
( 5,2 ) = 0.8427007933
15 6,2

6,4 = 6,3 +

1
( 5,3 ) = 0.8427007933
63 6,3

6,5 = 6,4 +

1
( 5,4 ) = 0.8427007933
255 6,4

Finalmente
6,6 = 6,5 +

1
( 5,5 ) = 0.8427007933
1023 6,5

Revisando los resultados tenemos que

Valor Exacto
(4 )
0.7717433321
0.8252629555
0.8383677772
0.8416192214
0.8424305056
0.8426332280

0.8431028300
0.8427360511
0.8427030361
0.8427009337
0.8427008021

erf(1) 0.8427007929
(6 )
(8 )

0.8427115992
0.8427008351
0.8427007935
0.8427007933

0.8427006642
0.8427007928
0.8427007933

(10 )

0.8427007933
0.8427007933

En general ,1 requiere 1 + 21 evaluaciones de la funcin, as que este caso se requieren 1 + 25 = 33

3. DESCRIPCIN DE LA IMPLEMENTACIN
Para aproximar la integral =

() ,

seleccione un entero n>0

ENTRADA: extremos a, b: entero n

SALIDA: un arreglo R. (Se calcula por renglones; slo ltimos renglones se guardan)
Paso 1: h=b-a;
1,1 =

(() + ())
2

Paso 2: SALIDA (1,1 )

Paso 3: i= 2, , n se realiza:
Mtodo del Trapecio
Paso 4:
22

1,1

1
= [1,1 + ( + ( 0.5))]
2
=1

Paso 5: j= 2, , i
Extrapolacin
2, = 2,1 +

1
(
1,1 )
4 1 1 2,1

Paso 6: SALIDA (1,1 = 1, 2, , )

Paso 7: Se toma =

Paso 8:
Actualizacin
Con j= 1, 2, , i tome (1, = 2, )
Paso 9: FIN
El algoritmo requiere un entero n establecido previamente para determinar el nmero de filas.
Pero para este problema es mejor si se fija una tolerancia de error en las aproximaciones y generar n dentro de una cota
superior hasta que las entradas diagonales consecutivas 1,1 , concordando con el margen de exactitud que este
caso es de 107 , esto se implementa en el algoritmo como |1,1 , | = 107 =
ATENCIN: Para programar el mtodo de integracin numrica por Romberg se us el IDE de Eclipse Versin:
Mars.1 Release (4.5.1), Build id: 20150924-1200 de x64 bits, no se us el IDE de ZinjaI porque no admita arreglos
dinmicos y da el error de decodificacin.

PROGRAMA COMPLETO DE INTEGRACIN NMERICA DE ROMBERG EN EL IDE ECLIPSE

/*
============================================================================
Name
: Romberg.c
Author
: Oscar Ordez Zamora
Version
: 1.0
Copyright
: Trabajo Final, Fsica Computacional
Description : Integracin Numrica: Mtodo de Romberg, Ansi-style
============================================================================
============================================================================
Para aproximar la Integral de una funcin dada continua en el intervalo
b
/
| f(x)dx
=
R(j,j);
/
a
Nota: Se necesita un "n" Natural Positivo
Se genera una tabla de aproximaciones R(i,k) de k <= i, y usando
R(j,j) como el resultado total. Las aproximaciones R(j,k) son guardadas.
Los elementos de R(j,0) de la columna 0 son calculadas usando el mtodo
de la regla del trapecio trapezoidal basados en sub intervalos [a,b];
Entonces R(j,k) es calculado usando el mtodo de Romberg.
Los elementos de la j-sima fila son
R(j,k-1) - R(j-1,k-1)
R(j,k) = R(j,k-1) + --------------------k
4
-1

for 1 <= k <= j.

El algoritmo es finalizado J-sima fila da el siguiente valor de exactitud:

|R(j,j) - R(j-1, j-1)| < Exactitud
============================================================================
La funcin a evaluar es dada por el valor de "funcion"*/
/*Libreras a usar*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
/*Cota Superior */
#define minimo 400
/*Definimos el valor de con 50 cifras decimales para mayor exactitud :)*/
/*Construimos la variable funcin con una entrada de valor doble*/
double funcion(double x);
/*Definimos el valor de regreso de nuestra construccin*/
double funcion(double x)
{
/*Definimos la funcin Dada*/
return ((2/sqrt(M_PI))*(1/exp(x*x)));
}
/*ALGORITOMO DEL PROGRAMA */
int main()
{
/*Variables a usar*/

int p, k, j, kk;
int m;
positivo*/
float n;
Subintervalos
double
double
double
double
double

/* Contadores de los loop, varios usos*/

/* Nmeros de Subintervalos, valor entero
/*Valor de Entrada: nmeros de veces que los

son bsectados*/
Exactitud = 1E-7;
/* Exactitud buscada: 0.0000001
*/
Finalizar;
/* Finalizacin
*/
a,b;
/* Limites de Integracin
*/
h;
/* Anchos
*/
Suma= 0;
/* Suma cero para el inicio del Programa*/

printf("Programa para la Integraci\242n Num\202rica de la funci\242n

error\n");
printf("Usando Integraci\242n de Romberg evaluada en 1\n");
printf("El valor m\240s exacto con 10 cifras decimales es
erf(1)=0.8427007929\n");
printf("
======================================================================\n");
printf("\n");
printf("
======================================================================\n");
printf("
ENTRADAS\n");
printf("
======================================================================\n");
printf(" Inserta los l\241mites de Integraci\242n [a,b]\n");
printf(" En este caso del problema son: a = 0 y b = 1\n");
printf(" Por favor ingresa el valor del l\241mite inferior de
integraci\242n:\n");
printf(" a=");
scanf("%lf",&a);
printf(" L\241mite inferior es: a= %lf\n",a);
printf("
======================================================================\n");
printf(" Por favor ingresa el valor del l\241mite superior de integraci\242n
b:\n");
printf(" b=");
scanf("%lf",&b);
printf(" L\241mite superior es: b= %lf\n",b);
printf("
======================================================================\n");
printf(" Los l\241mites de Integraci\242n respectivamente son: [%lf,
%lf]\n",a, b);
printf("
======================================================================\n");
printf("N\243mero m\240ximo de filas, dar un entero positivo :)\n");
printf(" n=");
scanf("%f",&n);
/*Lista generada para los valores de salida, para evitar el quiebre se
escribi as */
double R[minimo][minimo];
/*Condicional para evitar entradas de filas no enteras positivas*/
if(n<0 || floor(n)!=n)

{
printf("El n\243mero m\240ximo de filas dado no es un entero positivo:
%f\n",n);
printf("Iniciando otra vez :(.\n");
system("Pause");
return EXIT_SUCCESS;
}
/*Salidas*/
printf("Filas: n=%f\n",n);
printf("
======================================================================\n");
printf("\n");
printf("\n");
printf("
======================================================================\n");
printf("
CALCULOS\n");
printf("
======================================================================\n");
m = 1;
/* Iniciando el nmero de Intervalos */
h = b-a;
/* Iniciando las particiones
*/
Finalizar = 1; /* Iniciando la variable
*/
j = 0;
/* Iniciando el contados
*/
/* Se calcula la primera entrada del mtodo del trapezoide*/
R[0][0] = (h/2)*(funcion(a)-funcion(b));
/*Un ciclo While (Mientras), comparando la exactitud y los nmeros de
contadores*/
while (((Finalizar > Exactitud) && (j < n)) || (j < 4))
{
/* Iniciando los Clculos */
j++;
/* Calculo de un nuevo R(j,0) */
/* Reduciendo el tamao de los intervalos para el J-simo refinamiento*/
h = h/2;
/*Suma cero para el inicio de las sumas*/
Suma = 0;
for (p = 1; p <= m; p++) /* Loop*/
{
Suma = Suma + funcion(a + h*((2 * p) - 1));
}
R[j][0] = R[j-1][0] / 2 + h * Suma;
/*Actualizacin del nmero of Subintervalos */
m = 2*m;
/*Extrapolacin */
for (k = 1; k <= j; k++)
{
R[j][k] = R[j][k-1] + ( R[j][k-1] - R[j-1][k-1])/(por(4,k)-1);
}
printf(" ============================================================\n");
printf(" Las entradas en la fila %d para la integraci\242n de Romberg
es\n",j);
printf(" ============================================================\n");

/*Salidas Finales para el Sistema*/

for (kk = 1; kk <= j; kk++)
printf("R(%d,%d) = %.10f\n",j,kk,R[j][kk]);
/*Finalizacin con el criterio de Exactitud que se compar con el ciclo
while*/
Finalizar = fabs(R[j-1][j-1]-R[j][j]);
}
printf(" ============================================================\n");
printf(" El valor m\240s exacto con 10 cifras decimales es
erf(1)=0.8427007929\n");
printf(" ============================================================\n");
printf(" La aproximaci\242n m\240s exacta de la funci\242n error evaluada en
1\n");
printf(" usando la Integraci\242n de Romberg es erf(1)= %0.10lf\n",
R[j][j]);
printf(" ============================================================\n");
/*Pausa del sistema para salir del programa*/
system("Pause");
return EXIT_SUCCESS;
}

4. DISCUSIN DE RESULTADOS
Entradas y salidas del programa, para simplificar el problema solo se muestra para 10 filas, el programa en c (Romberg.c)
hecho en el IDE Eclipse se puede expender hasta un lmite de 400, valor fijado previamente, solo se da una corrida del
programa y el error de precisin se fija anteriormente (107 ), la aproximacin de 0.8427007933 se logra entre ms alta
sean el nmero de filas, pero est limitado por la exactitud fijada de 107

Programa para la Integracin Numrica de la funcin error

Usando Integracin de Romberg evaluada en 1
El valor ms exacto con 10 cifras decimales es erf (1) =0.8427007929
=================================================================
ENTRADAS
=================================================================
Inserta los lmites de Integracin [a, b]
En este caso el problema es: a = 0 y b = 1
Por favor ingresa el valor del lmite inferior de integracin:
a=0
Lmite inferior es: a= 0.000000
=================================================================
Por favor ingresa el valor del lmite superior de integracin b:
b=1
Lmite superior es: b= 1.000000
=================================================================
Los lmites de Integracin respectivamente son: [0.000000, 1.0000]
=================================================================
Nmero mximo de filas, dar un entero positivo :)
n=10
Filas: n=10.000000
=================================================================
CLCULOS
=================================================================
============================================================
Las entradas en la fila 1 para la integracin de Romberg es
============================================================
R(1,1) = 0.7047336642
============================================================
Las entradas en la fila 2 para la integracin de Romberg es
============================================================
R(2,1) = 0.7735514685
R(2,2) = 0.7781393221
============================================================
Las entradas en la fila 3 para la integracin de Romberg es
============================================================
R(3,1) = 0.8081107444

R(3,2) = 0.8104146961
R(3,3) = 0.8109270036
============================================================
Las entradas en la fila 4 para la integracin de Romberg es
============================================================
R(4,1) = 0.8254047878
R(4,2) = 0.8265577241
R(4,3) = 0.8268139626
R(4,4) = 0.8268762644
============================================================
Las entradas en la fila 5 para la integracin de Romberg es
============================================================
R(5,1) = 0.8340527289
R(5,2) = 0.8346292583
R(5,3) = 0.8347573779
R(5,4) = 0.8347885285
R(5,5) = 0.8347962629
============================================================
Las entradas en la fila 6 para la integracin de Romberg es
============================================================
R(6,1) = 0.8383767571
R(6,2) = 0.8386650256
R(6,3) = 0.8387290854
R(6,4) = 0.8387446607
R(6,5) = 0.8387485279
R(6,6) = 0.8387494931
============================================================
Las entradas en la fila 7 para la integracin de Romberg es
============================================================
R(7,1) = 0.8405387748
R(7,2) = 0.8406829093
R(7,3) = 0.8407149392
R(7,4) = 0.8407227268
R(7,5) = 0.8407246604
R(7,6) = 0.8407251430
R(7,7) = 0.8407252636
============================================================
Las entradas en la fila 8 para la integracin de Romberg es
============================================================
R(8,1) = 0.8416197838
R(8,2) = 0.8416918511
R(8,3) = 0.8417078661

R(8,4) = 0.8417117599
R(8,5) = 0.8417127267
R(8,6) = 0.8417129680
R(8,7) = 0.8417130283
R(8,8) = 0.8417130433
============================================================
Las entradas en la fila 9 para la integracin de Romberg es
============================================================
R(9,1) = 0.8421602884
R(9,2) = 0.8421963220
R(9,3) = 0.8422043295
R(9,4) = 0.8422062764
R(9,5) = 0.8422067598
R(9,6) = 0.8422068805
R(9,7) = 0.8422069106
R(9,8) = 0.8422069181
R(9,9) = 0.8422069200
============================================================
Las entradas en la fila 10 para la integracin de Romberg es
============================================================
R(10,1) = 0.8424305407
R(10,2) = 0.8424485575
R(10,3) = 0.8424525612
R(10,4) = 0.8424535347
R(10,5) = 0.8424537764
R(10,6) = 0.8424538367
R(10,7) = 0.8424538518
R(10,8) = 0.8424538555
R(10,9) = 0.8424538565
R(10,10) = 0.8424538567
============================================================
El valor ms exacto con 10 cifras decimales es erf (1)= 0.842700792
============================================================
La aproximacin ms exacta de la funcin error evaluada en 1
usando la Integracin de Romberg es erf(1)= 0.8424538567
============================================================

5. BIBLOGRAFIA

Anlisis Numrico, Richard L. Burden y J. Douglas Faires, Cengage Learning, 9a. ed., Mxico, 2011
Erdelyi, A. Higher Transcendental Functions. McGraw-Hill, 1953. Vol. 2.
Cmo programar en C/C++ y Java, Deitel H. M. y Deitel P. J., Pearson Educacin, Mxico, 2004
NUMERICAL METHODS for Mathematics, Science and Engineering, 2nd Ed, 1992
Prentice Hall, Englewood Cliffs, New Jersey, 07632, U.S.A.
Prentice Hall, Inc.; USA, Canada, Mxico ISBN 0-13-624990-6
Prentice Hall, International Editions: ISBN 0-13-625047-5