Documentos de Académico
Documentos de Profesional
Documentos de Cultura
0 Algoritmos LIBRO
0 Algoritmos LIBRO
~~ NACIONAL
DE COLOMBIA
Sede Bogotá
colección textos
HÉCTOR MANUEL MORA ESCOBAR
Investigación de Operaciones.
Introducción a e
y a métodos numéricos
Héctor Manuel Mora Escobar
Profesor del Departamento de Matemáticas
Facultad de Ciencias, Universidad Nacional de Colombia
Introducción a e
y a métodos numéricos
UNIBIBLOS
Director general
Ramón Fayad Naffah
Coordinaci6n editorial
Dora Inés Perilla Castillo
Revisi6n editorial
Osear Torres
Carátula
Camilo Umaña
ISBN 958-701-363-8
ISBN 958-701-138-4
(obra completa)
ISBN: 958-701-363-8
1.Análisis numérico 2.C (Lenguaje de programación para computadores)
3. Matemáticas aplicadas
CDD-21 519.41 M827in 1 2004
A Hélfme, Nicolás y Sylvie
A Hélfme, Nicolás y Sylvie
A Hélfme, Nicolás y Sylvie
,
Indice general
Prólogo IX
1. Introducción 1
2. Generalidades 5
2.1. El primer programa 6
2.2. Editar, compilar, ejecutar 9
2.2.1. g++ . . . . . 10
2.2.2. bcc32 . . . . 10
2.2.3. Thrbo C++ . 11
2.2.4. Visual C++ . 12
2.2.5. Dev-C++ 14
2.3. Comentarios. . 15
2.4. Identificadores 16
2.5. Tipos de datos 19
2.6. Operador de asignación 21
2.7. Operadores aritméticos. 22
2.8. Prioridad de los operadores aritméticos . 24
2.9. Abreviaciones usuales 26
2.10. Funciones matemáticas 27
2.11. Entrada de datos y salida de resultados 30
2.12. Conversiones de tipo en expresiones mixtas 35
2.13. Moldes . . . . . . . . . . . ..... . 36
III
ÍNDICE GENERAL
3. Estructuras de control 41
3.1. if . . . . . . . . . . 41
3.2. Operadores relacionales y lógicos 45
3.3. for .. 48
3.4. while 51
3.5. do while 54
3.6. switch. 57
3.7. break 58
3.8. continue 60
3.9. goto y exi t 61
4. Funciones 67
4.1. Generalidades 67
4.2. Funciones recurrentes 75
4.3. Parámetros por valor y por referencia 76
4.4. Parámetros por defecto ...... . 81
4.5. Variables locales y variables globales 82
4.6. Sobrecarga de funciones 83
4.7. Biblioteca estándar 85
5. Arreglos 87
5.1. Arreglos unidimensionales 87
5.2. Arreglos multidimensionales 94
5.3. Cadenas . . . . . . . . . 98
5.4. Inicialización de arreglos · 103
6. Apuntadores 109
6.1. Apuntadores y arreglos unidimensionales . · 111
6.2. Apuntadores a apuntadores . . . . . . . · 116
6.3. Apuntadores y arreglos bidimensionales · 116
6.4. Matrices y arreglos unidimensionales · 117
6.5. Arreglos aleatorios . . . . . . . . · 129
6.6. Asignación dinámica de memoria · 131
IV
ÍNDICE GENERAL
9. Estructuras 175
9.1. Un ejemplo con complejos 175
9.2. Un ejemplo típico. . . . . 181
v
ÍNDICE GENERAL
VI
ÍNDICE GENERAL
VII
ÍNDICE GENERAL
A. Estilo en e 389
A.1. Generalidades . . 389
A.2. Ejemplo . . . . . 393
A.3. Estructuras de control . 395
VIII
ÍNDICE GENERAL
A. Estilo en e 389
A.1. Generalidades . . 389
A.2. Ejemplo . . . . . 393
A.3. Estructuras de control . 395
VIII
ÍNDICE GENERAL
A. Estilo en e 389
A.1. Generalidades . . 389
A.2. Ejemplo . . . . . 393
A.3. Estructuras de control . 395
VIII
Prólogo
IX
Si hay reorganización de las páginas de la Universidad, será necesario
entrar a la página
www.unal.edu.co
dirigirse a Sede de Bogotá, Facultad de Ciencias, Departamento de Ma-
temáticas y página del autor.
hmmorae@unal.edu.co
hectormora@yahoo.com
x
1
Introducción
• Eficiencia.
1
1. INTRODUCCIÓN
2
dos presentan un equilibrio entre eficiencia, facilidad de presentación y
popularidad. Hay muy buenos libros de referencia para métodos numéri-
cos y análisis numérico. Algunos de ellos son [GoV96], [IsK66], [YoG72],
[DaB74], [BuF85], [LaT87], [StB93], [Atk78].
También hay libros que al mismo tiempo tratan los dos temas: C
(o C++) y métodos numéricos; por ejemplo: [Pre93], [Kem87], [OrG98],
[Fl095], [ReD90].
Los ejemplos de programas de este libro han sido probados en va-
rios compiladores. El autor espera que funcionen en la mayoría. Para
algunos ejemplos, aparecen los resultados producidos por el programa.
Estos resultados pueden variar ligeramente de un compilador a otro; por
ejemplo, en el número de cifras decimales desplegadas en pantalla.
En algunos ejemplos no están todos los detalles ni instrucciones ne-
cesarias, aparecen únicamente las instrucciones más relevantes para ilus-
trar el tema en estudio. Usualmente aparecerán puntos suspensivos in-
dicando que hacen falta algunas instrucciones; por ejemplo, las instruc-
ciones donde se leen, se definen o se les asigna un valor a las variables.
dos presentan un equilibrio entre eficiencia, facilidad de presentación y
popularidad. Hay muy buenos libros de referencia para métodos numéri-
cos y análisis numérico. Algunos de ellos son [GoV96], [IsK66], [YoG72],
[DaB74], [BuF85], [LaT87], [StB93], [Atk78].
También hay libros que al mismo tiempo tratan los dos temas: C
(o C++) y métodos numéricos; por ejemplo: [Pre93], [Kem87], [OrG98],
[Fl095], [ReD90].
Los ejemplos de programas de este libro han sido probados en va-
rios compiladores. El autor espera que funcionen en la mayoría. Para
algunos ejemplos, aparecen los resultados producidos por el programa.
Estos resultados pueden variar ligeramente de un compilador a otro; por
ejemplo, en el número de cifras decimales desplegadas en pantalla.
En algunos ejemplos no están todos los detalles ni instrucciones ne-
cesarias, aparecen únicamente las instrucciones más relevantes para ilus-
trar el tema en estudio. Usualmente aparecerán puntos suspensivos in-
dicando que hacen falta algunas instrucciones; por ejemplo, las instruc-
ciones donde se leen, se definen o se les asigna un valor a las variables.
2
Generalidades
5
2. GENERALIDADES
#include <stdio.h>
int mainO
{
printf(" Este es mi primer programa.\n");
return O;
}
6
2.1. EL PRIMER PROGRAMA
7
2. GENERALIDADES
int mainO
{
eout«" Este es mi primer programa en C++."«endl;
return O;
}
#inelude <iostream>
using namespaee std;
int mainO
{
eout«" Este es mi primer programa en C++."«endl;
return O;
}
8
2.2. EDITAR, COMPILAR, EJECUTAR
#include <stdio.h>
int
main() {printf
( 11 Este es mi primer programa. \n")
return
O;}
9
2. GENERALIDADES
2.2.1 g++
Este compilador está en la mayoría de las distribuciones de Linux, o
posiblemente en todas. Es en realidad el mismo compilador gcc.
Para editar el programa fuente, utilice el editor de su preferencia,
por ejemplo, Emacs, vi, pico. No olvide guardar los cambios hechos.
Si se da la orden
g++ prog01.cpp -o algo
2.2.2 bcc32
10
2.2. EDITAR, COMPILAR, EJECUTAR
ventana de sistema.
La edición del archivo se hace con cualquier editor de texto de Win-
dows (bloc de notas, Wordpad, Emacs para Windows ... ) o de DOS
(edit...).
Este compilador para DOS viene con IDE (ambiente integrado). Sin
embargo también se puede utilizar únicamente el compilador de la misma
forma como se usa el compilador bee32. Basta con cambiar bee32 por
tee.
Para utilizar el IDE, es necesario, como primer paso, disponer de una
ventana de DOS. Desde allí, el compilador y su ambiente se activan por
medio de la orden
te
Ya dentro de Turbo C++, el ambiente muestra directamente la ventana
del editor. Es necesario escribir el programa o hacer las modificaciones
deseadas.
Se tiene acceso a la barra de menú, en la parte superior de la ven-
tana, por medio del mouse o por medio de la tecla Alt acompañada
simultáneamente de la primera letra de la orden o submenú. Por ejem-
plo Alt-F para el sub menú File.
11
2. GENERALIDADES
Para algunas de estas secuencias de operaciones hay una tecla que re-
emplaza la secuencia. La secuencia File Save se puede reemplazar por
F2.
Para compilar:
r>Compile r>Compile o Alt-F9
Para correr el programa
r>Run r>Run o Ctrl-F9
La secuencia anterior, cuando el programa (la última versión) no ha sido
compilado, en un primer paso lo compila y después lo corre. Entonces,
en muchos casos, no es necesaria la secuencia Compile Compile.
Después de correr el programa, el ambiente Thrbo C++, vuelve in-
mediatamente a la pantalla donde está el editor. Si el programa muestra
algunos resultados en pantalla, éstos no se ven, pues la pantalla de re- 1\
sultados queda inmediatamente oculta por la pantalla del editor. Para
ver la pantalla de resultados:
Alt-F5
Para volver a la pantalla del editor, oprima cualquier tecla.
Hasta aquí, se creó un proyecto con nombre prog50; esto quiere de-
cir que hay una carpeta, con el nombre prog50, con la siguiente ruta
(posiblemente) :
12
2.2. EDITAR, COMPILAR, EJECUTAR
La secuencia
r> Build r> Build o F7
hace la ~dición de enlaces (link) y, si no hay errores, crea el ejecutable
prog50. ebce en la carpeta Debug. Si es necesario, esta secuencia también
guarda y compila.
La secuencia
r>Build r>Execute o Ctrl-F5
activa el ejecutable prog50. exe
Las otras veces ya no es necesario crear el proyecto, basta con abrir
el archivo adecuado. La secuencia
r> File r> Recent W orkpaces
permite escoger el proyecto prog50 y hacer las modificaciones necesa-
rias. Para compilar, enlazar y correr se utilizan las mismas secuencias
anteriores.
En Visual C++ y en Dev-C++, varias de estas secuencias se pueden
reemplazar por íconos que aparecen en una de las barras superiores; por
ejemplo el ícono del disquete para guardar, la carpeta semiabierta para
abrir un documento ...
13
2. GENERALIDADES
2.2.5 Dev-C++
#include <iostream.h>
#include <stdlib.h>
int mainO
{
system("PAUSE");
return O;
}
La secuencia
r>Execute r>Compile and Run o Ctrl-FlO
encadena las tres acciones importantes: guardar, compilar y ejecutar.
Cuando en una ocasión anterior ya se hizo una parte del programa y se
desea modificarlo, se puede utilizar la secuencia
r> File r> Open project or file o Ctrl-o
14
2.3. COMENTARIOS
2.3 Comentarios
Un comentario en C es una porción de texto que está en el programa
fuente con el objetivo de hacerlo más claro, pero no influye en nada en
el programa ejecutable.
#include <stdio.h>
II Comentario de una linea, especifico de C++
1* Comentario en C. *1
1*
Puede ser
de varias
lineas
int maine)
{
printf(" Este es mi primer programa.\n");
return O;
}
15
2. GENERALIDADES
2.4 Identificadores
Los identificadores sirven para el nombre de variables o de funcio-
nes. La longitud máxima de un identificador depende del compilador
utilizado y del lenguaje (C o C++). Generalmente no es inferior a 32;
más aún, puede ser muy grande. Los identificadores sólo usan símbolos
alfanuméricos, es decir, letras minúsculas, letras mayúsculas, dígitos y
el símbolo de subrayado:
16
2.4. IDENTIFICADORES
al
Al
peso_especifico_del_mercurio
blj
peso especifico
peso-especifico
la
peso'esp
float
cout«printf«endl;
17
2. GENERALIDADES
pem
es corto, y tal vez eficiente, pero dice poco con respecto al peso específico
del mercurio.
Usualmente, cuando es necesario, se emplean las tres o cuatro pri-
meras letras de cada palabra. Para diferenciar visualmente las palabras,
éstas se separan por el símbolo de subrayado o se escribe la primera letra
de cada palabra (a partir de la segunda) en mayúsculas; por ejemplo,
un identificador para el peso específico del mercurio puede ser
pesoEspHg
peso_esp_hg
a b e
18
2.5. TIPOS DE DATOS
char
int
float
double
double a, b, e;
int i, denom;
int j;
La siguiente tabla muestra los tamaños usuales en bytes (un byte, u octe-
to, es una unidad de información compuesta por 8 bits; un bit, acrónimo
de binary digit, es la unidad más sencilla de información y puede tomar
19
2 GENERALIDADES
unsigned long
20
2.6. OPERADOR DE ASIGNACIÓN
variable = expresión;
int a;
double x, y;
char c;
a = 100;
Y 9.0/4.0;
x = 5.0 + y;
a = a+3;
c = 'A' ;
21
2. GENERALIDADES
int i 3, j 5;
+ / * % ++
int i, j, k;
double x, y;
i 27;
j 4;
k i+j;
cout«k«endl;
x = 10.0;
Y = 3.0;
cout«x/y«endl;
cout«x*y«endl;
cout«i/j«endl;
22
2.7. OPERADORES ARITMÉTICOS
31
3.33333
30
6
int i, j;
i = 27;
j = -4;
cout«i/j«endl;
x = -y;
int i, j, k;
i 25;
j = 7;
k = i%j;
cout«k«endl;
23
2. GENERALIDADES
int i 4, j 4, k;
k = i++;
cout«i«" "«k«endl;
k = ++j;
cout«j«" "«k«endl;
5 4
5 5
k ++ j ; es equivalente a j++;
k = j;
también es equivalente a ++ j ;
k = j;
24
2.8. PRIORIDAD DE LOS OPERADORES ARITMÉTICOS
(a/b)/c
a/(b/c)
25
2. GENERALIDADES
x = a/b/e; // x (a/b)/e;
x = a*b+e/d-e*b; // x ( (a*b) + (c/d) ) - (e*b);
x = al-e; // x a/C-e);
x = (a/b)/e;
x = a*b + c/d - e*b;
x = a/C-e);
26
2.10. FUNCIONES MATEMÁTICAS
a = a + 2.0;
b b + c;
a += 2.0;
b += c;
a = a*3.0;
i i - 2;
b b/c;
3.0;
2;
b 1= C;
27
2. GENERALIDADES
#include <iostream.h>
#include <math.h>
int maine)
{
double a = 7.0, b = 3.1, c = -5.72;
double raiz1, raiz2;
#include <iostream.h>
#include <math.h>
int mainO
{
double a = 7.0, b = 3.1, c = -5.72;
double raiz1, raiz2, d, a2¡
a2 = 2.0*a¡
d = sqrt(b*b-4.0*a*c);
28
2.10. FUNCIONES MATEMÁTICAS
29
2. GENERALIDADES
#inelude <stdio.h>
#inelude <math.h>
int mainO
{
double a, b, e, raiz1, raiz2, d, a2;
printf(" a = ");
seanf ("%lf", &a);
printf(" b = ");
seanf("%lf", &b);
printf(" e = ");
seanf("%lf", &e);
a2 = 2.0*a;
d = sqrt(b*b-4.0*a*e);
raiz1 = (-b + d )/a2;
30
2.11. ENTRADA DE DATOS Y SALIDA DE RESULTADOS
En la orden:
31
2. GENERALIDADES
un cambio de línea,
un espacio,
el valor de a,
x*x +
el valor de b,
x +
el valor de e,
= O
dos cambios de línea.
%15.4f
32
2.11. ENTRADA DE DATOS Y SALIDA DE RESULTADOS
%10.4e
%5d
#include <iostream.h>
#include <math.h>
int main()
{
double a, b, c, raiz1, raiz2, d, a2;
cout«U a = u;
cin»a;
cout«U b U •
,
cin»b;
cout«U c = u;
cin»c;
33
2. GENERALIDADES
a2 = 2.0*a;
d = sqrt(b*b-4.0*a*c);
raizl (-b + d )/a2;
raiz2 = (-b - d )/a2;
int result;
34
2.12. CONVERSIONES DE TIPO EN EXPRESIONES MIXTAS
}
else {
En el ejemplo
int i = 8, j = 3;
double x = 1.5, u, z·,
35
2. GENERALIDADES
u = i/j*x;
z = i*x/j;
cout«u«endl;
cout«z«endl;
aparentemente u y z tienen el mismo valor, puesto que, según el orden en
que se efectúan las operaciones, en ambos casos se tiene (i x) / j. Pero
en realidad u vale 3.0 y z vale 4.0. En cada expresión hay dos operaciones
de igual prioridad, entonces el orden es de izquierda a derecha. Para u se
hace primero la división entera, con resultado 2, y enseguida el producto
doble precisión, y da 3.0. Para z se hace primero la multiplicación doble
precisión, con resultado 12.0, y enseguida la división doble precisión, y
da 4.0.
2.13 Moldes
Algunas veces es necesario utilizar temporalmente el valor de una
variable en otro tipo diferente de aquel con que fue definida. Supongamos
que la variable i se va a utilizar muchas veces como entera y por tanto
ha sido definida como entera, pero en algún momento se requiere usar
su valor como doble precisión. Esto se hace en C, anteponiendo el molde
(double). Por ejemplo:
int i, j;
double x, y;
i 3·,
j 4;
y (double)i;
x y*y/(double)j;
En el ejemplo anterior, no se requiere colocar el molde a j, puesto
que la multiplicación y*y da doble precisión, y al hacer la división de un
valor doble precisión por un entero, se hace previamente la conversión
del valor entero a doble precisión.
De igual manera se pueden utilizar los moldes (float) e (int). Al
utilizar el molde (int) para valores float o double, C trunca al entero
más cercano comprendido entre O y el valor, o sea,
(int)x signo(x)llxlJ .
36
2.13. MOLDES
En C++ los moldes tienen forma funcional, visualmente más clara. Por
ejemplo, el molde double ( ) es una función cuyo argumento es de cual-
quier tipo y el resultado es doble precisión. Así, son ejemplos de moldes
en C++:
int i;
double y;
i = 3;
Y = sqrt(double(i));
l/y = sqrt(i);
cout«y«n n«int(y)«endl;
Ejercicios
Para cada uno de los enunciados siguientes, defina cuáles son los datos
necesarios. Haga un programa que lea los datos, realice los cálculos y
muestre los resultados.
37
2. GENERALIDADES
38
2.13. MOLDES
2.24 Dado un plano y la recta que pasa por dos puntos u y v, halle el
punto de intersección de la recta y el plano.
)
/
39
2.13. MOLDES
2.24 Dado un plano y la recta que pasa por dos puntos u y v, halle el
punto de intersección de la recta y el plano.
)
/
39
3
Estructuras de control
En los ejemplos vistos hasta ahora, los programas tienen una estruc-
tura lineal, es decir, primero se efectúa la primera orden o sentencia,
enseguida la segunda, después la tercera y así sucesivamente hasta la
última. Por el contrario, la mayoría de los programas, dependiendo del
cumplimiento o no de alguna condición, toman decisiones diferentes.
También es muy usual repetir una o varias instrucciones mientras sea
cierta una condición. Estas bifurcaciones y repeticiones se logran me-
diante las sentencias o estructuras de control.
(
3.1 if
sentencia_1 ;
if ( condicion) sentencia_a;
else sentencia_b;
sentencia_2 ;
La líneas primera y última no hacen parte del if, pero aparecen para ver
mejor la secuencia de realización de las órdenes. Tal como está presenta-
do, las órdenes de estas dos líneas siempre se realizan. Si la condición se
cumple, se realiza sentencia_a, y si no se cumple, se realiza sentencia_b.
En resumen, dependiendo de que se cumpla o no la condición, se realiza
41
3. ESTRUCTURAS DE CONTROL
sentencia_l ; sentencia_l ;
sentencia_a; sentencia_b;
sentencia_2 ; sentencia_2 ;
double a, b, e;
sentencia_l ;
i f ( condicion) sentencia_a;
sentencia_2 ;
sentencia_l; sentencia_l ;
sentencia_a; sentencia_2 ;
sentencia_2 ;
int a, b, e;
42
3.1. IF
sentencia_l ;
if ( condicion) {
sentencia_al;
sentencia_a2 ;
}
el se {
sentencia_bl;
sentencia_b2 ;
}
sentencia_2 ;
sentencia_l; sentencia_l ;
sentencia_al; sentencia_bl;
sentencia_a2 ; sentencia_b2 ;
sentencia_2 ;
43
3. ESTRUCTURAS DE CONTROL
II#include <iostream.h>
#include <math.h>
#include <stdio.h>
int mainO
{
double a, b, c, raizl, raiz2, d, a2, pReal, plmag;
a2 = 2.0*a;
d = b*b-4.0*a*c;
i f ( d >= O. O ){
II raices reales
d = sqrt(d);
raizl = (-b + d )/a2;
raiz2 = (-b - d )/a2;
printf("\n Raices reales: %lf , %lf\n", raizl,
raiz2);
}
else{
II raices complejas
d = sqrt(-d);
pReal = -b/a2;
plmag = d/a2;
printf("\n Raices complejas: lO);
printf("%lf + %lf i , %lf - %lf i\n",
pReal, plmag, pReal, plmag);
}
return O;
}
44
3.2. OPERADORES RELACIONALES Y LÓGICOS
< menor
> mayor
<= menor o igual
>= mayor o igual
igual
!= diferente
&& y
11 o
no
if( i != O ) .•.
que escribir
i f ( i ) ...
45
3. ESTRUCTURAS DE CONTROL
La primera expresión es, tal vez, más fácil de entender, pues concuerda
con nuestra manera lógica de razonar. Es más claro decir "si i es diferente
de cero ... " que decir" si i ... ".
También se puede escribir como condición del i f (y de otras estruc-
turas de control) expresiones menos simples.
if ( a*c-b*d ) ...
Más aún, esa expresión puede ser de tipo doble precisión. Esto es líci-
to aunque no muy usual. La condición sería falsa únicamente cuando
a*c-b*d fuera exactamente 0.0. Para otros valores, aún muy cercanos a
cero, como 1. OE-20, la condición es verdadera. Lo anterior es un poco
inexacto, en realidad depende del compilador, del computador y del tipo
de la expresión. Para un valor doble precisión, en algunos compiladores,
los valores positivos menores a 2. 4E-323 se consideran nulos.
Como las comparaciones dan como resultado un valor entero O o
1, se pueden hacer asignaciones con este valor. Esto quita un poco de
claridad, pero es completamente lícito. Por ejemplo, se puede escribir
n x >= 0.0;
II#include <iostream.h>
#include <math.h>
#include <stdio.h>
int main()
{
46
3.2. OPERADORES RELACIONALES Y LÓGICOS
if( a != 0.0 ){
II ecuacion realmente cuadratica
a2 = 2.0*a;
d = b*b-4.0*a*c;
if ( d >= O. O ){
II raices reales
d = sqrt(d);
raizl = (-b + d )/a2;
raiz2 = (-b - d )/a2;
printf("\n Raices reales: ");
printf (" %lf , %lf\n" , raizl, raiz2);
}
else{
II raices complejas
d = sqrt(-d);
pReal = -b/a2;
plmag = d/a2;
printf("\n Raices complejas: ");
printf("%lf +- %lf i\n", pReal, plmag);
}
}
else{
II ecuacion no cuadratica
if( b != 0.0 ){
II ecuacion lineal
printf ("La ecuacion es lineal. Su raiz es: %lf\n",
-c/b);
}
else{
47
3. ESTRUCTURAS DE CONTROL
3.3 for
double suma;
int i;
suma = 0.0;
for( i=1; i <= 15; i++){
suma += 1.0/i;
printf("%5d %12. 6lf\n" , i, suma);
}
48
3.3. FOR
sentencia_a;
for(INIC; CDC; MODIF) {
sentencia_l ;
sentencia_2 ;
}
sentencia_b;
sentencia_a;
for(INIC; CDC; MODIF) sentencia_l;
sentencia_b;
49
3. ESTRUCTURAS DE CONTROL
int n, i, nFact;
cout«" n 11 •
cin»n;
nFact = 1;
for( i = 2; i <= n; i++) nFact *= i;
cout«nFact;
int n, i, j, suma;
n = 20;
suma = O;
for( i=l, j=n; i<j && i*i<j*j-l0*j i++, j 2){
suma += i+j;
printf(" %d %d \n",i,j);
}
printf(1I suma %d \n", suma);
1 20
2 18
3 16
4 14
suma = 78
50
3.4. WHILE
3.4 while
La estructura while permite repetir varias veces una sentencia o
una secuencia de sentencias. Es como una simplificación del f or. Aquí
no hay variable de control, no hay una parte explícita de inicialización
ni de modificación. Usualmente en el for se conocía por anticipado el
número de veces que se iba a efectuar el cuerpo del foro En el while,
simplemente, cuando no se cumpla la condición se acaba el while. La
forma general del while es:
sentencia_a;
while ( condicion ) {
sentencia_1 ;
sentencia_2 ;
}
sentencia_b;
Si se necesita repetir una sola instrucción, la forma del while es:
sentencia_a;
while ( condicion ) sentencia_1;
sentencia_b;
Después de sentencia_a, para empezar el while se verifica la condición
de continuación. Si se cumple, se realizan las sentencias dentro del cuerpo
del while: sentencia_1 , sentencia_2 ... Cada vez que se realiza la última
sentencia dentro del cuerpo del while, se pasa a verificar la condición,
y si se cumple, se vuelve a realizar el grupo de sentencias del while. Si
la primera vez no se cumple la condición, entonces nunca se efectúan las
sentencias del while.
El desarrollo en serie de Taylor para la función exponencial está dado
por:
51
3. ESTRUCTURAS DE CONTROL
lanl < é.
1+ ISnl -
El 1 en el denominador se colocó simplemente para asegurar que el
denominador no sea nulo. Una salida más elegante y precisa sería evaluar
una cota para el resto y utilizar este valor para detener el proceso.
#include <math.h>
#include <stdio.h>
int maine)
{
double x, sn, an, nFact, eps;
int n;
eps = 1. Oe-8 ;
sn = 1.0 + x;
nFact = 1;
n = 1;
an = x;
while( fabs(an)/( 1.0 + fabs(sn) ) > eps ){
n++;
nFact *= n;
52
3.4. WHILE
an = pow(x,n)/nFact;
sn += an;
}
printf(" exp(x) %lf\n", sn);
return O;
}
X2 x4 x6 (Xl x2n
cos X = 1 - 2 + 24 - 720 + ... = 2:) -1 t
n=ü
(2n)!
2n(2n - 1) .
53
3. ESTRUCTURAS DE CONTROL
eps = 1. Oe-8 ;
XX x*x;
an -xx/2.0;
sn 1.0 + an;
n2 2;
while( fabs(an)/( 1.0 + fabs(sn) ) > eps ){
n2 += 2;
an *= -xx/n2/(n2-1.0);
sn += an;
}
printf(" cos(x) %lf\n", sn);
3.5 do while
Es muy parecida a la estructura while, pero el control se hace al
final. Esto hace que el cuerpo del do while siempre se realice por lo
menos una vez. La forma general del do while es:
sentencia_a;
do {
sentencia_l ;
sentencia_2 ;
} while ( condicion );
sentencia_b;
Si se necesita repetir una sola instrucción, la forma del do-while es:
sentencia_a;
do sentencia_l;
while ( condicion );
sentencia_b;
Consideremos dos enteros positivos P y q. Su máximo común divisor se
puede calcular por el algoritmo de Euclides. Este es un proceso iterativo
en el que en cada iteración, dados dos enteros positivos Pk 2: qk, se halla
el cociente Ck y el residuo rk al dividir Pk por qk:
Pk = Ckqk + rk·
54
3.5. DO WHILE
Pk+l = qk,
qk+l = Tk·
Pk qk Ck Tk
34 15 2 4
15 4 3 3
4 3 1 1
3 1 3 O
II#include <iostream.h>
#include <math.h>
#include <stdio.h>
int maine)
{
int p, q, e, r, temp;
55
3. ESTRUCTURAS DE CONTROL
printf("\n p = ");
scanf("%d", &p);
printf(" q = ");
scanf("%d", &q);
printf("\n\n p = %d, q %d\n", p, q);
Observe que, para que dos variables intercambien sus valores, se ne-
cesita utilizar una variable intermedia que almacene temporalmente uno
de los dos valores.
La instrucción return permite salir inmediatamente de la función,
en este caso de la función main, es decir, permite salir del programa.
Más adelante se verá que return también sirve para que las funciones
devuelvan un valor.
56
3.6. SWITCH
3.6 switch
break;
case valor2
sentencia_2_1
break;
default :
sentencia_d_l
}
sentencia_b;
Si la variable de control tiene el primer valor, se efectúan las sentencias
del primer grupo y después el programa pasa a realizar sentencia_b. Si
la variable de control tiene el segundo valor, se efectúan las sentencias
del segundo grupo y después el programa pasa a realizar sentencia_b.
Si la variable de control no tiene ninguno de los valores previstos, el
programa realiza las sentencias de la parte def aul t y en seguida efectúa
sentencia_b. La parte def aul t no es indispensable desde el punto de
vista de la sintaxis, pero en la práctica puede ser útil o a veces necesaria.
Cuando para dos valores diferentes de la variable de control se tiene
que hacer el mismo grupo de sentencias, en lugar de hacer case valor _i:
grupo de sentencias y case valor _j: grupo de sentencias, se coloca sim-
plemente case valor _i: case valor _j: grupo de sentencias.
57
3. ESTRUCTURAS DE CONTROL
3.7 break
Además del uso en la estructura switch, la instrucción break se
puede utilizar en las estructuras for, while, do while. En estos bucles
el control se hace siempre al comienzo o al final del cuerpo del bucle. En
58
3.7. BREAK
algunos casos, en programas bastante complejos puede ser útil salir del
bucle, mediante un if, en un sitio intermedio del bucle. Para esto se usa
la instrucción break.
sentencia_a;
for( INIC; CDC; MODIF ){
sentencia_1 ;
sentencia_2 ;
if ( condicion_2 ) {
sentencia_c1 ;
sentencia_c2 ;
break;
}
}
sentencia_b;
Si en una pasada del programa por el cuerpo del bucle, se cumple la con-
dición del if, condicion_2, entonces el programa realiza las instrucciones
sentencia_c_1, sentencia_c2, ... , y salta a la instrucción sentencia_b.
La siguiente porción de programa calcula la suma de los enteros entre
ni inclusive y n2 inclusive, menores que el mínimo múltiplo de 10 en ese
mismo intervalo. Si en el conjunto {ni, ni +i ... , n2} no hay múltiplos
de 10, calcula la suma de todos ellos. También calcula la suma de los
cuadrados de esos enteros.
div = iO;
printf(" ni n2 : ");
scanf("%d%d", &ni, &n2);
sx = 0.0;
sxx = 0.0;
for( i = ni; i <= n2; i++){
res = i%div;
if( !res ) break; II if( res o) break;
59
3. ESTRUCTURAS DE CONTROL
sx += i;
sxx += i*i;
printf ("%5d\n", i);
}
printf(" suma x %lf, suma x*x %lf\n", sx, sxx);
3.8 continue
La instrucción continue permite saltar la parte restante del cuerpo
de un bucle -for, while o do while- y pasar a empezar una nueva
iteración. Su uso en una parte intermediaria de un bucle va asociado
generalmente a un if.
sentencia_a;
for(INIC; CDC; MODIF) {
sentencia_l ;
sentencia_2 ;
if ( condicion_2 ) {
sentencia_c_l ;
sentencia_c2 ;
continue;
}
sentencia_3 ;
sentenciaA;
}
sentencia_b;
Si en una pasada del programa por el cuerpo del bucle, se cumple la con-
dición del if, condicion_2, entonces el programa realiza las instrucciones
sentencia_cl, sentencia_c_2, ... , y vuelve a empezar una nueva itera-
ción sin ejecutar las sentencias restantes del bloque for (sentencia_3,
sentenciaA ... ). Como en el esquema anterior se trata de un for, en-
tonces realiza la modificación indicada en MODIF.
60
3.9. GOTO y EXIT
div = 10;
printf (" nl n2 : ");
scanf("%d%d", &nl, &n2);
sx = 0.0;
sxx = 0.0;
for( i = nl; i <= n2; i++){
res = i%div;
if( !res ) continue; II if( res O ) continue;
sx += i;
sxx += i*i;
printf("%5d\n", i);
}
printf(" suma x = %lf, suma x*x = %lf\n", sx, sxx);
61
3. ESTRUCTURAS DE CONTROL
goto final!;
final! :
II#include <iostream.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
int n, i, nPrimo, res;
if ( n<= 1 ){
printf(lI\n\n Valor inadecuado.\n\n");
exit (1) ;
62
3.9. GOTO y EXIT
}
nPrimo = 1;
II 1 indica que n es primo, O indica que no.
II Inicialmente se supone que n es primo.
for( i=2; i*i <= n; i++){
res = n%i; II residuo
if( !res ){
nPrimo = O;
break;
}
}
if( nPrimo ) printf(" es primo.\n");
else printf(II no es primo, es divisible por %d\n", i);
return O;
}
Ejercicios
Para cada uno de los enunciados siguientes, defina cuáles son los da-
tos necesarios. Haga un programa que lea los datos, verifique que no hay
inconsistencias (por ejemplo, distancias negativas o nulas; dos vértices
de un triángulo iguales; recta que pasa por un punto paralela a d = O... ),
estudie todas las posibilidades relajando algunas suposiciones (por ejem-
plo: solución única, sin solución, número infinito de soluciones ... ), realice
los cálculos y muestre los resultados.
63
3. ESTRUCTURAS DE CONTROL
00 1
Lk!'
k=ü
64
3.9. GOTO y EXIT
1 1 1
<p(n) = n(1 - - )(1 - - ) ... (1 - -).
PI P2 Pk
n 00 (-1)m x2m
Jn(x) = x L
m=O
22m+n m! (n + m)!'
= ~ (_1)m (~)2m+n.
~ m! (n+m)! 2
m=O
65
3. ESTRUCTURAS DE CONTROL
2k+ 1 k
Pk+1(X) = -k-- x Pk(X) - -k-Pk-1(X).
+1 +1
66
4
Funciones
4.1 Generalidades
La forma general de una función en C es la que se presenta a con-
tinuación. Posteriormente hay varios ejemplos que permiten un mejor
manejo de las las funciones.
67
4. FUNCIONES
#include <stdlib.h>
jj---------------------------------------------------------
double fact( int k );
jj=========================================================
int maine)
{
int n;
printf("\n\n n n!\n\n");
for( n = O; n <= 15; n++){
printf(I%5d%14.01f\n", n, fact(n));
}
return O;
}
jj=========================================================
double fact( int k )
{
jj calcula el factorial de k >= O
jj devuelve O si k < O.
int n;
double kFact 1.0;
H( k < O ){
printf(" %d valor inadecuado para factorial\n");
return 0.0;
}
for( n = 2; n <= k; n++) kFact *= n;
return kFact;
}
68
4.1. GENERALIDADES
if( k < O ){
printf(" %d valor inadecuado para factorial\n");
return 0.0;
}
return kFact;
for( n = 2; n <= k; n++) kFact *= n;
}
int i;
69
4. FUNCIONES
void pausa(void)
{
char c;
En el ejemplo que sigue, también hay una pausa hasta que el usuario
oprima cualquier tecla. Requiere el uso de la función getchO, que no
hace parte de la norma ANSI C. Su archivo de cabecera es conio.h.
Viene con algunos compiladores, por ejemplo, los de la casa Borland.
void pausa2(void)
{
II necesita conio.h
70
4. FUNCIONES
72
4.1. GENERALIDADES
void pausa3(void)
{
int c;
71
4.1. GENERALIDADES
fa f(a);
fb f(b);
73
4. FUNCIONES
74
4.2. FUNCIONES RECURRENTES
double i;
if( n < O ){
printf(1I n = %d inadecuado.\n", n);
return 0.0;
}
if( n < 2 ) return 1.0;
else return( n*factRec(n-l) );
}
75
4. FUNCIONES
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
m = 2;
n = 5;
printf(1I MAIN1: m %d n %d\n", m, n);
intercO(m, n);
printf(" MAIN2: m %d n %d\n", m, n);
return O;
}
11=========================================================
void intercO( int i, int j)
{
int t;
76
4.3. PARÁMETROS POR VALOR Y POR REFERENCIA
MAIN1 : m 2 n 5
FUNC1 : i 2 j 5
FUNC2: i 5 j 2
MAIN2: m 2 n 5
m = 2;
n = 5;
printf(" MAIN1: m %d n %d\n", m, n);
interc1(&m, &n);
printf(" MAIN2: m %d, n %d\n", m, n);
return O;
77
4. FUNCIONES
}
11=========================================================
void intercl( int *i, int *j)
{
int t;
t = *i;
*i *j;
*j = t;
}
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
78
4.3. PARÁMETROS POR VALOR Y POR REFERENCIA
m = 2;
n = 5;
printf (" MAIN1: m %d n %d\n", m, n);
interc(m, n);
printf(" MAIN2: m %d, n %d\n", m, n);
return O;
}
11=========================================================
void interc( int &i, int &j)
{
int t;
t i',
i j;
j t;
}
II indic valdra:
II 1 si se obtuvo una raiz,
79
4. FUNCIONES
80
4.4. PARÁMETROS POR DEFECTO
return m;
}
if( fa*fm < 0.0 ){
II nuevo intervalo [a,m]
b = m;
fb = fm;
}
else{
II nuevo intervalo [m,b]
a = m;
fa = fm;
}
}
indic = 1;
if( fabs(fa) <= fabs(fb) ) return a;
else return b;
}
81
4. FUNCIONES
}
jj---------------------------------------------------------
int bisec(double a, double b, double &raiz, double epsX,
double epsF)
{
funcl( ... );
82
4.6. SOBRECARGA DE FUNCIONES
int main(void)
{
nLlmadasF = O;
... = sin(t/RADIAN);
}
//--------------------------------------
fune1( ... )
{
nLlamadasF++;
... = 2.0*PI;
}
83
4. FUNCIONES
max(x, y);
= maxCi, j);
max(x, y, z);
max Ci, j, 4);
}
jj================================================
double maximo( double a, double b)
{
if( a >= b ) return a;
el se return b;
}
jj------------------------------------------------
double maximo( double a, double b, double e)
{
if( a >= b && a >= e) return a;
if( b >= e ) return b;
el se return e;
}
jj------------------------------------------------
int maximo( int a, int b)
{
if( a >= b ) return a;
else return b;
}
jj------------------------------------------------
int maximo( int a, int b, int e)
{
if( a >= b && a >= e) return a;
if( b >= e ) return b;
84
4.7. BIBLIOTECA ESTÁNDAR
el se return e;
}
}
//================================================
int factorial( int n )
{
}
//------------------------------------------------
double factorial( int n )
{
85
4. FUNCIONES
Ejercicios
Para cada uno de los enunciados siguientes, defina cuáles son los
datos necesarios. Haga un programa que lea los datos, llame la función
que realiza los cálculos y devuelve los resultados y, finalmente,
en la función main, muestre los resultados. La función debe analizar los
parámetros, estudiar su consistencia o inconsistencia e informar sobre
ello por medio de los resultados devueltos. También, cuando se justifica,
haga una función para la lectura de los datos. Puede ser útil, cuando
el proceso es bastante complejo, hacer funciones más simples que hacen
partes específicas del proceso y son llamadas desde otra función que
coordina los cálculos.
86
5
Arreglos
double x [80] ;
int factores[30];
char codSexo[20];
Los nombres deben cumplir con las normas para los identificadores. La
primera línea indica que se han reservado 80 posiciones para números
doble precisión. Estas posiciones son contiguas. Es importante recalcar
87
5. ARREGLOS
}
11------------------------------------------------
funcione ... , double x[] , .. . )11 definicion de la funcion
{
II cuerpo de la funcion
88
5.1. ARREGLOS UNIDIMENSIONALES
}
//------------------------------------------------
funcion( ... , double *x, ... )// definicion de la funcion
{
// cuerpo de la funcion
// Arreglos unidimensionales
// Lectura y escritura de un vector y calculo del promedio
//------------------------------------------------
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
//------------------------------------------------
void lectX(double *x, int n, char c );
void escrX(double *x, int n );
double promX( double *x, int n);
//================================================
int mainO
{
double v [40] ;
int n;
89
5. ARREGLOS
int i;
90
5.1. ARREGLOS UNIDIMENSIONALES
int i;
double s = 0.0;
i f ( n <= O ){
printf (" promX: n %d inadecuado\n", n);
return 0.0;
}
for( i = O; i < n; i++) s += xCi] ;
return sin;
}
v(1)
v(2)
91
5. ARREGLOS
II Arreglos unidimensionales
II Factores primos de un entero >= 2
11------------------------------------------------
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
11------------------------------------------------
int primerDiv( int n);
int factoresPrimos( int n, int *fp, int &nf, int nfMax);
11================================================
int maine)
{
int vFactPrim[40]; II vector con los factores primos
int n;
int nFact; II numero de factore primos
int i;
printf(" n = ");
scanf ( "%d", &n);
if( factoresPrimos(n, vFactPrim, nFact, 40) ){
for(i = O; i < nFact; i++) printf(" %d",
vFactPrim [i] ) ;
printf("\n");
}
92
5.1. ARREGLOS UNIDIMENSIONALES
el se printf(II ERROR\n");
return O;
}
11================================================
int primerDiv( int n)
{
II n debe ser mayor o igual a 2.
II Calcula el primer divisor, mayor que 1, de n
II Si n es primo, devuelve n.
II Si hay error, devuelve O.
int i',
if( n < 2 ){
printf (" primerDi v: %d inadecuado. \n ", n);
return O;
}
for( i = 2; i*i <= n; i++) if( n%i O ) return i;
return n;
}
11========·========================================
int factoresPrimos( int n, int *fp, int &nf, int nfMax)
{
II factores primos de n
II devuelve O si hay error.
II devuelve 1 si todo esta bien.
II fp vector con los factores primos
II nf numero de factores primos
II nfMax : tamano del vector fp
int d, indic;
if( n < 2 ){
printf(" factoresPrimos: %d inadecuado.\n", n);
return O;
}
nf O;
do{
93
5. ARREGLOS
Los sitios para los elementos de a están contiguos en el orden fila por
fila, o sea, a [O] [O], a [O] [1], a [O] [2], a [O] [3], a [1] [O], a [1] [1] ,
a[l] [2], a[l] [3], a[2] [O], a[2] [1], a[2] [2], a[2] [3].
En el siguiente ejemplo, el programa sirve para leer matrices, escri-
birlas y calcular el producto. Lo hace mediante la utilización de funciones
que tienen como parámetros arreglos bidimensionales.
j j prog14
j j Arreglos bidimensionales
94
5.2. ARREGLOS MULTIDIMENSIONALES
95
5. ARREGLOS
escrAO(a, m, n);
lectAO(b, n, q, 'B');
printf(" B : \n");
escrAO(b, n, q);
int i, j;
int i, j;
int nEltosLin 5; II numero de elementos por linea
96
5.2. ARREGLOS MULTIDIMENSIONALES
if«j+l)%nEltosLin o 11 j==n-l)printf("\n");
}
}
}
jj------------------------------------------------
int prodABO(double a[] [40], int m, int n, double be] [40],
int p, int q, double c[] [40])
{
jj producto de dos matrices, a mxn, b pxq
jj devuelve 1 si se puede hacer el producto
jj devuelve O si no se puede
int i, j, k;
double s;
97
5. ARREGLOS
5.3 Cadenas
Los arreglos unidimensionales de caracteres, además de su manejo
estándar como arreglo, pueden ser utilizados como cadenas de caracteres,
siempre y cuando uno de los elementos del arreglo indique el fin de la
cadena. Esto se hace mediante el carácter especial
'\0'
En el ejemplo
98
5.3. CADENAS
Como esta?
II prog15b
II Cadena de caracteres
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
int maine)
{
char aviso [30] ;
99
5. ARREGLOS
char aviso[30];
char nombre[81J;
En C++ se puede utilizar cin para leer cadenas que no contengan es-
pacios. Cuando hay un espacio, es reemplazado por fin de cadena.
char nombre[81J;
100
5.3. CADENAS
strcpyC , )
strcat C , )
strlenC )
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int mainO
{
char aviso [30] ;
101
5. ARREGLOS
return O;
}
II funcion strcat
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int mainO
{
char nombre [41] , apell[41] , Nombre[81];
102
5.4. INICIALIZACIÓN DE ARREGLOS
double x[4];
x [O] 1.1 ;
x[1] 1.2;
x [2] 1.3;
x[3] 1.4;
Si dentro de los corchetes hay menos valores que el tamaño del arreglo,
generalmente e asigna O. O a los faltantes. El ejemplo
double x[4];
x[O] 1.1 ;
x [1] 1.2;
x[2] 0.0;
x [3] 0.0;
es equivalente a
double x[3];
x[O] 1.1;
x[l] 1.2;
x [2] 1. 3;
103
5. ARREGLOS
char saludo[12];
Para arreglos bidimensionales, basta con recordar que primero están los
elementos de la fila 0, enseguida los de la fila 1, y así sucesivamente. La
inicialización
a [O] [O] = 1. 1;
a[O] [1] = 1.2;
a [O] [2J = 1. 3;
a[l] [O] = 1.4;
a[1] [1] = 1.5;
a [1J [2J = 1. 6 ;
104
5.4. INICIALIZACIÓN DE ARREGLOS
En el ejemplo anterior, e sabe que las filas tienen tres elementos, en-
tonces en el arreglo a debe haber dos filas. En el ejemplo que sigue, e
asigna ceros a lo que queda faltando hasta obtener filas completas.
Lo anterior es equivalente a
double a [] [] = { 1. 1, 1. 2, 1. 3, 1. 4, 1. 5, 1. 6} ;
double b [2] [] = { 1. 1, 1. 2, 1. 3, 1. 4, 1. 5, 1. 6} ;
Ejercicios
Para cada uno de los enunciados siguientes, defina cuáles son los
datos necesarios. Elabore un programa que lea los datos, llame la función
(o las funciones) que realiza los cálculos y devuelve los resultados, y
finalmente, haga que el programa principal (la función main) muestre
los resultados.
105
5. ARREGLOS
5.17 Dados un vector x de n componentes y una lista, VI, V2, ... , V m es-
trictamente creciente, averigüe cuantos elementos de x hay en cada
uno de los m + 1 intervalos (00, VI], (VI, V2], (V2, V3], ... , (Vm-I, V m ],
(V m , 00).
5.18 Dado un vector de enteros positivos, halle el m.c.d.
106
5.4. INICIALIZACIÓN DE ARREGLOS
5.26 Dados n puntos en ]R2, PI, P2, ... , P n . Verifique que la línea poli-
gonal cerrada P1 P2... Pn P1 sea de Jordan (no tiene "cruces").
5.27 Dados n puntos en ]R2, PI, P2, ... , P n , tal que la línea poligonal
cerrada P 1 P2 ... Pn P 1 es de Jordan, averigüe si el polígono determi-
nado es convexo.
5.28 Dados n puntos en ]R2, PI, P2, ... , Pn , tal que la línea poligonal
cerrada PtP2 ... Pn P1 es de Jordan, halle el área del polígono deter-
minado.
5.29 Sea x un vector en ]Rn y A una matriz de tamaño m x n definida
por una lista de p triplas de la forma (ik,jk, Vk) para indicar que
aik1k = Vk Y que las demás componentes de A son nulas; calcule
Ax.
5.30 Considere un conjunto A de n elementos enteros almacenados en
un arreglo a. Considere un lista de m parejas en A x A. Esta lista
define una relación sobre A. Averigüe si la lista está realmente
bien definida, si la relación es simétrica, antisimétrica, reflexiva,
transitiva y de equivalencia.
5.31 Considere un conjunto A de n elementos y una matriz M de ta-
maño n x n que representa una operación binaria sobre A. Averigüe
si la operación binaria está bien definida, si es conmutativa, si es
asociativa, si existe elemento identidad, si existe inverso para cada
elemento de A.
107
5.4. INICIALIZACIÓN DE ARREGLOS
5.26 Dados n puntos en ]R2, PI, P2, ... , P n . Verifique que la línea poli-
gonal cerrada P1 P2... Pn P1 sea de Jordan (no tiene "cruces").
5.27 Dados n puntos en ]R2, PI, P2, ... , P n , tal que la línea poligonal
cerrada P 1 P2 ... Pn P 1 es de Jordan, averigüe si el polígono determi-
nado es convexo.
5.28 Dados n puntos en ]R2, PI, P2, ... , Pn , tal que la línea poligonal
cerrada PtP2 ... Pn P1 es de Jordan, halle el área del polígono deter-
minado.
5.29 Sea x un vector en ]Rn y A una matriz de tamaño m x n definida
por una lista de p triplas de la forma (ik,jk, Vk) para indicar que
aik1k = Vk Y que las demás componentes de A son nulas; calcule
Ax.
5.30 Considere un conjunto A de n elementos enteros almacenados en
un arreglo a. Considere un lista de m parejas en A x A. Esta lista
define una relación sobre A. Averigüe si la lista está realmente
bien definida, si la relación es simétrica, antisimétrica, reflexiva,
transitiva y de equivalencia.
5.31 Considere un conjunto A de n elementos y una matriz M de ta-
maño n x n que representa una operación binaria sobre A. Averigüe
si la operación binaria está bien definida, si es conmutativa, si es
asociativa, si existe elemento identidad, si existe inverso para cada
elemento de A.
107
6
Apuntadores
P &x;
q &i;
109
6. APUNTADORES
P &x;
q &i;
y *p;
j *q;
r = p+1;
s q+3;
printf(" %p %d %lf\n", p, int(p), y);
printf(II %p %d %d\n" , q, int(q), j);
printf(" %p %d\n", r, int(r»;
printf (" %p %d\n", s, int(s»;
110
6.1. APUNTADORES Y ARREGLOS UNIDIMENSIONALES
111
6. APUNTADORES
cout«n p n«p«endl;
El resultado es el siguiente:
El resultado es:
p x;
112
6.1. APUNTADORES Y ARREGLOS UNIDIMENSIONALES
q = X;
for( i=O; i <= 5; i++){
printf(I%6.2lf%6.2lf%6.2lf\n", x[iJ, *(p+i), *q);
q++;
}
El resultado es el siguiente:
int i;
double s = 0.0;
II error si n <= O
113
6. APUNTADORES
II error si n <= O
pFin = x+n;
for( p = x ; p < pFin; p++) s += *p;
return sin;
}
11------------------------------------------------
double promX3( double *x, int n)
{
II promedio de los elementos del 'vector' x
II error si n <= O
p = x;
pFin = x+n;
while( p < pFin){
s += *p;
p++;
}
return sin;
}
11------------------------------------------------
double promX4( double *x, int n)
{
II promedio de los elementos del 'vector' x
II error si n <= O
114
6.1. APUNTADORES Y ARREGLOS UNIDIMENSIONALES
p = X;
pFin = x+n;
while( p < pFin) S += *p++;
return s/n;
}
printf("%lf\n", promXl(x,4) );
printf("%lf\n", promX1C &x[2], 10) );
El resultado es el siguiente:
0.150000
0.030000
115
6. APUNTADORES
i 16;
P &i;
q &p;
printf("%p %d %p %p %d\n", p, *p, q, *q, **q);
El resultado es el siguiente:
0064FEOO 16 0064FDFC 0064FEOO 16
p es un apuntador a entero; después de la asignación tiene la dirección
de i. q es un apuntador a apuntador a entero; dicho de otra forma, un
apuntador doble a entero. Después de la asignación q tiene la dirección
del apuntador p. La orden printf escribe cinco valores:
p, es decir, la dirección de i,
el contenido apuntado por p, es decir, el valor de i,
q, es decir, la dirección de p,
el contenido apuntado por q, es decir, el valor de p,
el contenido apuntado por lo apuntado por q, o sea, el valor de i.
El primero y el cuarto valor coinciden; también coinciden el segundo y
el quinto valor.
116
6.4. MATRICES Y ARREGLOS UNIDIMENSIONALES
n = 3;
i 2;
j l',
P &c [O] [O] ;
0.800000 0.800000
117
6 APUNTADORES
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
118
6,4 MATRICES Y ARREGLOS UNIDIMENSIONALES
printf(" A : \n");
escrA1(a, m, n);
lectA1(b, n, q, 'B');
printf(" B : \n");
escrA1(b, n, q);
int i, j¡
int i;
119
6. APUNTADORES
int j;
int nEltosLin 5; II numero de elementos por linea
int i, j, k;
double s;
120
6.4. MATRICES Y ARREGLOS UNIDIMENSIONALES
Observe que la función que escribe la matriz, escrAl, lo hace fila por fila.
Para esto llama varias veces la función escrX que escribe los elementos
de un vector. O sea, cada fila de la matriz se considera como un vector
de n elementos que empieza en la dirección de a [i*n] .
En el programa anterior, como en un ejemplo ya visto, durante la
lectura de la matriz, aparecen lo subíndices i+l y j+1. Entonces, para
el usuario, aparentemente los subíndices empiezan en 1 y acaban en m
o en n.
A manera de ejemplo del paso de manejar los arreglos con subíndices
al tratamiento mediante apuntadores, a continuación hay una versión
de la función que calcula el producto entre matrices, almacenadas en
vectores, mediante el uso de apuntadores.
121
6. APUNTADORES
ain = aiO+n;
bkj = bOj;
*cij = 0.0;
while( aik < ain ){
*cij += (*aik++)*(*bkj);
bkj += q;
}
cij++;
bOj++;
}
aiO ain;
}
return 1;
}
122
6.4. MATRICES Y ARREGLOS UNIDIMENSIONALES
iq = O;
for( in=O; in < n*m; in += n){
iqj = iq;
for( j=O; j < q; j++){
s = 0.0;
ink = in;
for( kq=O; kq<n*q; kq += q){
123
6. APUNTADORES
S += a[ink]*b[kq+j];
ink++;
}
c[iqj] s;
iqj++;
}
iq += q;
}
return 1;
}
11---------------------------------------------------------
int prodABap2(double *a, int m, int n, double *b, int p,
int q, double *c)
{
II ...
amn a + m*n;
bOq b+q;
cij c;
ain a+n;
for( aiO = a; aiO < amn; aiO += n){
for( bOj = b; bOj < bOq; bOj++){
bkj = bOj;
*cij = 0.0;
for(aik = aiO; aik < ain; aik++ ){
*cij += (*aik)*(*bkj);
bkj += q;
}
cij++;
124
6.4. MATRICES Y ARREGLOS UNIDIMENSIONALES
}
ain += n;
}
return 1;
}
I n = 500 I n = 1000 I
subíndices prodABsub1 8.8 67.8
subíndices prodABsub2 8.0 63.3
subíndices prodABsub3 7.7 60.9
apuntadores prodABap1 7.8 63.1
apuntadores prodABap2 7.9 63.4
125
6. APUNTADORES
•.. , X [(n-l) *sal tox]. De manera análoga, los elementos del segundo
double s 0.0;
int i;
if(n<O){
printf("prodXY: n negativo\n");
return s;
}
if( n==O ) return s;
for(i=O; i<n; i++) s += x[i*saltox]*y[i*saltoy];
return s;
}
11------------------------------------------------
double prodXY( double *x, int saltox, double *y,
int saltoy, int n)
{
II producto escalar de dos vectores
II uso de apuntadores
II x[O] , x [saltox] , x [2*saltox] , ... , X [(n-1) *saltox]
II y[O], y [saltoy], y [2*saltoy], y [(n-l) *saltoy]
double s = 0.0;
double *xi, *yi, *xn, *yn;
126
6.4. MATRICES Y ARREGLOS UNIDIMENSIONALES
if( n < O ){
printf("prodXY: n negativo\n");
return 0.0;
}
if( n==O ) return 0.0;
if( saltox == 1 ){
if( saltoy == 1 ){
II saltox = saltoy 1
xi x',
xn x + n;
yi y;
while( xi < xn ) s += (*xi++)*(*yi++);
}
else{
II saltox = 1; saltoy != 1
xi x;
xn = x + n;
yi = y;
while( xi < xn ){
s += (*xi++)*(*yi);
yi += saltoy;
}
}
}
else{
if( saltoy == 1 ){
II saltox > 1; saltoy 1
yi y;
yn y + n;
xi x;
while( yi < yn ){
s += (*xi)*(*yi++);
xi += saltox;
}
}
else{
127
6. APUNTADORES
II saltox != 1; saltoy != 1
xi x;
xn = x + n*saltox;
yi = y;
while( xi < xn ){
s += (*xi)*(*yi);
xi += saltox;
yi += saltoy;
}
}
}
return s;
}
128
6.5. ARREGLOS ALEATORIOS
bOj = b;
while( cij < ciq ){
*cij = prodXY(aiO, 1, bOj, q, n);
cij++;
bOj++;
}
aiO += n;
}
return 1;
}
I n = 500 I n = 1000 I
subíndices prodABsub2 8.0 63.3
apuntadores prodABapl 7.8 63.1
apuntadores + prod. escalar prodABl 7.0 56.0
129
6. APUNTADORES
C provee una función para crear números aleatorios: rand (). Es-
ta función da como resultado enteros entre O y RANO_MAX, cuyo valor
está definido en el archivo de cabecera stdlib. h. La siguiente función
devuelve un valor doble precisión aleatorio, o seudoaleatorio, en el inter-
valo [a, b]. Se utiliza el cambio de variable
b-a
t = a + RANO...MAX r .
Cuando r vale O, entonces t vale a. Cuando r vale RANO_MAX, entonces t
vale b.
double r;
r = a + rand()*(b-a)/RANO_MAX;
return r;
}
int k;
130
6.6. ASIGNACIÓN DINÁMICA DE MEMORIA
double x[1000];
double a[250000]; II matriz A
int m, n;
m 400;
n 500;
double *x;
int n;
printf(" n = ");
scanf("%d", &:n );
131
6. APUNTADORES
x = malloe( n*sizeof(double) );
if ( X == NULL ){
printf(" Memoria insufieiente\n");
exit(1) ;
}
aleatX(x, n, -1.0, 1.0);
eserX(x, n);
free(x);
A lo largo de este libro se supondrá que cuando un programa usa funcio-
nes definidas con anterioridad, para que funcione, es necesario agregar, al
código presentado, el prototipo, la definición y los archivos de cabecera
de cada una de las funciones utilizadas.
La función sizeof, del lenguaje C, da como resultado un entero
que indica el número de bytes que utilizan las variables cuyo tipo es
el indicado por el parámetro. En la mayoría de las implementaciones
sizeof (double) es 8. La función malloe reserva el número de bytes in-
dicado por el parámetro. Se hubiera podido escribir x = malloe (n*8),
pero podría no funcionar en un computador con un compilador de C
donde los números doble precisión utilicen un número de bytes diferente
de 8. Cuando no hay suficiente memoria disponible, la función malloe
devuelve NULL, o sea, el apuntador valdrá NULL. Es muy conveniente
controlar siempre si hubo suficiente memoria. La función free libera el
espacio que había sido reservado para x.
El ejemplo anterior, hecho en C, y suponiendo que las funciones están
estrictamente en C, puede presentar errores con algunos compiladores,
si se compila como programa C++. Este hecho es muy poco frecuente,
pero puede suceder.
El anterior inconveniente se puede solucionar colocando un molde
para el uso de malloe:
x = (double *)malloe( n*sizeof(double) );
132
6.6. ASIGNACIÓN DINÁMICA DE MEMORIA
double *p;
int n;
printf(" n = 11);
scanf("%d", &n );
p = new double[n+l] ;
if( P == NULL ){
printf(" Memoria insuficiente\n");
exit(1) ;
}
aleatX(p, n+l, -10.0, 10.0);
escrX(p, n+l);
delete p;
int i;
double pt = 0.0;
Una manera más eficiente de evaluar p(t) = ao + alt + a2t2 + ... + antn
133
6. APUNTADORES
2)(x - 2) + (-1).
La primera de las dos funciones que siguen, evalPol, evalúa el poli-
nomio en un valor t usando el esquema de Horner. La segunda función
devuelve p(t) (que también es el residuo) yen el arreglo apuntado por q
están los coeficientes del polinomio cociente de la división. El arreglo p
debe tener n + 1 elementos; el cociente, de grado n - 1, tiene n elementos.
pi = P + n;
pt = *pi;
pi--;
while( pi >= P ) pt pt*t + *pi--;
return pt;
}
jj------------------------------------------------
double divSint( double *p, int n, double t, double *q)
134
6.7. MATRICES Y APUNTADORES DOBLES
{
II division sintetica de p(x)/(x-t)
II n es el grado del polinomio
II p(x) = p[O] + p[l]*x + p[2]*x*x + ... + p[n]*x-n
II devuelve el residuo
II q contiene el cociente
pi = P + n;
pt = *pi;
pi--;
qi = q+n-l;
while( pi >= P ){
*qi-- = pt;
pt = pt*t + *pi--;
}
return pt;
}
135
6. APUNTADORES
double **a;
int m, n, i, j;
m 4;
n 3;
jj--------------------------------------------
jj asignacion de memoria
a = new double *[mJ
if( a == NULL ){
printf("Memoria insuficiente\n");
exit(1) ;
}
for( i=O; i<m; i++) {
a[iJ = new double [nJ;
if( a[iJ == NULL ){
printf(IIMemoria insuficiente\n");
exit(1) ;
}
}
jj--------------------------------------------
jj algunos resultados
for( i = O; i < m; i++){
for( j = O; j < n; j++)
136
6.7. MATRICES Y APUNTADORES DOBLES
a[O] =6695108
a[l] =6695136
a[2] =6695164
a[3] =6695192
&a[O] =6695088
&a[1]=6695092
&a[2]=6695096
&a[3] =6695100
a = 6695088
137
6. APUNTADORES
double **p;
int i;
138
6.8. ARREGLOS A PARTIR DE 1
int i;
double **a;
int m, n;
a = creaA(m, n);
libA( a, m);
139
6. APUNTADORES
int n, i;
n 7;
x new double[n];
x-_·,
x++;
delete x;
intm, n, i, j;
m 3;
140
6.8. ARREGLOS A PARTIR DE 1
n = 4;
a = new double * [m] ;
i f ( a == NULL ){
printf(1I Memoria insuficiente\n");
exit(1) ;
}
a--;
for( i = 1; i <= m; i++){
a[i] = new double[n] ;
if( a[i] == NULL ){
printf(1I Memoria insuficiente\n");
exit(1) ;
}
a [i] --;
}
II liberacion de la memoria
Fue necesario disminuir en una unidad tanto a, como cada uno de los
a [i]. Para liberar la memoria se requiere el proceso inverso.
A fin de obtener un arreglo con subíndice que varíe entre i1 y i2,
i1<i2, se necesita asignar memoria para i2-i1+1 elementos y disminuir
el valor del apuntador en i 1. El siguiente ejemplo ilustra lo anterior.
int i, i 1, i2;
141
6. APUNTADORES
i1 -2;
i2 7;
y = new double[i2-il+l];
y -= i1;
y += i1;
delete y;
Ejercicios
Para cada uno de los enunciados siguientes, defina cuáles son los datos
necesarios. Haga un programa que lea los datos, llame la función (o las
funciones) que realiza los cálculos y devuelve los resultados, y finalmente
que el programa principal (la función main) muestre los resultados. En
todos los casos haga asignación dinámica de memoria. Cuando se trate
de matrices, haga el programa de dos maneras, almacenando la matriz
mediante apuntadores sencillos y mediante apuntadores dobles.
142
7
Lectura y escritura en
archivos
fopen,
fscanf,
fclose,
fprintf,
feof.
143
7. LECTURA Y ESCRITURA EN ARCHIVOS
#include ...
int mainO
{
double *x, prom;
FILE *archDat, *archRes;
int n, i;
144
7.1. FOPEN, FSCANF, FCLOSE, FPRINTF
4
1.2 1.8 3 4
4 1.2
1.8
3 4
145
7. LECTURA Y ESCRITURA EN ARCHIVOS
1.2
1.8
3 4 5.1
El programa del ejemplo anterior hace uso de una función promX, que
calcula el promedio de los primeros n elementos de un arreglo. Puede
ser cualquiera de las cuatro funciones promX del capítulo 5. Obviamente
hay que incluirla dentro del programa, lo mismo que su prototipo.
En el programa del ejemplo, el archivo de lectura se llama datos 1 y
el archivo de escritura se llama ej emplo. res. Si se quiere modificar los
datos, basta con editar el archivo datos1, efectuar los cambios necesarios
y correr de nuevo el programa. En algunos casos esto puede ser útil.
146
7.1. FOP€N. FSCANF, FCLOSE, FPRINTF
Pero en otros casos puede ser más flexible dar al programa, durante su
ejecución, los nombres de los archivos que van a ser usados.
El siguiente programa, modificación del anterior, permite que duran-
te la ejecución reciba los nombres de los archivos.
#include ...
int mainO
{
II lectura de un vector en un archivo
II escritura del promedio en otro archivo
147
7. LECTURA Y ESCRITURA EN ARCHIVOS
7.2 feof
En los dos ejemplos anteriores, el primer dato indicaba el número
de valores que el programa debía leer. En algunos casos se sabe que
un archivo contiene valores y es necesario leerlos, pero no se conoce
por anticipado el número de valores. Entonces el programa debe leer
hasta que encuentre el final del archivo. Para esto se utiliza la función
f eof (end of file). Esta función tiene como parámetro un archivo (un
apuntador a tipo FILE). Devuelve un valor no nulo si se ha alcanzado
el fin de archivo, y O en caso contrario.
Suponga que es necesario calcular el promedio y la desviación están-
dar de los valores contenidos en un archivo. La definición de desviación
estándar
(J = (¿~=1 (~i - x)2) 1/2
148
7.2. FEOF
#include ...
int mainO
{
double xi, prom, sumax, sumaxx, desvEst;
FILE *archDat, *archRes;
char nombre [41] ;
int n, fin, res;
149
7. LECTURA Y ESCRITURA EN ARCHIVOS
fin = O;
while( !fin ){
res = fscanf(archDat, "%lf", &xi);
if( feof(archDat) II res <= O ) fin = 1;
else{
fprintf (archRes, "%12. 6lf\n", xi);
n++;
sumax += xi;
sumaxx += xi*xi;
}
}
fclose(archDat);
if( n > O ){
prom = sumax/n;
desvEst = sqrt( (sumaxx - n*prom*prom)/n );
fprintf (archRes, "promedio = %12 .4lf\n", prom);
fprintf(archRes, "desviacion estandar = %12.4lf\n",
desvEst);
}
el se {
fprintf(archRes, " No hay numeros.\n");
}
fclose(archRes);
return O;
}
150
7.3. ALGUNOS EJEMPLOS
{
II Lectura en un archivo de los primeros n
II elementos de un arreglo x.
int i, res;
int j;
int nEltosLin 5; II numero de elementos por linea
double *x;
FILE *archDat, *archRes;
151
7. LECTURA Y ESCRITURA EN ARCHIVOS
int n, res;
152
7.3. ALGUNOS EJEMPLOS
II usa flectX
int i, res;
II usa fescrX
int i;
153
7. LECTURA Y ESCRITURA EN ARCHIVOS
II con fscanf.
II usa flectX
int i, res;
int i;
Ejercicios
Para cada uno de los enunciados siguientes, defina cuáles son los da-
tos necesarios. Haga un programa que lea los datos en un archivo, llame
la función que realiza los cálculos y finalmente escriba los resultados en
un archivo.
3.141592 -342
154
7.3. ALGUNOS EJEMPLOS
1.5e-2
-32.1542
32.5E+02 +31 31.45 1000
0.31415El
2*escritorios + 3*sillas>=24
4.5*mesas+3.1*sillas <= 31.5
155
7.3. ALGUNOS EJEMPLOS
1.5e-2
-32.1542
32.5E+02 +31 31.45 1000
0.31415El
2*escritorios + 3*sillas>=24
4.5*mesas+3.1*sillas <= 31.5
155
8
Temas varios
8.1 sizeof
jj sizeof
#include ...
jj-------------------------------------------------
int mainO
{
double *x, y[10], a[10] [10], *p;
x = new double[20];
157
8. TEMAS VARIOS
p = y;
printf(" arreglo y %d\n", sizeof(y) );
printf(" arreglo a %d\n", sizeof(a) );
printf(II apuntador x %d\n", sizeof(x»;
printf (" apuntador p %d\n", sizeof(p»;
return O;
}
int 4
float 4
double 8
char 1
short int 2
long int 4
unsigned 4
long double: 10
arreglo y 80
arreglo a 800
apuntador x 4
apuntador p 4
158
8.2. CONST
tienen, en general, una manejo casi idéntico, pero son en realidad dife-
rentes. Observe que utilizar sizeof para x, un apuntador al que se le
ha asignado memoria dinámicamente, no da como resultado el total de
memoria asignada. Tampoco devuelve el valor "imaginado", es decir 80,
la utilización de sizeof con el apuntador p al que se le asignó el valor
de y.
8.2 const
Si en la declaración de algunas variables, el especificador const pre-
cede al tipo, entonces el compilador sabe que esas variables no pueden
ser modificadas en el programa. Más específicamente, no puede haber
asignaciones donde el lado izquierdo sea una de esas variables. Además,
hace más legible el programa fuente, al indicar que se trata de una cons-
tante.
c *= 1.001;
nMax += O;
8.3 typedef
La utilización de typedef simplemente introduce un sinónimo para
un tipo de datos. El esquema de su uso es el siguiente:
typedef tipo sinónimo;
Por ejemplo,
159
8. TEMAS VARIOS
entero i, j 4, m;
jj uso de typedef
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "misfunc.h"
#include <iostream.h>
numero epsMaq(void);
jj======================================
int maine)
{
cout«" eps de la maquina "«epsMaq()«endl;
return O;
160
8.4. INCLUDE
}
11======================================
numero epsMaq(void)
{
II calculo aproximado del epsilon de la maquina
eps = 1.0;
unoEps = uno+eps;
while( unoEps > uno ){
eps 1= divisor;
unoEps = uno+eps;
}
eps *= divisor;
return eps;
}
El resultado puede ser 2. 22045e-16. Esto indica que los números doble
precisión utilizan aproximadamente 16 cifras significativas.
Si se desea calcular el épsilon de la máquina usando números de
precisión sencilla, basta con cambiar únicamente la línea typedef, para
que quede
8.4 include
En un programa fuente, además de las órdenes y controles corres-
pondientes al lenguaje C o C++, hay otras órdenes o directrices para el
preprocesador, quien las realiza antes de la compilación. Las directrices
para el preprocesador, una únicamente por línea, empiezan con # .
161
8. TEMAS VARIOS
#include <nombrearchivo>
#include "nombrearchivo"
162
8.4. INeLUDE
#include <iostream.h>
#include "mibibl.h"
int mainO
{
double a, b, e;
163
8. TEMAS VARIOS
8.5 define
La directriz def ine tiene dos usos. El primero sirve para definir
constantes. Por tradición estas constantes se escriben en mayúsculas.
Por ejemplo:
#define PI 3.14159265358979
#define PI 3.14159265358979
#define PI2 2.0*PI
#include ...
int mainO
{
double x 3.0, y 4.0;
cout«CUADRADo(x)«endl;
cout«CUADRADoB(x)«endl;
164
8.6. APUNTADORES A FUNCIONES
cout«CUADRADO(x+y) «endl;
cout«CUADRADOB(x+y)«endl;
cout«NORMA(x, y)«endl;
return O;
}
9
9
49
19
5
165
8. TEMAS VARIOS
#include ...
double s, h;
int i;
i f ( n <= O ){
166
8.6. APUNTADORES A FUNCIONES
return exp(-x*x/2.0)/sqrt(DOSPI);
}
#include ...
167
8. TEMAS VARIOS
{
double a, b;
int n;
double s, h;
int i;
i f ( n <= O ){
cout«n\n\n trapecio: ERROR: n n«n«endl;
return 0.0;
}
s = ( (*f)(a) + (*f)(b) )j2.0;
h = (b-a)jn;
for( i = 1; i <= n-l; i++) s += (*f)( a + i*h );
return s*h;
}
jj------------------------------------------------
double fl( double x)
{
return exp(-x*x);
}
jj------------------------------------------------
168
8.7. FUNCIONES EN LÍNEA
return exp(-x*x/2.0)/sqrt(DOSPI);
}
Este ejemplo muestra las principales características del uso de los apun-
tadores a funciones. En la definición de la función trapecio, un paráme-
tro es un apuntador a función. El identificador está precedido de aste-
risco y aparece entre paréntesis: (*f). Además están el tipo devuelto
por la función y los parámetros: double (*f) (double x). Esto impli-
ca que trapecio se puede usar para cualquier función que devuelva un
número doble precisión y que tenga un único parámetro tipo doble pre-
cisión. Cuando se utiliza el apuntador dentro de trapecio para evaluar
la función en un valor específico, también está precedido de asterisco y
encerrado entre paréntesis: (*f) (a) .
169
8. TEMAS VARIOS
#include <math.h>
#include <iostream.h>
#include <math.h>
#include <iostream.h>
170
8.8. ARGUMENTOS DE LA FUNCIÓN MAIN
return O;
}
Es usual que una función en línea esté escrita en una única línea, pero
no es obligatorio. La función en línea cosGrd se hubiera podido escribir
así:
return cos(0.0174532925199433*x);
}
Otro ejemplo de una función en línea puede ser el siguiente, que calcula
el máximo entre dos números doble precisión.
171
8. TEMAS VARIOS
Los parámetros para main son argc y argv. El primero es de tipo ente-
ro y sirve para contar el número de palabras (o cadenas) en la línea de
comandos. El nombre mismo del programa se cuenta como una palabra.
En el ejemplo prog28 caso1. dat resul t hay tres palabras. El paráme-
tro argv es un arreglo de cadenas donde se almacenan las cadenas dadas
en la línea de comandos. El siguiente ejemplo muestra un esquema de
su uso.
II prog28
II Parametros en la linea de comandos,
II uso de argc, argv
#include ...
i f ( argc ! = 3 ){
cout«"ERROR: el llamado debe ser:\n"
«"progr28 nombre_arch_datos nombre_arch_result"
«endlj
exit(1) j
}
172
8.8. ARGUMENTOS DE LA FUNCIÓN MAIN
fclose(archDat);
fclose(archRes);
return O;
}
173
8.8. ARGUMENTOS DE LA FUNCIÓN MAIN
fclose(archDat);
fclose(archRes);
return O;
}
173
9
Estructuras
struct complejo {
double pReal; II parte real
double plmag; II parte imaginaria
};
struct complejo z, w, c;
complejo z, w, c;
175
9. ESTRUCTURAS
z.pReal 1.0;
z.plmag 1.0;
w.pReal 1.0;
w.plmag -1.0;
Una vez definida una estructura, ésta puede servir para describir un
parámetro de una función, para declarar arreglos cuyos elementos sean
estructuras, para declarar apuntadores, para asignar memoria dinámi-
camente, para que una función devuelva una estructura.
El siguiente ejemplo usa la estructura complejo definida anterior-
mente. El programa lee en un archivo el valor de n. Asigna dinámica-
176
9.1. UN EJEMPLO CON COMPLEJOS
complejo *z, w;
int n, resLect;
FILE *archDat;
char nombre [51] ;
177
9. ESTRUCTURAS
w = complMaxNorma(z, n);
printf(" parte real = %lf parte imag. %lf\n",
w.pReal, w.plmag);
w = prodCompl(w, w);
printf (" parte real = %lf parte imag. %lf\n" ,
w.pReal, w.plmag);
return O;
}
11================================================
complejo prodCompl( complejo zl, complejo z2)
{
II producto de dos complejos
complejo z3;
178
9.1. UN EJEMPLO CON COMPLEJOS
return z3;
}
11------------------------------------------------
int flectXCompl(FILE *arch, complejo *x, int n)
{
II Lectura en un archivo de los primeros n
II elementos de un arreglo complejo x.
int i, res;
179
9. ESTRUCTURAS
imax i;
normaMax = normai;
}
}
return x[imax];
}
11------------------------------------------------
double normaCompl(complejo X)
{
II Norma del complejo x
180
9.2. UN EJEMPLO TÍPICO
double normaComplb(complejo X)
{
II Norma del complejo x
complejo *w;
w = &x;
return sqrt(w->pReal*w->pReal + w->plmag*w->plmag);
}
Ejercicios
Los ejercicios de este capítulo se pueden hacer definiendo explíci-
tamente una estructura por medio de struct, o sin su uso. Haga o
estudie las dos alternativas y detecte ventajas y desventajas.
181
9. ESTRUCTURAS
9.2 Un grafo se puede representar por una lista de vértices y una lista
de arcos. U na red es un grafo donde adicionalmente cada arco tiene
un valor (costo o distancia). Defina una estructura para su manejo.
Haga funciones para:
• agregar un arco con costo,
• quitar un arco,
• quitar un vértice de la lista de arcos,
• quitar un vértice de la lista de arcos y de la lista de vértices,
• modificar un costo,
• buscar si un arco existe,
• dada una sublista de vértices, averiguar si es un camino,
• calcular su costo.
182
10
Algunas funciones
elementales
Para cada una de ellas, está la versión sin saltos y la versión con
saltos. Utilizando la sobrecarga de funciones permitida por C++, las
dos versiones tienen el mismo nombre.
183
10. ALGUNAS FUNCIONES ELEMENTALES
184
10.1. CÓDIGO DE ALGUNAS FUNCIONES
11------------------------------------------------
double prodXY(double *x, double *y, int n)
{
II producto "interno" x.y
double s = 0.0;
double *pxi, *pyi, *pxn;
pxi x·,
pyi y;
pxn x + n;
while( pxi < pxn ) s += (*pxi++)*(*pyi++);
return s;
}
11------------------------------------------------
double dist2(double *x, double *y, int n)
{
II distancia euclideana (Holder, orden 2) entre x y
double s = 0.0;
185
10. ALGUNAS FUNCIONES ELEMENTALES
pxi X;
pyi y;
pxn X + n;
whileC pxi < pxn ){
xiyi = C*pxi++) - C*pyi++);
S += xiyi*xiyi;
}
return sqrt(s);
}
11---------------------------------------------------------
void alfaXCdouble alfa, double *x, int n)
{
II X alfa * x
pxi = x;
pxn = x + n;
whileC pxi < pxn ) *pxi++ *= alfa;
}
11---------------------------------------------------------
void xMasAlfaYCdouble *x, double alfa, double *y, int n)
{
II x x + alfa * y
pxi x;
pyi y;
pxn x + n;
whileC pxi < pxn ) *pxi++ += alfa*C*pyi++);
}
11---------------------------------------------------------
void xIglKCdouble *x, int n, double k)
{
II x = k
186
10.1. CÓDIGO DE ALGUNAS FUNCIONES
pxi = X;
pxn = X + n;
while( pxi < pxn ) *pxi++ = k;
}
11---------------------------------------------------------
void xIglY(double *x, double *y, int n)
{
II X = Y
pxi x;
pyi y;
pxn X + n;
while( pxi < pxn ) *pxi++ = *pyi++;
}
11---------------------------------------------------------
void xIglAlfY(double *x, double alfa, double *y, int n)
{
II X = alfa * y
pxi x;
pyi y;
pxn X + n;
while( pxi < pxn ) *pxi++ = alfa*(*pyi++);
}
11---------------------------------------------------------
void intercXY(double *x, double *y, int n)
{
II intercambiar x y
187
10. ALGUNAS FUNCIONES ELEMENTALES
pxi x;
pyi y;
pxn = x + n;
while( pxi < pxn ){
t = *pxi;
*pxi++ *pyi;
*pyi++ = t;
}
}
11---------------------------------------------------------
double maxX(double *x, int n)
{
II maximo xi
pxi = x;
pxn = x + n;
while( pxi < pxn ){
xi = *pxi++;
if( xi > maxi ) maxi xi;
}
return maxi;
}
11---------------------------------------------------------
double maxXPos(double *x, int n, int &posi)
{
II maximo xi
II posi contendra la posicion del maximo
posi = -1;
pxi = x;
pxn = x + n;
i = O;
while( pxi < pxn ){
188
10.1. CÓDIGO DE ALGUNAS FUNCIONES
xi = *pxi++;
if ( xi > maxi ){
maxi xi;
posi = i;
}
i++;
}
return maxi;
}
11---------------------------------------------------------
double maxAbsX(double *x, int n)
{
II maximo Ixil
pxi = x;
pxn = x + n;
while( pxi < pxn ){
axi = fabs(*pxi++);
if( axi > maxi ) maxi axi;
}
return maxi;
}
11---------------------------------------------------------
double maxAbsXPos(double *x, int n, int &posi)
{
II maximo Ixil
II posi contendra la posicion del maximo valor abs.
posi = -1;
pxi = x;
pxn = x + n;
i = O;
while( pxi < pxn ){
189
10. ALGUNAS FUNCIONES ELEMENTALES
axi = fabs(*pxi++);
if( axi > maxi ){
maxi axi;
posi = i;
}
i++;
}
return maxi;
}
if( n < O ){
printf("dist2: n negativo\n");
return 0.0;
}
if( n==O ) return 0.0;
if( saltox == 1 ){
if( saltoy == 1 ){
II saltox = saltoy 1
pxi = x;
pxn = x + n;
pyi = y;
while( pxi < pxn ){
xiyi = (*pxi++) - (*pyi++);
s += xiyi*xiyi;
190
10.2. VERSIONES CON SALTOS
}
}
else{
II saltox = 1; saltoy != 1
pxi x;
pxn = x + n;
pyi = y;
while( pxi < pxn ){
xiyi = (*pxi++) - (*pyi);
s += xiyi*xiyi;
pyi += saltoy;
}
}
}
else{
if( saltoy == 1 ){
II saltox > 1; saltoy 1
pyi y;
pyn y + n;
pxi x;
while( pyi < pyn ){
xiyi = (*pxi) - (*pyi++);
s += xiyi*xiyi;
pxi += saltox;
}
}
else{
II saltox != 1; saltoy != 1
pxi x;
pxn = x + n*saltox;
pyi = y;
while( pxi < pxn ){
xiyi = (*pxi) - (*pyi);
s += xiyi*xiyi;
pxi += saltox;
pyi += saltoy;
}
}
191
10. ALGUNAS FUNCIONES ELEMENTALES
}
return sqrt(s);
}
11---------------------------------------------------------
void alfaX(double alfa. double *x. int salto. int n)
{
II x = alfa * x
II x en x[O]. x[salto]. x[2*salto] •...• x[(n-l)*salto]
double *pxi. *pxn;
if( salto == 1 ){
pxi = x;
pxn = x + n;
while( pxi < pxn ) *pxi++ *= alfa;
}
else{
pxi = x;
pxn = x + n*salto;
while( pxi < pxn ){
*pxi *= alfa;
pxi += salto;
}
}
}
11------------------------------------------------
void xMasAlfaY(double *x. int saltox. double alfa.
double *Y. int saltoy. int n)
{
II x = x + alfa y
II x[O]. x[saltox]. x[2*saltox]. ... , x [(n-1) *saltox]
II y[O]. y[saltoy]. y[2*saltoy]. ... , y[(n-l)*saltoy]
II uso de apuntadores
if( n < O ){
192
10.2. VERSIONES CON SALTOS
printf("xMasAlfaY: n negativo\n");
return;
}
if( n==O ) return;
if( saltox -- 1 ){
if( saltoy == 1 ){
II saltox = saltoy 1
pxi x;
pxn x + n;
pyi y;
while( pxi < pxn ) *pxi++ += alfa*(*pyi++);
}
else{
II saltox = 1; saltoy != 1
pxi x;
pxn = x + n;
pyi = y;
while( pxi < pxn ){
*pxi++ += alfa*(*pyi);
pyi += saltoy;
}
}
}
else{
if( saltoy == 1 ){
II saltox > 1; saltoy 1
pyi y;
pyn y + n;
pxi x;
while( pyi < pyn ){
*pxi += alfa*(*pyi++);
pxi += saltox;
}
}
else{
II saltox != 1; saltoy != 1
pxi = x;
193
10. ALGUNAS FUNCIONES ELEMENTALES
pxn = X + n*saltox;
pyi = y;
while( pxi < pxn ){
*pxi += alfa*(*pyi);
pxi += saltox;
pyi += saltoy;
}
}
}
}
Considere
194
10.3. MÉTODO BURBUJA
x = (-1,6,14,0,1,2)
x = (-1,6,14,0,1,2)
x = (-1,6,0,1,14,2)
x = (-1,6,0,1,2,14)
x = (-1,6,0,1,2,14)
x = (-1,0,6,1,2,14)
x = (-1,0,1,6,2,14)
x= (-1,0,1,2,6,14)
x = (-1,0,1,2,6,14)
195
10 ALGUNAS FUNCIONES ELEMENTALES
Como °
y 1 están ordenados, no se hace nada.
x = (-1,0,1,2,6,14)
x = (-1,0,1,2,6,14)
int nCamb, m;
double *pxi, *pxi1, *pxm, t;
196
10.3. MÉTODO BURBUJA
Ejercicios
Los ejercicios de este capítulo no están enfocados directamente a los
temas tratados en él; más bien, corresponden a varios temas y aparecen
aquí por tratarse del último capítulo sobre C.
10.4 Utilice el ejercicio anterior para resolver por la "fuerza bruta" (es-
tudio de todas las posibilidades) el problema del morral con cotas
inferiores y superiores. Sean n un entero positivo; e, PI, P2, ... ,
Pn, bl, b 2 , ... , bn números positivos; UI :S VI, U2 :S V2, ... , Un :S V n
enteros positivos. Encontrar enteros Xl, X2, ... , X n para resolver el
siguiente problema de maximización con restricciones:
197
10.3. MÉTODO BURBUJA
Ejercicios
Los ejercicios de este capítulo no están enfocados directamente a los
temas tratados en él; más bien, corresponden a varios temas y aparecen
aquí por tratarse del último capítulo sobre C.
10.4 Utilice el ejercicio anterior para resolver por la "fuerza bruta" (es-
tudio de todas las posibilidades) el problema del morral con cotas
inferiores y superiores. Sean n un entero positivo; e, PI, P2, ... ,
Pn, bl, b 2 , ... , bn números positivos; UI :S VI, U2 :S V2, ... , Un :S V n
enteros positivos. Encontrar enteros Xl, X2, ... , X n para resolver el
siguiente problema de maximización con restricciones:
197
11
Solución de sistemas
lineales
Ax=b (11.1)
11.1 Notación
199
11. SOLUCIÓN DE SISTEMAS LINEALES
x = A-lb.
a12 13 bl 13
[ bl
det b2 a22 aa23 ] [ a11
b2 a ]
det a21 a23
b3 a32 a33 a31 b3 a33
Xl =
det(A)
X2 = det(A)
200
11.2. MÉTODOS INGENUOS
21! = 5.1091E19.
Siendo muy optimistas (sin tener en cuenta las sumas y otras operacio-
nes concomitantes), supongamos que un computador del año 2000 hace
1000 millones de multiplicaciones por segundo. Entonces, el tiempo ne-
cesario para resolver un sistema de ecuaciones de orden 20 por la regla
de Cramer y el método de cofactores es francamente inmanejable:
~ X3
-11 - (2.5x3 + 4.25x4)
-0.25
" 202
11.4. SISTEMA TRIANGULAR SUPERIOR
Xn = bnjann
para i = n - 1, ... , 1
Xi = (b i - prodEsc(A(i,i + 1: n),x(i + 1: n)))jaii
fin-para
Xn-l = bn-Ijan-l,n-l
para i=n-2, ... ,0
Xi = (bi - prodEsc(A(i,i + 1: n -l),x(i + 1: n -l)))jaii
fin-para
203
11. SOLUCIÓN DE SISTEMAS LINEALES
11.4.2 Implementación en e
Para la siguiente implementación en e es necesario tener en cuenta
estos aspectos:
204
11.4. SISTEMA TRIANGULAR SUPERIOR
II A se considera singular si
II I Aii I <= eps para algun i.
ni = n+l;
n_l = n-l;
for( i = n_l; i >= O; i--){
ii = i*nl;
if( fabs( a[ii] ) <= eps ) return O;
205
11. SOLUCIÓN DE SISTEMAS LINEALES
bi - L aijXj
j=l
Xi = (11.3)
aii
para i = 1, ... , n
Xi = (b i - prodEsc(A(i, 1 : i - 1), x(l : i - l)))/aii
fin-para
equivalente al primero, tal que A' sea triangular superior. Que los siste-
mas sean equivalentes quiere decir que la solución de Ax = b es exacta-
mente la misma solución de A' X = b' . La segunda parte es simplemente
la solución del sistema triangular superior.
Para una matriz, con índices entre 1 y n, el esquema de triangulari-
zación se puede escribir así:
206
11.6. MÉTODO DE GAUSS
para k = 1, ... , n - 1
para i = k + 1, ... , n
buscar ceros en la posición de aik.
fin-para
fin-para k
+ 3X2 - 2X3 + X4
4Xl 4
3Xl + 2X2 + X3 + 5X4 -8
-2Xl + 3X2 + X3 + 2X4 -7
-8
3 -2
[J-5
2
3
O
1
1
1
Es usual trabajar únicamente con los números, olvidando temporalmen-
te los Xi. Más aún, se acostumbra trabajar con una matriz ampliada,
resultado de pegar a la derecha de A el vector b.
3 -2
[J
1
2
3
1
1
5
2 -!-7 1
-5 O 1 1 -8
207
11. SOLUCIÓN DE SISTEMAS LINEALES
[~
3 -2 1
-0.25 2.5 4.25 -114 ]
O 45 79 -203
3.75 -1.5 2.25 -3
Para buscar cero en la posición (4,2) se hace siguiente operación:
fila4 f- fila4 - (3.75/( -0.25))*fila2
[~
3 -2 1
-0.25 2.5 4.25 -114 ]
O 45 79 -203
O 36 66 -168
208
11.6. MÉTODO DE GAUSS
[~
3 -2 1 4
-0.25 2.5 4.25
-11 ]
O 45 79 -203
O O 2.8 -5.6
El sistema resultante ya es triangular superior. Entonces se calcula pri-
mero X4 = -5.6/2.8 = -2. Con este valor, utilizando la tercera ecuación
resultante, se calcula X3, después X2 Y Xl·
lik = aik/akk
A(i,:) = A(i,:) -lik * A(k,:)
bi = bi - lik * bk
Como en las columnas 1, 2, ... , k - 1 hay ceros, tanto en la fila k como
en la fila i, entonces ail, ai2, ... , ai,k-l seguirán siendo cero. Además, las
operaciones se hacen de tal manera que aik se vuelva cero. Entonces aik
no se calcula puesto que dará O. Luego los cálculos se hacen en la fila i
a partir de la columna k + 1.
209
11. SOLUCIÓN DE SISTEMAS LINEALES
para k = 1, ... , n - 1
para i = k + 1, ... , n
lik = aik/akk, aik = O
A(i, k + 1 : n) = A(i, k + 1 : n)-lik*A(k, k + 1 : n)
bi = bi-lik*bk
fin-para i
fin-para k
para k = 1, ... , n - 1
para i = k + 1, ... , n
si lakkl ~ é ent
buscar m, k + 1 ~ m ~ n, tal que lamkl > é
si no fue posible ent salir
intercambiar(A(k, k : n), A(m, k: n))
intercambiar(bk, bm )
fin-si
lik = aik/akk, aik = O
A(i, k + 1 : n) = A(i, k + 1 : n)-lik*A(k, k + 1 : n)
bi = bi-lik*bk
fin-para i
fin-para k
si Ia nn I ~ é ent salir
210
11.6. MÉTODO DE GAUSS
para k = 1, .oo, n
para i = k + 1, oo., n
si lakkl ~ é ent
buscar m, k + 1 ~ m ~ n, tal que lamkl > é
si no fue posible ent salir
intercambiar(A(k, k : n), A(m, k : n))
intercambiar(bk,bm )
fin-si
lik = aik/ akk. aik = O
A(i, k + 1 : n) = A(i, k + 1 : n)-lik*A(k, k + 1 : n)
bi = bi-lik*bk
fin-para i
fin-para k
Triangularización
Consideremos inicialmente la búsqueda de cero en la posición (2,1). Para
efectuar A(2,2 : n) = A(2,2 : n) - lik * A(1, 2 : n) es necesario hacer
211
11. SOLUCIÓN DE SISTEMAS LINEALES
¿i
m
2 = m(m + 1)(2m + 1) .
i=l 6
Número de sumas y restas:
n-l n-l n3 n n3
¿ i(i + 1) = ¿(i2 + i) = 3 - "3 ~ 3·
i=l i=l
212
11.6. MÉTODO DE GAUSS
L ·. L·(2
n-l n-l 3 2 3
2( 2 + 2) = 2
+ 22). = -n + -n - -5n ~
n
-.
3 2 6 3
i=l i=l
Número de operaciones:
n3 n n3 n2 5n 2n 3 n2 7n 2n 3
3 - 3+3 +2 - 6 = 3 +2 - 6 ~ 3'
Proceso completo
El número de operaciones para las dos partes, triangularización y solu-
ción del sistema triangular, es
2n 3 3n2 7n 2n 3
-+---~_.
3 2 6 3
Para valores grandes de n el número de operaciones de la solución del
sistema triangular es despreciable con respecto al número de operaciones
de la triangularización.
11.6.2 Implementación en e
La implementación hace uso de la función xMasAlfaY, definida en el
capítulo 10, que adiciona a un vector un múltiplo de otro vector:
U f-- U + 3.5v
Su prototipo es:
213
11. SOLUCIÓN DE SISTEMAS LINEALES
nl = n+l;
n_l = n-l;
II triangularizacion
214
11.7. FACTORIZACIÓN LU
return 1;
}
11.7 Factorización L U
Si durante el proceso del método de Gauss no fue necesario inter-
cambiar filas, entonces se puede demostrar que se obtiene fácilmente
la factorización A = LU, donde L es una matriz triangular inferior con
unos en la diagonal y U es una matriz triangular superior. La matriz U es
simplemente la matriz triangular superior obtenida al final del proceso.
.~.
O O
L = [ 75 1 O
-0.5 -18 1
-1.25 -15 0.8
En este ejemplo, fácilmente se comprueba que LU = A. Esta factoriza-
ción es útil para resolver otro sistema Ax = b, exactamente con la misma
matriz de coeficientes, pero con diferentes términos independientes.
Ax b,
LUx b,
Ly b,
donde Ux y.
215
11. SOLUCIÓN DE SISTEMAS LINEALES
En resumen:
+ 3X2 - 2X3 + X4
4Xl 8
3Xl + 2X2 + X3 + 5X4 30
Al resolver
o
~ ][~~l ~ [~~l
1 O
0.75 1 o
[ -0.5
-1.25
-18
-15
1
0.8
[~~
4 3 -2 1
O -0.25 2.5 4.25 24.0
1
[ O
O
O
O
45
O
79
2.8 1 1
[ 80
451.0
11.2
216
11.8. MÉTODO DE GAUSS CON PIVOTEO PARCIAL
Un UI2 UI3 UI n
b U22 U23 U2n
L= lsl l32 U3I U3n'
~. 75
3 -2
-0.25 2.5
/25]
[ -0.5 -18 45 79
-1.25 -15 0.8 2.8
217
11. SOLUCIÓN DE SISTEMAS LINEALES
4 3 -2 1
[
3
-2
2
3
1
1
5
2
-! ]
-7
-5 O 1 1 -8
-~ O
2
1
1
1
5 -8]
-8
[ -2
4
3
3
1
-2
2
1
-7
4
218
11.8. MÉTODO DE GAUSS CON PIVOTE O PARCIAL
.~
obtiene
-5 O 1 1 -8
O 2 1.6 5.6 "'C" 12.8
[ O
O
3
3
0.6
-1.2
1.6
1.8
-3.8
-2.4 1
El valor dominante de A(2 : 4,2) es 3 y está en la fila 3 (o en la fila 4).
Entonces se intercambian las filas 2 y 3.
-5 O 1 1 -8
[
O
O
O
3
2
3
0.6
1.6
-1.2
1.6
5.6
1.8
-3.8
-.12.8
-2.4 1
X
Buscar ceros en las posiciones de a32, a42 se hace usando los valores de
lik= 2/3 = 0.6666 Y 1. Se obtiene
-5 O 1 1
O 3 0.6 1.6 -3.8
-8 1
[ O
O
O
O
1.2
-1.8
4.5333
0.2
-10.2667
1.4
-5 1 1
O
O
3 0.6 1.6 -3.8
-8 1
[ O
O
O
O
-1.8
1.2
0.2
4.5333
1.4
-10.2667
-5 O 1 1 -8
[ O
O
O
3
O
O
0.6
-1.8
O
1.6
0.2
4.6667
-3.8
1.4
-9.3333 1
Al resolver el sistema triangular superior, se encuentra la solución:
219
11. SOLUCIÓN DE SISTEMAS LINEALES
[ 1.0000
1.3310
1.0000
1. 2100
1.0000
1.1000
0.8338
1.0000 ]
Con lik = 1.3717 Y con lik = 1. 8258 se obtiene
[ 0.0000
0.0000
-0.1111
-0.2689
-0.2345
-0.5432
-0.1081
-0.2538 ]
Con lik = 2.4203 se obtiene
0.7290 0.8100 0.9000 0.6867
[ 0.0000
0.0000
-O .1111
0.0000
-0.2345
0.0244
-0.1081
0.0078 ]
La solución del sistema triangular da:
220
11.8. MÉTODO DE GAUSS CON PIVOTEO PARCIAL
[ 1.0000
1.3310
1.0000
1.2100
1.0000
1.1000
0.8338
1.0000 1
Intercambio de las filas 1 y 3.
[ 1.0000
0.7290
1.0000
0.8100
1.0000
0.9000
0.8338
0.6867 1
Con lik = 0.7513 Y con lik= 0.5477 se obtiene
[ 0.0000
0.0000
0.0909
0.1473
0.1736
0.2975
0.0825
0.1390 1
Intercambio de las filas 2 y 3.
[ 0.0000
0.0000
0.1473
0.0909
0.2975
0.1736
0.1390
0.0825 1
Con lik= 0.6171 se obtiene
1.3310 1. 2100 1.1000 1.0000
[ 0.0000
0.0000
0.1473
0.0000
0.2975
-0.0100
0.1390
-0.0033 1
La solución del sistema triangular da:
221
11. SOLUCIÓN DE SISTEMAS LINEALES
Se observa que para este ejemplo la norma del residuo es del mismo or-
den de magnitud que la norma del residuo correspondiente a la solución
obtenida sin pivoteo, aunque algo mayor. La comparación directa con
la solución exacta favorece notablemente al método de pivoteo parcial:
0.0053 y 0.0202, relación de 1 a 4 aproximadamente. Además, "visual-
mente" se observa la mejor calidad de la solución obtenida con pivoteo.
A continuación aparece una versión de la función que implementa el
método de Gauss con pivoteo parcial.
nl = n+l;
n_l = n-l;
II triangularizacion
222
11.9. FACTORIZACIÓN LU=PA
solTrSup(a, b, n, eps);
return 1;
}
LU=PA.
223
11. SOLUCIÓN DE SISTEMAS LINEALES
Pi. = Jpi •
En palabras, la fila i de P es simplemente la fila Pi de J. Obviamente P
debe cumplir:
Pi E {1, 2, 3, ... , n} Vi
Pi =1= Pj Vi =1= j.
Por ejemplo, P = (2,4,3,1) representa la matriz
o
p~ ~ ~ ].
1
O O
[ O 1
O O
A~[
4 3 -2 1
3
-2
-5
2
3
O
1
1
1
5
2
1
]
Inicialmente P = (1,2,3,4). Para buscar el mejor pivote, se intercambian
las filas 1 y 4.
[ -~
~]
O 1
2 1
p=(4,2,3,1),
-2 3 1
4 3 -2
224
11.9. FACTORIZACIÓN LU=PA
o
~.6l·
-5 1
-0.6 2 1.6
0.4 3 0.6 1.6
[
-0.8 3 -1.2 1.8
Para buscar el mejor pivote, se intercambian las filas 2 y 3.
-5 O 1 1
p=(4,3,2,1),
[ 0.4
-0.6
-0.8
3
2
3
0.6
1.6
-1.2
1.6
5.6
1.8 1
Buscando ceros en la segunda columna y almacenando allí los valores
lik se obtiene:
-5 O 1 1
0.4 3 0.6 1.6
[ -0.6
-0.8
0.6667
1
1.2
-1.8
4.5333
0.2 1
Para buscar el mejor pivote, se intercambian las filas 3 y 4.
-5 o 1
0.4 3 0.6
p= (4,3,1,2),
-0.8 1 -1.8
[
-0.6 0.6667 1. 2
Buscando ceros en la tercera columna y almacenando allí los valores lik
se obtiene:
o
~.6 1
-5 1
0.4 3 0.6
-0.8 1 -1.8 0.2 .
[
-0.6 0.6667 -0.6667 4.6667
En esta última matriz y en el arreglo p está toda la información necesaria
para obtener L, U, P. Entonces:
~1
1 O O
0.4 1 O
L= [ -0.8 1 1 O .
-0.6 0.6667 -0.6667 1
225
11. SOLUCIÓN DE SISTEMAS LINEALES
-5 O 1 1
O 3 0.6 1.6
u=[ O
O
O
O
-1.8
O
0.2
4.6667
]
O O O 1
O O 1 O
P=[ 1
O
O
1
O
O
O
O
] O
• Resolver Ly = z.
• Resolver U x = y.
z = Pb = [ ~~ ]
-8
-3.8 ]
Ly = z ,entonces y =
1.4
[
-9.3333
Ux = y ,entonces x =
U] O
226
11.10. MÉTODO DE CHOLESKY
:~~ :~~
xTAx xn ]
[ anl an2
allXl
a21xl
+ a12 X 2 + ... + alnX n
+ a22 x 2 + ... + a2n X n
1
[ Xl xn ]
[
anlXl + a n 2X 2 + ... + annXn
n n
LLaijXiXj.
i=l j=i
Si A es simétrica,
n n-l n
x
T
Ax =L aii X ; +2L L aijXiXj.
i=l i=l j=i+l
227
11. SOLUCIÓN DE SISTEMAS LINEALES
A [; ;].
xTAx xi + 5x~ + 4XlX2
Xl2 + 4XlX2 + 4X22 + X22
(Xl + 2X2)2 + X~.
Obviamente x TAx 2: O. Además x TAx = O si y solamente si los dos
sumandos son nulos, es decir, si y solamente si X2 = O Y Xl = O, o sea,
cuando X = O. Luego A es definida positiva. O
A [; ~].
xTAx xi + 4x~ + 4XlX2
(Xl + 2X2)2.
Obviamente x TAx 2: O. Pero si X = (6, -3), entonces x TAx = O. Luego
A no es definida positiva. O
A [; ~].
xTAx xi + 3x~ + 4XlX2
(Xl + 2X2)2 - x~.
A [! ~].
Como A no es simétrica, entonces no es definida positiva. O
228
11.10. MÉTODO DE CHOLESKY
det([a11]) = a11,
det
[ al!
a21
a31
a12
a22
a32
a13
a13
a33
],
det(A).
• A es definida positiva.
229
11. SOLUCIÓN DE SISTEMAS LINEALES
Sea
A=[12]
2 5 .
Entonces
[ Un
U12
O ] [
U22
Un
O
U12 ]
U22
2
[~ ~ ]
un 1
Un U 12 2,
2 2
u12 + u22 5
Se deduce que
Un 1
U12 2,
U22 1,
U
[~ ~ ] .
Entonces existe la factorización de Cholesky de A.
Cuando se calculó Un se hubiera podido tomar Un = -1 Y se hubiera
podido obtener otra matriz U. Se puede demostrar que si se escogen
los elementos diagonales Uii positivos, entonces la factorización, cuando
existe, es única.
Sea
A=[12]
2 4 .
230
11.10. MÉTODO DE CHOLESKY
Entonces
[ Un
U12
O ] [ Un
U22 O
U12 ]
U22 [~ ~]
2 1
un
Un U 12 2,
2 2 4
u12 + u22
Se deduce que
Un 1
U12 2,
U22 O,
U [~ ~].
Entonces, aunque existe U tal que A = UTU, sin embargo no existe la
factorización de Cholesky de A ya que U no es invertible.
Sea
A=[~ ~].
Entonces
[ Un
U12
O
U22 ][ Un
O
U12 ]
U22 [~ ~]
2 1
un
Un U 12 2,
2 2 3
U12 + u22
Se deduce que
Un 1
U12 2,
U~2 -1.
231
11. SOLUCIÓN DE SISTEMAS LINEALES
En el caso general,
Luego
U11 = Vall' (11.6)
El producto de la fila 1 de U T por la columna j de U da:
Luego
al'
Ulj = _J , j = 2, ... , n. (11.7)
U11
¿U;k akk
i=l
k-l
"2 2
L-t Uik + Ukk akk·
i=l
Luego
k-l
Ukk = 1 I akk - ¿ U;k ' k = 2, ... ,n. (11.8)
i=l
232
11.10. MÉTODO DE CHOLESKY
k
L UikUij = akj·
i=l
Luego
k-l
akj - L UikUij
i=l
Ukj=------ k = 2, ... , n, j = k + 1, ... , n. (11.9)
Ukk
-12 8
A
[ 16
-1~ 18 -6 -1! 1.
-6 5 -10
-16 9 -10 46
Ull = Jl6 = 4
-12
U12 =-3
4
8
U13 =2
4
-16
= -4
4
U22 = J18 - (-3)2 = 3
-6 - (-3)(2)
=0
3
9 - (-3)(-4)
U24 = = -1
3
U33 = J5 - (2 2 + 02 ) = 1
-10 - ( 2(-4) + O( -1) )
U34 = =-2
1
233
ll. SOLUCIÓN DE SISTEMAS LINEALES
4 -3 2 -4]
O 3 O -1
U
[ O
O
O 1 -2
O O 5
. <>
Para ahorrar espacio de memoria, los valores Ukk Y Ukj se pueden al-
macenar sobre los antiguos valores de akk Y akj. O sea, al empezar el
algoritmo se tiene la matriz A. Al finalizar, en la parte triangular supe-
rior del espacio ocupado por A estará U.
datos: A, E
para k = 1, oo.,n
cálculo de t según (11.10)
si t ~ E ent salir
akk = vi
para j = k + 1, oo., n
cálculo de akj según (11.12)
fin-para j
fin-para k
234
11.10. MÉTODO DE CHOLESKY
n1 = n+1;
for( k = O; k < n; k++){
kk = k*n1;
t = a[kk] - prodXY( &a[k] , n, &a[k] , n, k);
if( t <= eps ) return O;
a[kk] = sqrt(t);
for( j = k+1; j < n; j++){
kj = kk + j-k;
a[kj] = (a[kj]-prodXY(&a[k], n, &a[j] , n, k))1
a [kk] ;
}
}
return 1;
}
235
11. SOLUCIÓN DE SISTEMAS LINEALES
cálculo de U nn n-1 n
n-l
~
3 3
L(n-i)i= n -n n
i=l 6 6.
n n3 n2 n n3
L(n + 1 - i)i = 6 + 2" + 3" ~ 6-
i=l
n3 n2 n n3
-+-+-~-
3 2 6 3 -
236
11.10. MÉTODO DE CHOLESKY
resolver (11.13)
resolver (11.14)
Resolver cada uno de los dos sistemas es muy fácil. El primero es trian-
gular inferior, el segundo triangular superior. El número total de ope-
raciones para resolver el sistema está dado por la factorización más la
solución de dos sistemas triangulares.
n3 n3
Número de operaciones ~ - + 2n 2 ~ -.
3 3
Esto quiere decir que para valores grandes de n, resolver un sistema,
con A definida positiva, por el método de Cholesky, gasta la mitad del
tiempo requerido por el método de Gauss.
El método de Cholesky se utiliza para matrices definidas positivas.
Pero no es necesario tratar de averiguar por otro criterio si la matriz
es definida positiva. Simplemente se trata de obtener la factorización de
Cholesky de A simétrica. Si fue posible, entonces A es definida positiva
y se continúa con la solución de los dos sistemas triangulares. Si no fue
posible obtener la factorización de Cholesky, entonces A no es definida
positiva y no se puede aplicar el método de Cholesky para resolver Ax =
b.
u ~ [~ -~ ~]
237
11. SOLUCIÓN DE SISTEMAS LINEALES
Al resolver U T y = b se obtiene
238
ll.ll. MÉTODO DE GAUSS-SEIDEL
II La solucion quedara en b.
int i, nl;
nl = n+l;
for( i = O; i < n; i++){
b[i] = (b[i] - prodXY( &u[i] , n, b, 1, i))/u[i*nl];
}
}
lim xk = x*.
k-4OO
239
11. SOLUCIÓN DE SISTEMAS LINEALES
Xin ni-
X ' l ·Z = 1, 2, ... , n - 1.
[ ~~ 1~ [ -;~ 1
1~ -1
20 -2 3O
2
1
[ -2 1 30 O
1 2 3 20
240
11.11. MÉTODO DE GAUSS-SEIDEL
l 26 - (2 x 2 + ( -1) x 3 + O x 4)
Xl = 10 = 2.5,
xl = (2.5, 2, 3, 4).
2 _ -15 - (1 x 2.5 + (-2) x 3 + 3 x 4) _ 7
X2 - 20 - -1.1 5,
x2 = (2.5, -1.175, 3, 4).
3 53 - (-2 x 2.5 + 1 x (-1.175) + O x 4)
x3 = 30 = 1.9725,
x3 = (2.5, -1.175, 1.9725, 4).
4 47- (1 x 2.5+2 x (-1.175) +3 x 1.9725)
x4 = 20 = 2.0466,
x4 = (2.5, -1.175, 1.9725, 2.0466).
Una vez que se ha hecho una iteración completa (n sub iteraciones) ,
se utiliza el último X obtenido como aproximación inicial y se vuelve a
empezar; se calcula Xl de tal manera que se satisfaga la primera ecuación,
luego se calcula X2 ... A continuación están las iteraciones siguientes para
el ejemplo anterior.
241
11. SOLUCIÓN DE SISTEMAS LINEALES
2
[ -1
11 -1 10
2 ][ Xl] = [ 1211 ]
X2
1 5 2 X3 8
242
ll.ll. MÉTODO DE GAUSS-SEIDEL
n
bi - I:: aijX j + aiiXi
j=l
aii
bi - At. x
Xi <-:- Xi + ~-~
aii
Sean
bi - Ai. X,
ri
aii
Sean r = (rl, r2, ... , r n), o = (01,02, ... , on). Entonces xk+n = xk + o.
Además xk es solución si y solamente si r = 0, o sea, si y solamente
243
11. SOLUCIÓN DE SISTEMAS LINEALES
datos: A, b, x O, é, maxit
x=xo
para k = 1, ... ,maxit
nrmD+--- O
para i = 1, ... , n
t5i = (b i - prodEsc( A i ., x) ) / aii
Xi +--- Xi + t5i
nrmd +---nrmD+t5i
fin-para i
si nrmD :S é ent x* ~ x, salir
fin-para k
II Devuelve:
II 1 si se obtuvo aproximadamente la soluciono
II O si hay un elemento diagonal nulo.
II 2 si hubo demasiadas iteraciones, mas de maxit.
244
11.12. SOLUCIÓN POR MÍNIMOS CUADRADOS
int i, ni, k;
double nrmD, di;
ni = n+l;
for(i=0;i<n;i++)if(fabs(a[i*nl])<=1.e-40)return O;
Ax b,
Ax-b 0,
IIAx-bll 0,
IIAx - bl1 2 0,
IIAx - bll~ O.
Es Posible que lo deseado no se cumpla, entonces se quiere que el in-
cumplimiento (el error) sea lo más pequeño posible. Se desea minimizar
esa cantidad,
min IIAx - bll~ . (11.15)
245
11. SOLUCIÓN DE SISTEMAS LINEALES
El vector x que minimice IIAx - bll~ se llama solución por mínimos cua-
drados. Como se verá más adelante, tal x existe y es único (suponiendo
que las columnas de A son linealmente independientes).
Con el ánimo de hacer más clara la deducción, supongamos que A
es una matriz 4 x 3. Sea f(x) = IIAx - bll~,
246
11.12. SOLUCIÓN POR MÍNIMOS CUADRADOS
01
~ =2(an X l
UX l
+ a12 x 2 + a13 X 3 - bl)an
+ 2(a21 x l + a22 x 2 + a23x3 - b2)a21
+ 2(a31 x l + a32 x 2 + a33X3 - b3)a31
+ 2(a41 x l + a42 x 2 + a43X3 - b4)a41.
01
~ =2(Al.X - bl)an + 2(A 2.x - b2)a21 + 2(A3.x - b3)a31
UXl
+ 2(A4.x - b4)a41.
+((AX)4 - b4 a41) ,
4
2 ¿)Ax - b)i ail,
i=l
4
2 2)A. 1MAx - b)i,
i=l
4
2¿)AT1.MAx - b)i,
i=l
2AT 1.(Ax - b),
2(AT (Ax - b))l
De manera semejante
247
11. SOLUCIÓN DE SISTEMAS LINEALES
(AT(Ax - b))l = O,
(AT(Ax - b))2 O,
(AT(Ax - b))3 = O
Es decir,
AT(Ax - b) O,
ATAx ATb. (11.16)
Las ecuaciones (11.16) se llaman ecuaciones normales para la solución
(o seudosolución) de un sistema de ecuaciones por mínimos cuadrados.
La matriz ATA es simétrica de tamaño n x n. En general, si A es
una matriz m x n de rango r, entonces A T A también es de rango r
(ver [Str86]). Como se supuso que el rango de A es n, entonces ATA es
invertible. Más aún, ATA es definida positiva.
Por ser ATA invertible, hay una única solución de (11.16), o sea,
hay un solo vector x que hace que las derivadas parciales sean nulas.
En general, las derivadas parciales nulas son simplemente una condición
necesaria para obtener el mínimo de una función (también lo es para
máximos o para puntos de silla), pero en este caso, como ATA es defi-
nida positiva, f es convexa, y entonces anular las derivadas parciales se
convierte en condición necesaria y suficiente para el mínimo.
En resumen, si las columnas de A son linealmente independientes, en-
tonces la solución por mínimos cuadrados existe y es única. Para obtener
la solución por mínimos cuadrados se resuelven las ecuaciones normales.
Como A T A es definida positiva, (11.16) se puede resolver por el méto-
do de Cholesky. Si m 2: n y al hacer la factorización de Cholesky resulta
que ATA no es definida positiva, entonces las columnas de A son lineal-
mente dependientes.
Si el sistema Ax = b tiene solución exacta, ésta coincide con la
solución por mínimos cuadrados.
Ejemplo 11.17. Resolver por mínimos cuadrados:
-~ -21 3O 1 1 [
[ = 3.1
8.9 1
[ -2
5
2
4 -2
1
Xl
X2
X3
-3.1
0.1
248
11.12. SOLUCIÓN POR MÍNIMOS CUADRADOS
[ ;~ ~~ =~~14 1[XXX3~ 1
-15 -12
4.0
-20.5
[ 23.4
1
La solución por mínimos cuadrados es:
El error, Ax - b, es:
-0.0628 ]
0.0196 <>
-0.0039 .
[
0.0275
-~ -~] [Xl]
[ -25 X22
= [ ~]
-6
4 6
249
11. SOLUCIÓN DE SISTEMAS LINEALES
34 20] [
[ 20 25
Xl ]
X2 [ i~ ]
La solución por mínimos cuadrados es:
X = (2, -1).
El error, Ax - b, es:
[~ ]
En este caso, el sistema inicial tenía solución exacta y la solución por
mínimos cuadrados coincide con ella. <>
250
11.12. SOLUCIÓN POR MÍNIMOS CUADRADOS
Ejercicios
4 -12 -10] [6 ]
A = -12 45 30 ,b = -9 .
[ -10 30 41 -31
-36 ]
e= 126 .
[ 122
A= [-1~
-10
-!~30 -!~],
41
b= [ -~].
-31
251
11. SOLUCIÓN DE SISTEMAS LINEALES
A = [ -~4 -2~ 2] [ 4]
~ ,b = : .
A =
[51 -1]
2 4
1 2
1
10
,b = [ 9]20
48
.
A=
[
1
6 4
2 57] , b = [10]15 .
8 9 3 20
147 825 3]
6 [10]
15
A =
[ 10 12
9 ,b =
15
20 .
25
~l, b=[¡~l·
1 2
A= 4 5
1~
8
[
11 12 25
252
11.12. SOLUCIÓN POR MÍNIMOS CUADRADOS
4 -2 2 O O O O -8
-2 5 -1 2 O O O 12
2 -1 5 4 6 O O 8
A= O 2 4 6 5 -2 O , b= 12
O O 6 5 11 4 3 23
O O O -2 4 12 2 18
O O O O 3 2 14 -6
11.21 Se dice que una matriz simétrica es una matriz banda de ancho
2m -1 si aij = O cuando Ij - i I ~ m. Demuestre que si A es definida
253
11. SOLUCIÓN DE SISTEMAS LINEALES
(ik,jk,Vk)
254
12
Solución de ecuaciones
f(x) = 0,
f:lR---+lR.
x5 - 3x4 + 10x - 8 0,
eX - x 3 + 8 0,
. x2 +x
---;-----,--- - x O.
cos(x - 1) + 2
¡ X
-00 e
_t 2
dt - 0.2 = O.
255
12. SOLUCIÓN DE ECUACIONES
lim Xk=X*.
k---+oo
IXk-X*I:SE,
If(Xk)1 :s E.
En la mayoría de los casos, cuanto más cerca esté Xo de x*, más rápida-
mente se obtendrá una buena aproximación de x*.
Otros métodos parten de un intervalo inicial [ao, boj, en el cual se
sabe que existe una raíz x*. A partir de él, se construye otro intervalo
[al, blJ, contenido en el anterior, en el que también está x* y que es de
menor tamaño. De manera análoga se construye [a2, b2]. Se espera que
256
12.1. MÉTODO DE NEWTON
X* E [ao, bol,
[aHl, bk+1l e [ak, bk], k = 1,2, ... ,
x* E [ak, bk], k = 1,2, ... ,
lim (bk - ak) O.
k-.oo
257
12. SOLUCIÓN DE ECUACIONES
k Xk f(Xk) f'(Xk)
O 3.000000 2.200000E+01 91.000000
1 2.758242 5. 589425E+00 47.587479
2 2.640786 9.381331E-01 32.171792
3 2.611626 4.892142E-02 28.848275
4 2.609930 1.590178E-04 28.660840
5 2.609924 1.698318E-09 28.660228
6 2.609924 -2. 838008E-15 28.660227
Las raíces reales del polinomio x 5 - 3x4 + lOx - 8 son: 2.6099, 1.3566,
1. Tomando otros valores iniciales el método converge a estas raíces. Si
se toma Xo = 2.1, se esperaría que el método vaya hacia una de las raíces
cercanas, 2.6099 o 1.3566 . Sin embargo, hay convergencia hacia 1.
k Xk f(Xk) f'(Xk)
O 2.100000 -4.503290e+00 -3.891500
1 0.942788 -1.97425ge-01 3.894306
2 0.993484 -1.988663e-02 3.103997
3 0.999891 -3. 272854e-04 3.001745
4 1.000000 -9.509814e-08 3.000001
5 1.000000 -7.993606e-15 3.000000
258
12.1. MÉTODO DE NEWTON
• Sencillez.
• Generalmente converge.
• En la mayoría de los casos, cuando converge, lo hace rápidamente.
• Puede no converger.
259
12. SOLUCIÓN DE ECUACIONES
Cada una de estas posibilidades puede hacerse con nombres fijos para
las funciones o por medio de apuntadores a funciones. En el método de
Newton, en cada iteración se calcula una vez j(x) y una vez j'(X).
Cuando se cambia j es necesario cambiar j'. Por razones de sencillez
en la escritura, la siguiente implementación en C utiliza un nombre fijo
para una función donde al mismo tiempo se evalúa j y j'.
int k;
double delta, xk, fx, fpx;
xk xO;
fx fxfpx(xk, fpx);
260
12.1. MÉTODO DE NEWTON
double fx;
return fx;
}
261
12. SOLUCIÓN DE ECUACIONES
Definición 12.1. Sea {xd una sucesión de números reales con límite
L. Se dice que la convergencia tiene orden de convergencia p, si pes
el mayor valor tal que el siguiente límite existe y es finito.
lim IX k+1 - LI
k--->oo IXk - Llp = j3 < 00
En este caso se dice que j3 es la tasa de convergencia. Cuando el orden
es 1, se dice que la convergencia es lineal.
Teorema 12.1. Sean a < b, 1 = la, b[, f : 1 --+]R, x* El, f(x*) = 0, l'
y 1" existen y son continuas en 1, 1'(x*) f:. 0, {Xk} la sucesión definida
por 12.1. Si Xo está suficientemente cerca de x*, entonces
lim Xk *
x, (12.2)
k--->oo
IXk+1 - x*1 11"(x*)1
lim (12.3)
k--->oo IXk - x*1 2 21f'(x*)1
262
12.2. MÉTODO DE LA SECANTE
entonces se obtiene
(12.4)
263
12. SOLUCIÓN DE ECUACIONES
264
12.2. MÉTODO DE LA SECANTE
int k;
double delta, xl, x2, fO, fl, f2, den;
xl xO + 0.01;
fO f(xO);
fl f(xl);
for( k=l; k<= maxit; k++){
den = fl - fO;
if( fabs(den) <= epsO ){
indic = O;
return xl;
}
delta = fl*(xl-xO)/den;
x2 = xl - delta;
f2 = f(x2);
if( fabs(f2) <= epsF ){
indic = 1;
return x2;
}
if( fabs(delta)/C 1.0+fabs(x2) ) <= epsX ){
indic = 2;
return x2;
}
xO xl; xl x2; fO f1; f1 f2;
}
indic = 3;
return x2;
}
11---------------------------------------------------------
double f(double x)
266
12.3. MÉTODO DE LA BISECCIÓN
{
II Calculo de f(x)
entonces
Finalmente
267
12. SOLUCIÓN DE ECUACIONES
Obviamente Ek -t OY
Ek 1 1
--=--t-
Ek-l 2 2·
Esto quiere decir que la sucesión de cotas del error tiene convergencia
lineal (orden 1) y tasa de convergencia 1/2.
En el método de la bisección se puede saber por anticipado el número
de iteraciones necesarias para obtener un tamaño deseado,
bk - ak < E,
(~)k <
-
E
bo - ao
,
bo - ao
2k >
E
1 bo-ao
klog2 > og ,
E
log bQ ~ aQ
k >
log2
268
12.4. MÉTODO DE REGULA FALSI
y = f(x)
(12.5)
269
12. SOLUCIÓN DE ECUACIONES
lim (b k - ak) = O.
k--->oo
270
12.5. MODIFICACIÓN DEL MÉTODO DE REGULA FALSI
entonces
nbisec = 2+ kbisec .
nmodif = 2 + 2 kmodif .
271
12. SOLUCIÓN DE ECUACIONES
g(x) = x. (12.6)
Xo -1
Xl -0.833333
X2 -0.852623
x3 -0.851190
X4 -0.851303
x5 -0.851294
X6 -0.851295
x7 -0.851295
X8 -0.851295
272
12.6. MÉTODO DE PUNTO FIJO
Xo -0.8510
Xl -0.8488
X2 -0.8294
X3 -0.6599
X4 1.1415
X5 -11.6832
X6 -142.0691
X7 -2.0190e+4
En este caso se observa que, aun partiendo de una muy buena apro-
ximación de la solución, no hay convergencia. <>
273
12. SOLUCIÓN DE ECUACIONES
274
12.6. MÉTODO DE PUNTO FIJO
y=x
y = g(x)
X2 X* X3 Xl
y=x
x* Xo X2 X3 X4
275
12. SOLUCIÓN DE ECUACIONES
y=x
276
12.6. MÉTODO DE PUNTO FIJO
Xo 3
Xl 2
X2 1.75000000000000
X3 1.73214285714286
X4 = 1.73205081001473
Xs 1.73205080756888
X6 1. 73205080756888
277
12. SOLUCIÓN DE ECUACIONES
°
Entonces g"(x) > para todo x positivo. Luego g'(x) es creciente para
x> O. Como g'(1) = -1, entonces -1 < g'(1+E). De nuevo por ser g'(x)
creciente, entonces -1 < g'(x) :s: 13/32 para todo x E l. En resumen,
19'(x)1 < 1 cuando x E l.
Entre 1 + E Y J3 el valor de g' (x) es negativo. Entre J3 y 4
el valor de g'(x) es positivo. Luego 9 decrece en [1 + E, J3] y crece en
[J3,4]. Entonces g([1 +E,J3]) = [g(1 +E),J3] ~ [2,J3] Y g([J3, 4]) =
[J3, 2.375]. En consecuencia g(l) = [J3, 2.375] ~ l. Entonces el método
de punto fijo converge a x* = J3 para cualquier Xo E]1, 4]. Este resultado
se puede generalizar al intervalo [1 + E, b] con b > J3.
Si se empieza con Xo = 1/2, no se cumplen las condiciones del teore-
ma; sin embargo, el método converge. <>
°
Supongamos que c .¡. es una constante y que x* es solución de la
ecuación f(x) = O. Ésta se puede reescribir
° cf(x),
x x + cf(x) = g(x). (12.8)
1+cJ'(x*) 0,
1
c
- f'(x*)'
f(Xk)
Xk+1 = Xk - f'(x*)' (12.9)
278
12.7. MÉTODO DE NEWTON EN IR N
xI + XIX2 + X3 - 3 o
2XI + 3X2X3 - 5 O (12.10)
(Xl + X2 + X3)2 - lOx3 +1 o.
Este sistema no se puede escribir en la forma matricial Ax = b; entonces
no se puede resolver por los métodos usuales para sistemas de ecuaciones
lineales. Lo que se hace, como en el método de Newton en ffi., es utili-
zar aproximaciones de primer orden (llamadas también aproximaciones
lineales). Esto es simplemente la generalización de la aproximación por
una recta.
FI(X)
F 2 (x)
1
F(x) =
[
Fn(x)
Así F es una función de variable vectorial y valor vectorial, F : ffi.n --t
F(x) = O. (12.11)
279
12. SOLUCIÓN DE ECUACIONES
2XI + X2 Xl
F'(2, -3,4) =
1
2
2
12
1
-9
1
[
6 6 -4
f(Xk)
Xk+l = Xk - f'(Xk) ,
280
12.7. MÉTODO DE NEWTON EN IR N
(12.12)
dk _F'(xk)-l F(x k )
xk+l xk + dk .
281
12. SOLUCIÓN DE ECUACIONES
xi + XIX2 + X3 - 3 O
+ 3X2X3 - 5
2XI O
(Xl + X2 + X3)2 - lOx3 + 1 O
2.5753]
resolver 21 122 -91] [d!i]
dg = - [- 1 ]
-37 , ~= 0.5890
[ 6 6 -4 dg -30 [ -2.7534
xl = -32] + [2.5753]
0.5890 =
[4.5753]
-2.4110
[
4 -2.7534 1.2466
4.5753] [ -4.4433]
[ 0.1321 ]
x2 = -2.4110 + 4.6537
2.2428 =
[
1.2466 0.5048
1.7514
A continuación se presentan los resultados de F(x k ), F'(x k ), dk , xk+l.
k=2
282
12.7. MÉTODO DE NEWTON EN IR N
k=4
k=5
Ejercicios
Trate de resolver las ecuaciones propuestas, utilice métodos diferen-
tes, compare sus ventajas y desventajas. Emplee varios puntos iniciales.
Busque, si es posible, otras raíces.
12.1 x 3 + 2x2 + 3x + 4 = O.
12.2 x 3 + 2x2 - 3x - 4 = O.
12.3 x 4 - 4x 3 + 6x2 - 4x + 1 = O.
12.4 x 4 - 4x 3 + 6x2 - 4x - 1 = O.
12.5 x 4 - 4x 3 + 6x2 - 4x +2 = O.
12.6
3x-6 x-2
---
cos(x) + 2 x2 + 1 + x3 _ 8 = O.
x2 +x + 10
eX +x2
12.7
. (1 + i)12
1000000 z ( ')12 1 = 945560.
1 +z -
283
12. SOLUCIÓN DE ECUACIONES
12.9 X¡ + X2 + 2X¡X2 - 31 = O,
6x¡ + 5X2 + 3X¡X2 - 74 = O.
284
13
Interpolación y
. .,
aproXlmaclon
lAño I Población I
1930 3425
1940 5243
1950 10538
1960 19123
1970 38765
1980 82468
1985 91963
1990 103646
1995 123425
Xo f(xo)
Xl f(XI)
X2 f(X2)
Xn f(x n )
285
13. INTERPOLACIÓN Y APROXIMACIÓN
x
Figura 13.1
Figura 13.2
286
13.1. INTERPOLACIÓN
Figura 13.3
13.1 Interpolación
En el caso general de interpolación se tiene un conjunto de n puntos
(Xl, Yl), (X2, Y2), ... , (x n , Yn) con la condición de que los Xi son todos
diferentes. Este conjunto se llama el soporte. La función 1, que se desea
construir, debe ser combinación lineal de n funciones llamadas funciones
de la base. Supongamos que estas funciones son !.pi, !.p2, ... , !.pn. Entonces,
Como las funciones de la base son conocidas, para conocer 1 basta co-
nocer los escalares al, a2, ... , an .
Las funciones de la base deben ser linealmente independien-
tes. Si n 2: 2, la independencia lineal significa que no es posible que una
de las funciones sea combinación lineal de las otras. Por ejemplo, las
funciones !.pi (x) = 4, !.p2 (x) = 6x2 - 20 Y !.p3 (x) = 2x 2 no son linealmente
independientes.
Los escalares al, a2, ... , an se escogen de tal manera que 1(Xi) = Yi,
para i = 1,2, ... , n. Entonces
287
13. INTERPOLACIÓN Y APROXIMACIÓN
ipl(XI) ip2(XI)
ipl(X2) ip2(X2) ipn(X2)
ipn(XI) 1[ala2· 1 [ Y2YI. 1
·· ..
[
ipl(Xn ) ip2(X n ) ipn(X n ) an Yn
De manera compacta se tiene
<I>a = y. (13.1)
[=n '
Entonces
2
a= j(x)=-4-3x+2x ,
288
13.2. INTERPOLACIÓN DE LAGRANGE
Entonces
a=
-1.2921
-0.8123
1, j(x) = 1.2921 - 0.8123é + 0.0496e 2x ,
[ 0.0496
Los valores Xi deben ser todos diferentes entre sí. Sin perder generalidad,
se puede suponer que Xo < Xl < X2 < ... < Xn .
El problema 13.2 se puede resolver planteando n + 1 ecuaciones con
n + 1 incógnitas (los coeficientes del polinomio). Este sistema lineal se
puede resolver y se tendría la solución. Una manera más adecuada de
encontrar p es por medio de los polinomios de Lagrange.
289
13. INTERPOLACIÓN Y APROXIMACIÓN
f'(c) = o.
rrn
(x - Xi)
Lk(X) = _i---:=O;:;-,~'-=--=f_k_ __ (13.3)
rr
n
i=O,i=fk
(Xk - Xi)
(x - 2)(x - 3) x 2 - 5x + 6
Lo(x)
(-1-2)(-1-3) = 12
(x - -1)(x - 3) 2
x - 2x - 3
Ll(X)
(2 - -1)(2 - 3) = -3
(x - -1)(x - 2) x2 - x - 2
L 2(x)
(3 - -1)(3 - 2) = - - 4
Osi i =1= k,
Lk(Xi) = { 1 si i = k. (13.4)
290
13.2. INTERPOLACIÓN DE LAGRANGE
Para el ejemplo,
p(x) = 1Lo(x) - 2Ll(X) + 5L 2(x) = 2x 2 - 3x - 4.
Ejemplo 13.3. Encontrar el polinomio, de grado menor o igual a 3, que
pasa por los puntos
(-1,1), (1, -5), (2, -2), (3,5).
291
13. INTERPOLACIÓN Y APROXIMACIÓN
Entonces
C E C n +1
lt '
<I>(Xi)
C(Xi) E(Xi) - <I>(t) E(t) = O,
292
13. INTERPOLACIÓN Y APROXIMACIÓN
Entonces
C E eItn +1 '
cI> (Xi)
C(Xi) E(Xi) - cI>(t) E(t) = O,
cI>(t)
C(t) E(t) - cI>(t) E(t) = O.
292
13.3. DIFERENCIAS DIVIDIDAS DE NEWTON
Entonces
E(t) = <I>(t) f{n+l)(().
(n + 1)!
La fórmula anterior dice que e tiene n raíces diferentes xo, Xl, ... , Xn-l,
entonces
293
13. INTERPOLACIÓN Y APROXIMACIÓN
Pn(X) = Pn-l (x) + f[xo, Xl, ... , Xn](X - XO)(X - Xt) ... (X - Xn-l). (13.7)
Esta fórmula es la que se utiliza para calcular Pn(x), una vez que se sepa
calcular, de manera sencilla, f[xo, Xl, ... , Xn ].
•
• A partir depn-l(x), con el valor J[XO,XI, ... ,Xn], se calculapn(x).
Obviamente
po(X) = f(xo). (13.8)
Por definición, consistente con lo visto antes,
f[xo] := f(xo),
que se generaliza a
J[Xi] := f(Xi), Vi. (13.9)
Las demás diferencias divididas se deducen de (13.7),
PI (Xl) - Po(XI)
f[xo, Xl]
XI- Xo
f(XI) - f(xo)
f[XO,XI]
Xl - Xo
J[XI] - f[xo]
f[xo, Xl]
Xl - Xo
294
13.3. DIFERENCIAS DIVIDIDAS DE NEWTON
(13.10)
12 - h h - fa
j[Xl, X2] - f[xo, Xl]
X2 - Xo
j[Xl, X2] - f[xo, Xl] fO(X2 - Xl) - h(X2 - XO) + 12(xl - XO)
X2 - Xo (X2 - Xl)(X2 - XO)(Xl - XO)
Luego
Generalizando,
(13.11)
(13.12)
(13.13)
295
13. INTERPOLACIÓN Y APROXIMACIÓN
Entonces
296
13.3. DIFERENCIAS DIVIDIDAS DE NEWTON
(O, O), (0.5, 0.7071), (1, 1), (2, 1.4142), (3, 1.7321), (4, 2).
297
13. INTERPOLACIÓN Y APROXIMACIÓN
para i = 0,000, n
DO j[Xi] = f(Xi)
fin-para i
para j = 1, ooo,m
para i = 0,000, n - j
calcular Dj f[Xi] según (13017)
fin-para i
fin-para j
• Si para algún m todos los valores f[Xk, xk+l, 000' Xk+m] son iguales
(o aproximadamente iguales), entonces f es (aproximadamente)
un polinomio de grado mo
Po(X) = fk
PI(X) = Po(x) + DI f[Xk](x - Xk)
P2(X) = PI(X) + D 2f[Xk](x - Xk)(X - Xk+l)
P3(X) = P2(X) + D3 f[Xk](X - Xk)(X - Xk+1)(X - Xk+2)
P4(X) = P3(X) + D4j[Xk](X - Xk)(X - Xk+1) (x - Xk+2)(X - Xk+3)
298
13.3. DIFERENCIAS DIVIDIDAS DE NEWTON
Xi
O
.5
1
2
3
4
Para el caso de la interpolación cuadrática, una simple inspección
visual determina que hay dos posibilidades para Xk. La primera es Xk =
299
13. INTERPOLACIÓN Y APROXIMACIÓN
Ui
Xi + Xi+m (13.20)
2
Vi
Xi + Xi+! + Xi+2 + ... + Xi+m (13.21)
m+1
Ix -ukl min{lx -
t
uil :x E [Xi, Xi+m]} , (13.22)
Ix - vkl m.in{lx - vil: x E [Xi, Xi+m]}. (13.23)
t
Xi Ui Ix - uil . Vi Ix - vil
O
.5 1.25 0.44 1.1667 0.5233
1 2.00 0.31y' 2.0000 0.3100y'
2
3
4
300
13.3. DIFERENCIAS DIVIDIDAS DE NEWTON
Xi Ui IX - Uil Vi IX - Vil
'/'0 = 1, po(X) = 1,
'/'1 = 1(1.69 - 1) = 0.69, Pl(X) = 1 + 0.4142(0.69) = 1.285798
'/'2 = 0.69(1.69 - 2) = -0.2139, P2(X) = 1.285798 - 0.0482( -0.2139)
P2(X) = 1.296097
determinar Xk
px = f(Xk)
gi = 1.0
para j = 1, ... ,m
gi = gi * (x - Xk+j-l)
px = px + gi * Dj f[Xkl
fin-para j
301
13. INTERPOLACIÓN Y APROXIMACIÓN
~kfi t( j=O
-1)j (~) fi+k-j ,
J
(13.27)
k
fi+k L (~)~j Ji. (13.28)
j=o J
Las demostraciones se pueden hacer por inducción. La primera igualdad
permite calcular ~k fi sin tener explícitamente los valores ~k-Ifj. La
segunda igualdad permite el proceso inverso al cálculo de las diferencias
finitas (se obtienen a partir de los valores iniciales f p ), es decir, obtener
un valor fm a partir de las diferencias finitas.
Para valores igualmente espaciados, las diferencias finitas y las divi-
didas están estrechamente relacionadas.
DO f[Xi] = f[Xi] fi = ~Ofi
fi+l - fi ~l Ji
DI f[Xi] = f[Xi, Xi+1]
Xi+1 - Xi h
j[Xi+I, Xi+2] - f[Xi, Xi+l] ~2Ji
D 2f[Xi] = j[Xi, Xi+1, Xi+2]
Xi+2 - Xi 2h 2
~mfi
D m f[Xi] = j[Xi, ... , Xi+m] (13.29)
m!hm
302
13.4. DIFERENCIAS FINITAS
303
13. INTERPOLACIÓN Y APROXIMACIÓN
para i = 0, ... , n
b..0Ji = f(Xi)
fin-para i
para j = 1, ... ,m
para i = 0, ... , n - j
. . 1 . 1
b..J fi = b..J - fi+l - b..J - Ji
fin-para i
fin-para j
Pm(X) = ¿m [b..ifk
i! h i II (x -
i-l
Xk+j)
1
t=O J=O
m i-l 8 _ j
¿b..
.°
t=
iA P
J=O
j +1
(~)=~ .. _
..
Desarrollando los factoriales y simplificando se tiene
304
13.4. DIFERENCIAS FINITAS
Esta última expresión sirve para cualquier valor real a y cualquier entero
no negativo b, con la convención de que (~) = 1. Entonces,
i-l .
s -J
II
j=oJ
.+ 1
(13.30)
( ~)
'/,
(. s ) s -
'/, -1
~+1
'/,
Esto permite su cálculo de manera recurrente
305
13. INTERPOLACIÓN Y APROXIMACIÓN
1'0 = 1, po(X) = fk
1'1 = 1'0 s, PI (X) = Po (X)+ ,6,1 ik 1'1
1'2 = 1'1 (s - 1)/2, P2 (X) = PI (X)+ fl 2ik 1'2
1'3 = 1'2(S - 2)/3, P3(X) = P2(X) + fl3 fk 1'3
1'4 = 1'3(S - 3)/4, P4(X) 4
= P3(X) + fl ik1'4
1'0=1, po(x)=h=1.2247
1'1 = 1(0.92) =0.92, PI (x) = 1.2247 + .1895(.92) = 1.39904
1'2=0.92(0.92 -1)/2=-.0368, P2(X) = 1.39904 - .0226(-0.0368)
P2(X) = 1.399872
306
13.5. APROXIMACIÓN POR MÍNIMOS CUADRADOS
muy buena. Sin embargo, en algunas ocasiones se desea una función que
sirva para todos los puntos. La segunda solución consiste en obtener una
sola función j que, aunque no pase por todos los puntos, pase relativa-
mente cerca de todos. Este es el enfoque de la aproximación por mínimos
cuadrados.
Se supone que hay m puntos (Xl, YI), (X2, Y2), ... , (x m , Ym) y que
los Xi son todos diferentes. La función j, que se desea construir, debe
ser combinación lineal de n funciones llamadas funciones de la base.
Supongamos que estas funciones son 'PI, 'P2, ... , 'Pn' Entonces,
}(x) = al'PI(x) + a2'P2(x) + ... + an'Pn(x).
Como las funciones de la base son conocidas, para conocer j basta co-
nocer los escalares al, a2, ... , ano
Como se supone que hay muchos puntos (m grande) y como se desea
que j sea sencilla, es decir, n es relativamente pequeño, entonces se debe
tener que m ~ n.
Las funciones de la base deben ser linealmente independien-
tes. Los escalares al, a2, ... , a n se escogen de tal manera que }(Xi) ~ Yi,
para i = 1,2, ... , m. Entonces,
[f 1 ~
Ym
De manera compacta se tiene
cI>a ~ y. (13.31)
307
13. INTERPOLACIÓN Y APROXIMACIÓN
es decir,
m _ 2
min L (¡(Xi) - Yi) .
i=l
2
3
1
1.5 2.25
4
9
[;:l ~ 0.65
0.725
0.85
1.35
Las ecuaciones normales dan:
7.5
1625 ][ a) ] [ 4.1250]
[ 5
7.5 16.25 39.375 a2 7.4875
16.25 39.375 103.0625 a3 17.8313
308
13.5. APROXIMACIÓN POR MÍNIMOS CUADRADOS
La solución es:
0.56] -
a= -0.04 , f(x) = 0.56 - 0.04x + O.lx 2 .
[ 0.10
Ejercicios
(1, -5),
(2, -4),
(4, 4).
(-1,-5),
(1, -5),
(2, -2),
(4, 40).
(-1, 10),
(1, 8),
(2, 4),
(4, -10).
309
13. INTERPOLACIÓN Y APROXIMACIÓN
(0.10, 11.0000),
(0.13, 8.6923),
(0.16, 7.2500),
(0.20, 6.0000),
(0.26, 4.8462),
(0.40, 3.5000),
(0.32, 4.1250),
(0.50, 3.0000).
(0.05,21.0000),
(0.10, 11.0000),
(0.15, 7.6667),
(0.20, 6.0000),
(0.25, 5.0000),
(0.30, 4.3333),
(0.35, 3.8571),
(0.40, 3.5000).
13.1 Considere los mismos puntos del ejercicio anterior. Construya la ta-
bla de diferencias finitas hasta el orden 3. Halle P2(0.11), P2(0.08),
P2(0.25), P2(0.12), P2(0.33), P2(0.6), P3(0.25), P3(0.33),
P3(0.6).
310
13.5. APROXIMACIÓN POR MÍNIMOS CUADRADOS
13.10 Considere los mismos puntos de los dos ejercicios anteriores. Use
otra base y obtenga la correspondiente función de aproximación
por mínimos cuadrados.
311
14
Integración y diferenciación
1= lb f(x)dx.
y = f(x)
a
Figura 14.1
313
14. INTEGRACIÓN Y DIFERENCIACIÓN
¡ 0.5
0.1
X2
e dx.
r
Jxo
n
f(x)dx = r
Jxo
m
f(x)dx + {X2m
JXm
f(x)dx + ... + r n
}X -
f(x)dx.
nm
Xo Xl x2 xm X2m xn - m xn
a b
Figura 14.2
314
14.2. FÓRMULA DEL TRAPECIO
En el intervalo [xo, xml se conocen los puntos (xo, Yo), (Xl, YI), ... ,
(x m , Ym) y se puede construir el polinomio de interpolación de Lagrange
Pm(x). Entonces la integral J:om f(x)dx se aproxima por la integral de
Pm,
X- Xl X - Xo
PI (x) = Yo Xo - Xl
+ Yl
Xl -Xo
,
x-h X
PI(X) = Yo-=-¡;: + YI h'
YI - Yo
PI (X ) = Yo +X h .
Entonces
¡Xo
Xl
PI(x)dx =
lho
(Yo + X
YI - Yo
h )dx
_ h + h 2 YI - Yo
- Yo 2 h '
= h( Yo + J!..!..-)
2 2'
¡ Xo
Xl f(x)dx ~ h Yo + YI.
2
(14.1)
315
14. INTEGRACIÓN Y DIFERENCIACIÓN
Yo YI
Xo h Xl
Figura 14.3
Ejemplo 14.1.
0.2 1 1
10
eXdx ~ 0.2( _ea + _eO. 2) = 0.22214028. <>
22
Aplicando la fórmula del trapecio a cada uno de los intervalos [Xi-l, Xi]
se tiene:
¡Xl f(x)dx ~ h( Yo + n),
Jxo 2 2
¡ X2
Xl
f(x)dx ~ h(n + ~),
2 2
~
¡ Xo
xn
f(x)dx ~ h( ;
y
+ YI + Y2 + ... + Yn-2 + Yn-l +
yn
2 ), (14.2)
n-l
(X n y y
Jx f(x)dx~h(-f+LYi+ ;).
xo i=l
Ejemplo 14.2.
0.8 1 1
1° eXdx ~ 0.2( _ea
2
+ eO. 2 + e°.4 + eO. 6 + _eO. 8 ) = 1.22962334. <>
2
316
14.2. FÓRMULA DEL TRAPECIO
eloe = ¡ Xl
xo
Yo
f(x)dx - h(2 +
YI
2)
= {Xl f(x)dx _ (Xl PI(x)dx
Jxo Jxo
= ¡Xl (j(X) - PI(x))dx.
Jxo
Utilizando la fórmula del error para la interpolación polinómica 13.6,
f"(z) ¡Xl
eloe = - - (X - XO)(x - xI)dx, z E [XO, Xl].
2 Xo
eloe =
f"(z) r
-2- Jo t(t - h)dt, z E [xo, Xl],
f"(z) h 3
= -2-(-6), z E [xo, Xl],
3 f"(z)
eloe = -h ~' z E [xo, Xl]. (14.3)
317
14. INTEGRACIÓN Y DIFERENCIACIÓN
entonces
1 E [0.22132601,0.22147361].
.
eglob = ¡Xo
xn
f(x)dx - h( -fy + YI + Y2 + ... + Yn-2 + Yn-l +
yn
2 )
. n f"(Zi) h 3
=2:) , n ) ' ZiE[Xi-I,Xi]
i=l
h3 n
= - 12 I:.. J" (Zi) , Zi E [Xi-l, Xi]
i=l
Sean
318
14.3. FÓRMULA DE SIMPSON
Entonces
MI :::; f"(Zi) :::; M2, Vi
n
nMl :::; L f"(Zi) :::; nM2,
i=l
n
MI :::; -1 ~
~ f "( Zi):::; M 2 •
n i=l
Si f E C~,bl' entonces, aplicando el teorema del valor intermedio a f",
existe ~ E [a, b] tal que
f"(~) = ~
n
t
i=l
f"(zd·
Entonces
~ E [a,b].
(b - a)f"(~)
eglob = - h2 12 ,~E [a,b]. (14.5)
319
14. INTEGRACIÓN Y DIFERENCIACIÓN
{2h 1 8h 3 4h 2
Jo P2(x)dx = 2h2 (3(YO - 2Yl + Y2) + h T (-3yO + 4YI - Y2)
+ 2h 2(2h)yO) ,
(2h 1 4 1
Jo P2(x)dx = h(3 YO + 3Y1 + 3 Y2 ).
Entonces
¡ X2
Xo
h
f(x)dx ~ 3(YO + 4Yl + Y2) (14.6)
¡ Xo
xn h
f(x)dx ~ 3(YO + 4Yl + 2Y2 + 4Y3 + ... + 4Yn-l + Yn) (14.7)
{X n h k k-l
Jx f (X )dx ~ 3 ( Yo + 4 L Y2j-l + 2 L Y2j + Yn)
Xo j=l j=l
Ejemplo 14.3.
o.S 02
l° eX dx ~ -'-(eo + 4(eO. 2 + eO. 6) + 2 e°.4
3
+ eO. s) = 1.22555177.
=
t h
J-h f(x)dx - 3(J(-h) + 4f(0) + f(h)).
320
14.3. FÓRMULA DE SIMPSON
Sea F tal que F'(x) = f(x), entonces J~h f(x) dx = F(h) - F( -h). Al
derivar con respecto a h se tiene f(h) + f( -h).
1
e'(h) = f(h) + f( -h) - 3" (J( -h) + 4f(0) + f(h))
- ~ ( - f' (- h) + f' (h) ) ,
3e'(h) = 2f(h) + 2f(-h) - 4f(0) - h(f'(h) - f'(-h)).
Entonces
e"'(h) = - 2~2 f(4) (o:h) , o: E [-1,1].
Sea
e"(h) = -- 21
3 O
h
t 2 g4(t) dt.
321
14. INTEGRACIÓN Y DIFERENCIACIÓN
Sea
entonces
De manera semejante,
Sea
322
14.3. FÓRMULA DE SIMPSON
e(h) = 1 h
e'(t)dt + e(O),
e(h) = -11
8
1 h
t492(t) dt,
(14.8)
eglob = 1Ja
b
(x) dx - ( 3" ( Yo
h
j=l
k
+ 4 I: Y2j -1 + 2 I: Y2j +
k-1
j=l
Yn)),
= t (-
j=l
h5 ¡(~bZj)), Zj E [X2j-2,X2j],
h5 k
= - 90 I: ¡(4) (Zj)
j=l
323
14. INTEGRACIÓN Y DIFERENCIACIÓN
kLj=l k
¡(4) (Zj) = ¡(4) (~),
k
L¡(4)(Zj) = k¡(4)(~),
j=l
k
" " ¡(4) (Zj) = ?!: ¡(4)(~),
~
)=1
2
k
L ¡(4) (Zj) =. b- a
2h
¡(4)(~).
j=l
Entonces
4 (b-a)¡(4)(~)
eglob = -h 100 ,~ E [a, b]. (14.9)
¡ X3
XQ
¡(x)dx =
h
S(3YQ + 9Y1 + 9Y2 + 3Y3) -
3
80h5 ¡(4)(z) , Z E [xQ, X3],
324
14.4. OTRAS FÓRMULAS DE NEWTON-COTES
Xm ¡xm
¡xo f(x)dx>:::: xo Pm(x)dx.
La siguiente tabla muestra las más importantes.
m error
h f"(z) 3
1 "2 (Yo + YI) ---h
12
h f(4)(z) 5
2 3(YO + 4YI + Y2) 90 h
3h 3f(4)(z) 5
3 8(YO + 3YI + 3Y2 + Y3) 80 h
2h 8 f(6)(z) 7
4 45 (7yo + 32YI + 12Y2 + 32Y3 + 7Y4) 945 h
325
14. INTEGRACIÓN Y DIFERENCIACIÓN
espaciados en x.
m error
f"(Z) h 3
+ __
O 2hYl
3
1
3h
2(Yl + Y2) + 3 f"(z)
h3
4
4h 14f(4)(Z) 5
2 3(2Yl - Y2 + 2Y3) + 45 h
5h 95f(4)(Z) 5
3 24 (l1Yl + Y2 + Y3 + llY4) + 144 h
En todos los casos z E [xo, Xm +2].
Ejemplo 14.4.
0.8 4 x 02
1° eX dx ~
3
. (2 eO. 2 - eO. 4 + 2 eO. 6 ) = 1.22539158.
En general, las fórmulas cerradas son más precisas que las abiertas,
entonces, siempre que se pueda, es preferible utilizar las fórmulas cerra-
das. Las fórmulas abiertas se usan cuando no se conoce el valor de la
función f en los extremos del intervalo de integración; por ejemplo, en
la solución numérica de algunas ecuaciones diferenciales ordinarias.
326
14.5. CUADRATURA DE GAUSS
(14.10)
Los valores Wi se llaman los pesos o ponderaciones y los Xi son las abs-
cisas. Si se desea integrar en otro intervalo,
t =
2
-(~ - a) -1, ~
b-a
= -2-(t + 1) + a, d~ = b - a dt
b-a 2
(14.11)
(14.12)
(14.13)
)-1
r f(x) dx = L Wi f(Xi) ,
i=l
si f(x) = 1, X, x 2, ... , xmn.
Recordemos que
o si k es impar,
2
si k es par.
k+1
327
14. INTEGRACIÓN Y DIFERENCIACIÓN
WI = {I 1 dx = 2,
J-l
WlXl = {l xdx = O.
J-l
Se deduce inmediatamente que
Wl = 2, Xl = O. (14.14)
Para n ~ 2, se puede suponer, sin perder generalidad, que hay simetría
en los valores Xi yen los pesos Wi. Más específicamente, se puede suponer
que:
Xl < X2 < ... < Xn ,
Xi = -Xn+l-i ,
Wi = Wn+l-i·
Para n = 2,
Wl + W2 = {l 1 dx = 2,
J-l
WlXl + W2 X 2 = {l xdx = O,
J-l
2
Wlxl +W2X2
2= JI 2dx = -2,X
-1 3
WlX~ + W2X~ = {l x 3 dx = O.
J-l
Por suposicione~ de simetría,
Xl < O< X2,
Xl = -X2,
Wl = W2·
Entonces
2Wl = 2,
2 _ _2 -o
2WlXl - 3
328
14.5. CUADRATURA DE GAUSS
Finalmente,
Para n = 3,
Wl + W2 + W3 = 2,
WlXl + W2X2 + W3X3 = O,
2 2 2 2
Wlxl + W2 x 2 + w3 x 3 = 3'
Wlxl + W2 x 2 + W3 x 3 =
3 3 3 O,
4 4 4 2
Wlxl + W2 x 2 + w3 x 3 = 5'
Wl xf + W2X~ + W3X~ = o.
Xl < O = X2 < X3 ,
Xl = -X3,
Wl = W3·
Entonces
2Wl + W2 = 2,
2 2
2WlXl = 3'
4 2
2WlXl = 5·
Finalmente,
Wl = ~,Xl = -/f,
8
W2 = 9,X2 = O,
W3 = ~,X3 = /f.
329
14. INTEGRACIÓN Y DIFERENCIACIÓN
La siguiente tabla contiene los valores Wi, Xi, para valores de n menores
o iguales a 4.
n Wi Xi
1 2 O
2 1 ±0.577350269189626
3 0.555555555555555 ±O. 774596669241483
0.888888888888889 O
4 0.347854845137454 ±0.861136311594053
0.652145154862546 ±0.339981043584856
¡ 0.2
0.8
eX dx
¡ 0.8
0.2
e
xd
x:::::!
0.8-0.2(5 6
2 9
8
9
56)
-e +-e6 +-e
9
:::::! 1.00413814737559
¡0.2
0.8
é dx
03
:::::! - ' -
3
(eO. 2 + 4 eO. 5 + eO. 8) = 1.00418287694532
330
14.5. CUADRATURA DE GAUSS
331
14. INTEGRACIÓN Y DIFERENCIACIÓN
Por ejemplo,
Po(x) = 1,
P1 (x) = x,
1 2
P2(X) = 2(3x - 1),
1 3
P3(X) = 2(5x - x),
1
P4 (x) = S (35x 4 - 30x 2 + 3).
Po (x) = 1, (14.19)
P1 (x) = x, (14.20)
2n+ 1 n
Pn+1(X) = X Pn(x) - --lPn-1(x). (14.21)
n+1 n+
Algunas de las propiedades de los polinomios de Legendre son:
(1 2
• J_1(Pn (x))2 dx = (14.24)
• w. = 1 (1 Pn(x) dx (14.25)
t P~(Xi) J-1 X - Xi '
1 2
(14.26)
• Wi = (P~(Xi))2 1 - x; .
332
14.6. DERIVACIÓN NUMÉRICA
Para n = 1
En general,
- '22 f"(C),
." ."e E [Xi,Xi+l ] (14.27)
333
14. INTEGRACIÓN Y DIFERENCIACIÓN
Entonces
2
f '( Xl ) = Y2 - Yo
<'OL - 6h f"'(C)
"', 'C" E [xo, x2 1.
De manera general, ,,,\
(.
2
f '()
Xi = Yi+l - Yi-l
2h h f"'(C)
- 6 "', 'C" E [xi-l, Xi+l 1, (14.29)
En [YoG72], página 357, hay una tabla con varias fórmulas para diferen-
ciación numérica. Para la segunda derivada, una fórmula muy empleada
es:
2
f "( x~.) -- Yi+l - 2Yi +
h2
Yi-l _ h
12
f(4)(~), ~ E [Xi-l, Xi+1], (14.30)
334
14.6. DERIVACIÓN NUMÉRICA
Ejercicios
14.1 Calcule
{l eXdx
JO.2
utilizando la fórmula del trapecio y de Simpson, variando el núme-
ro de subintervalos. También por medio de la cuadratura de Gauss
variando el número puntos. Calcule los errores. Compare.
14.2 Calcule
335
14. INTEGRACIÓN Y DIFERENCIACIÓN
¡ 0.35
0.05
f(x)dx, ¡0.05
0.40
f(x)dx,
r°.45
Jo
0.05
f(x)dx.
14.7 Considere los mismos puntos del ejercicio anterior. Calcule una
aproximación de f'(0.25), f'(0.225), 1"(0.30).
¡° e
_t 2
dt = 0.1.
336
15
Ecuaciones diferenciales
Y, = xy + 3x 2 x E [2 4]
l+x 2 +y 2 ' "
y(2) = 5.
Temas importantísimos como existencia de la solución, unicidad o esta-
bilidad, no serán tratados en este texto. El lector deberá remitirse a un
libro de ecuaciones diferenciales. Aquí se supondrá que las funciones sa-
tisfacen todas las condiciones necesarias (continuidad, diferenciabilidad,
condición de Lipschitz ... ) para que la solución exista, sea única ...
Como en todos los otros casos de métodos numéricos, la primera
opción para resolver una ED01CI es buscar la solución analítica. Si
esto no se logra, entonces se busca la solución numérica que consiste en
encontrar valores aproximados YI, Y2, ... , Yn tales que
337
15. ECUACIONES DIFERENCIALES
Entonces
Yl = Yo + hf(xo, YO).
338
15.1. MÉTODO DE EULER
(Xl, YI)
Yo = y(XO)
Xo Xo +h
Figura 15.1 Método de Euler.
El error local tiene que ver con el error cometido para calcular Y(Xi+1)
suponiendo que Yi es un valor exacto, es decir, Yi = Y(Xi). El error global
es el error que hayal considerar Yn como aproximación de y(x n) (n indica
el número de intervalos).
Los resultados sobre el error en el método de Euler son:
2 (15.3)
YI = Y(XI) + O(h )
Yn = y(x n ) + O(h). (15.4)
339
15. ECUACIONES DIFERENCIALES
y' = 2x 2 - 4x +Y
y(1) = 0.7182818
Yl = Yo + hf(xo, Yo)
= 0.7182818 + 0.25f(1, 0.7182818)
= 0.7182818 + 0.25(0.7182818 + 2 x 12 - 4 x 1)
= 0.3978523
Y2 = Yl + hf(Xl, yd
= 0.3978523 + 0.25f(1.25, 0.3978523)
= 0.3978523 + 0.25(0.3978523 + 2 x 1.252 - 4 x 1.25)
= 0.0285654
Y3 = ...
Xi I Y(Xi) y(xd
1.00 0.7182818 0.7182818
1.25 0.3978523 0.3653430
1.50 0.0285654 -0.0183109
1.75 -0.3392933 -0.3703973
2.00 -0.6428666 -0.6109439
2.25 -0.8035833 -0.6372642
2.50 -0.7232291 -0.3175060
2.75 -0.2790364 0.5176319
3.00 0.6824545 2.0855369
340
15.2. MÉTODO DE HEUN
1
•
o
•
• •
-1 +------,-------------r------------~--
1 2 3
Figura 15.2 Método de Euler.
En los primeros valores se observa que el error es muy pequeño. A
partir de x = 2 se empiezan a distanciar los valores jj(x) y y(x). Si se
trabaja con h = 0.1 se obtiene jj(3) = 1.4327409; con h = 0.01 se obtiene
y(3) = 2.0133187; con h = 0.001 se obtiene y(3) = 2.0782381. O
y(xo + h)
Yo = y(xo)
Xo Xo +h
Figura 15.3 Método de Heun.
341
15. ECUACIONES DIFERENCIALES
o sea,
Kl = hf(Xi, Yi)
K2 = hf(Xi + h, Yi + K 1) (15.5)
1
Yi+l = Yi + "2(K1 + K 2 ).
y' = 2x 2 - 4x + Y
y(l) = 0.7182818
342
15.2. MÉTODO DE HEUN
K 1 = hf(xo, YO)
= 0.25f(1, 0.7182818)
= -0.320430
K 2 = hf(xo + h, Yo + Kl)
= 0.25f(1.25, 0.397852)
= -n.369287
Yl = Yo + (K1 + K2)/2
= 0.3734236
K 1 = hf(Xl, Yl)
= 0.25f(1.25, 0.3734236)
= -0.375394
K2 = hf(Xl + h, Yl + K 1 )
= 0.25f(1.500000, -0.001971)
= -0.375493
Y2 = Yl + (K1 + K2)/2
= -0.0020198
343
15. ECUACIONES DIFERENCIALES
-1 +I------,------------,------------~--
1 2 3
Figura 15.4 Método de Heun.
344
15.3. MÉTODO DEL PUNTO MEDIO
y(xo + h)
I (Xl,Yl)
I
Yo = Y(Xo) I
I
I
I
I
I
I
Xo Xo + h/2 Xo +h
h
y(x + h/2) :::::: y(x) + "2 f(x, y)
h
y(x + h) :::::: y(x) + hf(x + h/2,y(x) + "2 f (x,y)).
La anterior aproximación suele escribirse de la siguiente manera:
Kl = hf(Xi, Yi)
K2 = hf(Xi + h/2, Yi + K1/2) (15.6)
Yi+l = Yi + K 2·
y' = 2x2 - 4x + Y
y(1) = 0.7182818
345
15. ECUACIONES DIFERENCIALES
K 1 = hf(xo, YO)
= 0.25f(1, 0.7182818)
= -0.320430
K 2 = hf(xo + h/2, Yo + KI/2)
= 0.25f(1.125, 0.558067)
= -0.352671
Yl = Yo +K2
= 0.3656111
K 1 = hf(Xl, Yl)
= 0.25f(1.25, 0.3656111)
= -0.377347
K 2 = hf(Xl + h/2, Yl + KI/2)
= 0.25f(1.375, 0.176937)
= -0.385453
Y2 = Yl + K 2
= -0.0198420
K1 = oo'
Xi I ii(Xi) Y(Xi)
1.00 0.7182818 0.7182818
1.25 0.3656111 0.3653430
1.50 -0.0198420 -0.0183109
1.75 -0.3769851 -0.3703973
2.00 -0.6275434 -0.6109439
2.25 -0.6712275 -0.6372642
2.50 -0.3795415 -0.3175060
2.75 0.4121500 0.5176319
3.00 1.9147859 2.0855369
346
15.4. MÉTODO DE RUNGE-KUTTA
-1 +-----~------------~------------~--
1 2 3
Figura 15.6 Método del punto medio.
También, en este ejemplo, los resultados son mucho mejores. De nue-
vo hubo que evaluar 16 veces la función ¡(x, y), 2 veces en cada iteración.
Al aplicar el método del punto medio con h = 0.5 (es necesario evaluar
8 veces la función) se obtiene i/(3) = 1.5515985, resultado no tan bueno
como 2.0887372, pero netamente mejor que el obtenido por el méto-
do de Euler. Si se trabaja con h = 0.1 se obtiene i/(3) = 2.0538177;
con h = 0.01 se obtiene i/(3) = 2.0851903; con h = 0.001 se obtiene
i/(3) = 2.0855334. (>
347
15. ECUACIONES DIFERENCIALES
Método de Euler:
K¡ = hf(Xi, Yi)
Yi+¡ = Yi + K¡.
Método de Heun:
K¡ = hf(Xi, Yi)
K 2 = hf(Xi + h, Yi + K¡)
1 1
Yi+1 = Yi + 2"K¡ + 2"K2.
K¡ = hf(Xi, Yi)
1 1
K2 = hf(Xi + 2"h, Yi + 2"K¡)
Yi+¡ = Yi + OK¡ + K2·
K¡ = hf(Xi, Yi)
K2 = hf(Xi + h/2, Yi + K¡f2)
K3 = hf(Xi + h/2, Yi + K2/2) (15.8)
K4 = hf(Xi + h, Yi + K3)
Yi+¡ = Yi + (K¡ + 2K2 + 2K3 + K4)/6.
y' = 2x2 - 4x + y
y(1) = 0.7182818
348
15.4. MÉTODO DE RUNGE-KUTTA
K 1 = hf(xo, YO)
= 0.25f(1, 0.7182818)
= -0.320430
K 2 = hf(xo + h/2, Yo + KI/2)
= 0.25f(1.125, 0.558067)
= -0.352671
K3 = hf(xo + h/2, Yo + K2/2)
= 0.25f(1.125, 0.541946)
= -0.356701
K4 = hf(xo + h, Yo + K 3)
= 0.25f(1.25, 0.361581)
= -0.378355
Yl = Yo + (K1 + 2K2 + 2K3 + K4)/6
= 0.3653606
K 1 = hf(Xl, Yl)
= 0.25f(1.25, 0.3653606)
= -0.377410
K2 = hf(Xl + h/2, Yl + KI/2)
= 0.25f(1.375, 0.176656)
= -0.385524
349
15. ECUACIONES DIFERENCIALES
Xi I Y(Xi) Y(Xi)
1.00 0.7182818 0.7182818
1.25 0.3653606 0.3653430
1.50 -0.0182773 -0.0183109
1.75 -0.3703514 -0.3703973
2.00 -0.6108932 -0.6109439
2.25 -0.6372210 -0.6372642
2.50 -0.3174905 -0.3175060
2.75 0.5175891 0.5176319
3.00 2.0853898 2.0855369
-1 +I~~~---'--~~~~~~--.~~~~~~-----r-
1 2 3
Figura 15.7 Método de Runge-Kutta 4.
En este ejemplo, los resultados son aún mejores. Hubo que evaluar
32 veces la función ¡(x, y), 4 veces en cada iteración. Si se trabaja con
h = 0.1 se obtiene y(3) = 2.0855314; con h = 0.01 se obtiene y(3)
2.0855369; con h = 0.001 se obtiene y(3) = 2.0855369. <>
350
15.5. DEDUCCiÓN DE RK2
K 1 = hf(Xi, Yi)
K 2 = hf(Xi + 0'.2 h , Yi + /321 K t)
Yi+l = Yi + RI K l + R2 K 2.
Como hay un solo coeficiente O'. y un solo coeficiente /3, utilicémoslos sin
subíndices:
Kl = hf(Xi, Yi)
K2 = hf(Xi + O'.h, Yi + /3K 1)
Yi+1 = Yi + RI K l + R 2K 2.
h2
Y(Xi + h) = y(xd + hy'(Xi) + 2 Y"(Xi) + O(h3 ) (15.10)
h2
Y(Xi + h) ~ Y(Xi) + hy'(Xi) + 2 y"(Xi). (15.11)
351
15. ECUACIONES DIFERENCIALES
f := f(Xi, Yi)
af
fx := ax f(Xi, Yi)
af
fy := ay f(Xi, Yi)
y := Y(Xi)
y' := y'(Xi) = f(Xi, Yi) = f
y" := y"(Xi).
Entonces
y" = fx + ffy
h2 h2
Y(Xi + h) ';:::;, y + hf + 2" fx + 2" f fy· (15.12)
352
15.6. CONTROL DEL PASO
Rl + R2 = 1,
1
R2 a = -
2'
1
R2/3 -- -2'
Entonces
/3 = a, (15.14)
1
R2=-' (15.15)
2a
Rl = 1- R2· (15.16)
353
15. ECUACIONES DIFERENCIALES
lerrorl ~ e = /'PI(YA,YB,h,p).
354
15.6. CONTROL DEL PASO
Di f3i1 f3i2
1 1
2 - -
4 4
3 3 9
3 -
8 32 32
12 1932 7200 7296
4
13 2197 2197 2197
439 3680 845
5 1 -8 ---
216 513 4104
1 8 3544 1859 11
6 - 2 ---
2 27 2565 4104 40
_. 25 K 1408 2197 _ ~
YA-Yt+216K1+0 2+ 2565K3+ 4104 K4 5 K5
-. 16 K OK 6656 K 28561 K - ~K ~K
YB - Yt + 135 1 + 2 + 12825 3 + 56430 4 50 5 + 55 6
(15.17)
IYA -YBI
Ierror I ;::::j e = h . (15.18)
Co = 0.84 ( ~
E) 1/4 ,
C = min{Co,4}, (15.19)
C = max{C,O.l}.
Las fórmulas anteriores buscan que C no sea muy grande ni muy pe-
queño. Más específicamente, C debe estar en el intervalo [0.1, 4].
355
15. ECUACIONES DIFERENCIALES
u [u; t]
MÉTODO RUNGE-KUTTA-FEHLBERG
datos: xo, Yo, b, ho, é, hmin
x = xo, Y = Yo, h = ho
X = [xo], Y = [Yo]
mientras x < b
h=min{h,b-x}
hbien = O
mientras hbien = O
calcular Ya, YB según (15.17)
e = IYA - YBI/h
si e ~ é
X = X + h, Y = YB
bienh = 1
X = [X; x], Y = [Y; y]
fin-si
Co = O.84(é/e)1/4
C = max{Co,O.l}, C = min{C,4}
h=Ch
si h < hmin ent parar
fin-mientras
fin-mientras
_J_1-K _
e- 360 1
128
4275 K3
_ 2197 K4
75240 +
~K
50 5 +
~ K6
55
J
356
15.6. CONTROL DEL PASO
y' = 2x 2 - 4x +Y
y(1) = 0.7182818
YA = -0.01834063
YB = -0.01830704
e = 0.00006717
h = 0.5 no sirve.
eo = 0.29341805
e= 0.29341805
h = 0.14670902
YA = 0.51793321
YB = 0.51793329
e = 0.00000057
h = 0.14670902 sirve.
x = 1.14670902
Y = 0.51793329
eo = 0.96535578
e = 0.96535578
h = 0.14162640
YA = 0.30712817
YB = 0.30712821
e = 0.00000029
357
15. ECUACIONES DIFERENCIALES
h = 0.14162640 sirve.
x = 1. 28833543
Y = 0.30712821
x
-- -- -
h - -
y(x)
-
¡ -
y(x)
-
1
358
15.7. ORDEN DEL MÉTODO Y ORDEN DEL ERROR
-1 +------,----------;r-------~-
1 2 3
Figura 15.8 Método de Runge-Kutta-Fehlberg.
Para algunos de los métodos hasta ahora vistos, todos son métodos
de RK, se ha hablado del orden del método, del orden del error local y
del orden del error global.
El orden del método se refiere al número de evaluaciones de la función
f en cada iteración. Así por ejemplo, el método de Euler es un método
de orden 1 y el método de Heun es un método de orden 2.
El orden del error local se refiere al exponente de h en el error teórico
cometido en cada iteración. Si la fórmula es
359
15. ECUACIONES DIFERENCIALES
360
15.7. ORDEN DEL MÉTODO Y ORDEN DEL ERROR
y' = 2x 24x + Y
-
y(l) = 0.7182818,
-5
•
-6 •
•
•
-7 •
•
-8 '--_ _-'--_ _ - - L_ _----'_ __
361
15. ECUACIONES DIFERENCIALES
1
P2(X) = 2h 2 (Uo - 2fr + 12)x2 + (-3Jo + 4fr - 12)hx + 2h 2Jo).
¡X2
X3
Y(X3) = Y(X2) + ¡ X3
Xz
y'(x)dx
Y(X3) = Y(X2) + ¡ 3h
2h
J(x, y)dx.
362
15.8. MÉTODOS MULTlPASO EXPLÍCITOS
2
(-3fo + 4ft - 12)hx + 2h fo )dX
1 ( 19 h 3
Y3 = Y2 + 2h 2 (Jo - 2ft + 12)3 +
(-3fo + 4ft - 5h
12 ) 2 3+ 2h3)
fo
h
Y3 = Y2 + 12 (5fo - 16ft + 2312) (15.21)
h 3
Y(X3) = Y(X2) + 12 (5fo - 16h + 2312) + "B y (3) (z)h 4 , Z E [xo, X3]'
(15.22)
h
Yi+l = Yi + 12 (5fi-2 - 16fi-l + 23fi). (15.23)
363
15. ECUACIONES DIFERENCIALES
2, la ecuación diferencial
y' = 2x 2 - 4x + Y
y(l) = 0.7182818
YI = 0.3653606
Y2 = -0.0182773.
Entonces
Xi I Y(Xi) Y(Xi)
1.00 0.7182818 0.7182818
1.25 0.3653606 0.3653430
1.50 -0.0182773 -0.0183109
1.75 -0.3760843 -0.3703973
2.00 -0.6267238 -0.6109439
2.25 -0.6681548 -0.6372642
2.50 -0.3706632 -0.3175060
2.75 0.4320786 0.5176319
3.00 1.9534879 2.0855369
364
15.8. MÉTODOS MULTIPASO EXPLÍCITOS
-1 +-----~------------~----------~---
1 2 3
Figura 15.10 Método de Adams-Bashforth 2.
En este caso hubo que evaluar 8 veces la función para los dos valores
de RK4 y en seguida 6 evaluaciones para un total de 14 evaluaciones de
la función f. <>
error
h
1 Yi+l = Yi + 2"( -/i-l + 3fi) 152y"'(~)h3
h
2 Yi+l = Yi + 12 (5/i-2 - 16/i-l + 23/i) iy(4)(~)h4
h
3 Yi+1 = Yi + 24 (-9/i-3 + 37/i-2 - 59fi-l + 55/i) ~~~y(5)(~)h5
h
4 Yi+l = Yi + 720 (251/i-4 - 1274/i-3 + 2616fi-2 is5sy(6) (~)h6
-2774/i-l + 1901fi)
365
15. ECUACIONES DIFERENCIALES
¡Xl
X2
y'(x)dx
¡2h
Y(X2) = Y(Xl) + lh f(x, y)dx.
¡2h
Y(X2) ~ Y(Xl) + lh P2(x)dx
¡2h 1 (
Y(X2) ~ Y(Xl) + lh 2h 2 (Jo - 2ft + h)x 2+
366
15.9. MÉTODOS MULTIPASO IMPLÍCITOS
367
15. ECUACIONES DIFERENCIALES
y' = 2x 2 - 4x +Y
y(l) = 0.7182818
en el intervalo [1,3]' con h = 0.25 Y E = 0.0001.
Al aplicar el método RK4 una vez, se obtiene:
Yl = 0.3653606
Entonces
y~ = -0.0120493
J~ = -1.5120493
y~ = -0.0170487
Ji = -1.5170487
y~ = -0.0175694
Ji = -1.5175694
y~ = -0.0176237 = Y2
JI = -1.5096394
12 = -1.5176237.
368
15.9. MÉTODOS MULTIPASO IMPLÍCITOS
y~ = -0.3970296
j~ = -1.2720296
Y5 = -0.3716132
jj = -1.2466132
y~ = -0.3689657
jj = -1.2439657
y~ = -0.3686899
j1 = -1.2436899
yj = -0.3686612 = Y3
369
15. ECUACIONES DIFERENCIALES
-1 +I------~------------~----------_,---
1 2 3
Figura 15.11 Método de Adams-Moulton 2.
r:l
-
h
error
-l2y"(~)h3 I
1 Yi+1 = Yi + 2(Ji + fi+l)
h
2 Yi+l = Yi + 12 (- fi-l + 81i + 5fi+l) -214y(3)(~)h4
h
3 Yi+l = Yi + 24 (Ji-2 - 5fi-l + 19fi + 9fi+¡) - /ioy(4) (Oh 5
h
4 Yi+l = Yi + 720 (-19fi-3 + 1061i-2 - 264fi-l -1¡¡oy(5)(~)h6
+646fi + 25 1fi+l)
-- ---
-
370
15.10. SISTEMAS DE ECUACIONES DIFERENCIALES
Yl(XO) = y~
Y2(XO) = y~
371
15. ECUACIONES DIFERENCIALES
Yi = (Y1'
i i
Y2' i )
... , Ym ,
K 1 = hf(Xi, yi)
K 2 = hf(Xi + h/2, yi + K 1/2)
K3 = hf(Xi + h/2, yi + K2/2) (15.28)
K4= hf(Xi + h, yi + K 3 )
yi+1 = yi + (K 1 + 2K 2 + 2K3 + K4)/6.
Ejemplo 15.9. Resolver el siguiente sistema de ecuaciones por RK4:
2Y1 3
Y1 = - x + X Y2, 1 <
f
- x <
- 2
f 3
Y2 = --Y2
x
Y1(1) = -1
Y2(1) = 1
con h = 0.2.
La solución (exacta) de este sencillo sistema de ecuaciones es:
Y1(X) = -x
Y2(X) = x- 3 .
372
15.11. ECUACIONES DIFERENCIALES DE ORDEN SUPERIOR
K 1 = (-0.2, -0.6)
K 2 = (-0.2136600, -0.3818182)
K 3 = (-0.1871036, -0.4413223)
K4 = (-0.2026222, -0.2793388)
yl = (-1.2006916, 0.5790634)
K1 = (-0.2001062, -0.2895317)
2
K = (-0.2093988, -0.2004450)
K 3 = (-0.1912561, -0.2210035)
K 4 = (-0.2011961, -0.1534542)
y2 = (-1.4011269, 0.3647495)
373
15. ECUACIONES DIFERENCIALES
y (m) -- f( X,y,y,y,
,,, ... ,y (m-l)) , Xo :S X :S b
y(XO) = Yo
y'(XO) = yb
Y"()
Xo = Yo "
(m-l)( ) _ (m-l)
Y Xo - YO .
Esta ecuación diferencial se puede convertir en un sistema de ecuaciones
diferenciales de primer orden, mediante el siguiente cambio de variables:
Ul = Y
U2 = y'
U3 = Y"
U
m
= y(m-l)
,
um-l = Um
u~ = f(x, Ul, U2, ... , u m )
Ul(XO) = Yo
U2(XO) = yb
U3(XO) = y~
(m-l)
Um (Xo) = Yo .
De forma más compacta,
u' = F(x, u), xo:S x :S b
u(xo) = /'i,O,
374
15.11. ECUACIONES DIFERENCIALES DE ORDEN SUPERIOR
donde /\'0 = [Yo Yó yg ... y~m-l)lT. Este sistema se puede resolver por
los métodos para sistemas de ecuaciones diferenciales de primer orden.
" 4y - xy/
=
Y
x
2 ' 1::; x ::; 2,
y(l) = 3
y'(l) = 10,
/
Ul = U2
/ 4Ul - XU2
u2 = 2 ,1 ::; x ::; 2,
x
ul(1)=3
u2(1) = 10.
K 1 = (2, 0.4)
K 2 = (2.04, 0.7900826)
K 3 = (2.0790083, 0.7678437)
K 4 = (2.1535687, 1.0270306)
u1 = (5.0652642, 10.7571472)
375
15. ECUACIONES DIFERENCIALES
y(b) = Y(b,y~).
376
15.12. ECUACIONES DIFERENCIALES CON CONDICIONES DE FRONTERA
v = aproximación de y~,
n = número de intervalos para la solución numérica,
y = (Yo, YI, ... , Yn) = solución numérica del siguiente problema:
377
15. ECUACIONES DIFERENCIALES
Y5 = 0.94935663.
'Po = 0.03609310
VI = 1.19206278 + 0.03609310/(0.7 - 0.5) = 1.26424897
Y5 = 0.95337713
'PI = 0.03207260
V2 = 1.84009748
Y5 = 0.98544973
Este disparo fue preciso (no siempre se obtiene la solución con una sola
iteración de la secante). El último vector y es la solución. La solución
exacta es y = sen(2x).
378
15.13. ECUACIONES LINEALES CON CONDICIONES DE FRONTERA
I Xi I
0.2 0.3894183 0.3894183
0.3 0.5647741 0.5646425
0.4 0.7174439 0.7173561
0.5 0.8415217 0.8414710
0.6 0.9320614 0.9320391
0.7 0.9854497 0.9854497
Entonces:
i = 1, ... , n-1.
379
15. ECUACIONES DIFERENCIALES
2
2 Yi-1 - 2y~ + Yi+1 h -Yi-1 + Yi+1 2h2riYi 2h Si
Pi 2h2 + q~ + 2h2 2h2 2h2
2
(2Pi - hqi)Yi-1 + (-4Pi + 2h2ri)Yi + (2pi + hqi)Yi+1 = 2h s i
d1 U1 Y1 {31
h d2 U2 Y2 {32
l2 d 3 U3 Y3 {33
, (15.32)
donde
380
15.13. ECUACIONES LINEALES CON CONDICIONES DE FRONTERA
d¡ = -4p¡ + 2h2r¡
d¡ = -4(0.3)2 + 2(0.1)24(0.3)2 = -0.3528
u¡ = 2p¡ + hq¡
u¡ = 2(0.3)2 + 0.1(1) = 0.28
l¡ = 2P2 - hq2
l¡ = 2(0.4)2 - 0.1(1) = 0.22
d = (-0.3528, -0.6272, -0.98, -1.4112),
u = (0.28, 0.42, 0.6),
l = (0.22, 0.4, 0.62),
f3 = (0.00186, 0.0278683, 0.0216121, -0.7935745).
Su solución es
I Xi I
0.2 0.3894183 0.3894183
0.3 0.5628333 0.5646425
0.4 0.7158127 0.7173561 <>
0.5 0.8404825 0.8414710
0.6 0.9315998 0.9320391
0.7 0.9854497 0.9854497
Ejercicios
381
15. ECUACIONES DIFERENCIALES
y~ = 2Yl + Y2 + 3
y~ = 4Yl - Y2 + 9
Yl(O) = -3
Y2(0) = 5.
Su solución es Yl(t) = _e- 2t - 2, Y2(t) = 4e- 2t + 1.
15.3
y" = 2 ,
x(2 -x) Y
y(l) = -2
y'(l) = 1.
382
l5.l3. ECUACIONES LINEALES CON CONDICIONES DE FRONTERA
15.5
Su solución es y = eX + sen(x).
15.6
Su solución es y = eX + sen(x).
383
l5.l3. ECUACIONES LINEALES CON CONDICIONES DE FRONTERA
15.5
Su solución es y = eX + sen(x).
15.6
Su solución es y = eX + sen(x).
383
Bibliografía
385
BIBLIOGRAFÍA
[DeD99] Deitel H.M. y Deitel P.J., e++, cómo programar, Prentice Hall
Hispanoamericana, México, 1999.
[LIH01] Liberty Jesse y Horvath David B., Aprendiendo e++ para Li-
nux en 21 días, Prentice Hall, Pearson, México, 2001.
[NoD88] Noble Ben y Daniel James W., Applied Linear Algebra 3rd ed.,
Prentice Hall, Englewood Cliffs, 1988.
386
BIBLIOGRAFÍA
387
BIBLIOGRAFÍA
387
Apéndice A
Estilo en e
Para que la lectura de un programa en e sea más fácil para el mismo
programador o para otros lectores, es conveniente tener ciertas reglas
sobre la manera de escribir, de hacer sangrías, de separar las funciones,
etc. Esta reglas no son absolutamente fijas y cada programador establece
su propio estilo. Hay unos estilos que son más claros y dicientes que
otros. Algunos son ventajosos en ciertos aspectos y desventajosos en
otros. Otros son diferentes pero comparables. Algunas "reglas" son más
universales y populares que otras.
A.l Generalidades
• El corchete { de inicio del cuerpo de una función debe ir en la
primera columna y no debe haber nada más en la línea.
El corchete } de finalización de una función debe ir en la primera
columna y no debe haber nada más en la línea. Si se desea escri-
bir un comentario, éste se puede colocar en la línea anterior. Por
ejemplo:
389
APÉNDICE A. ESTILO EN C
II fin de factorial
}
fore i ... ){
whileC ... ){
for( j ... ){
} II fin while
} II fin i
390
A.l. GENERALIDADES
• Utilizar una línea para cada una de las variables importantes, co-
locando un comentario explicativo. Por ejemplo,
int i, j, k;
double templ, temp2;
• Separar de manera clara las funciones entre sí, por ejemplo con
una línea como
11----------------------------------------------------
• Dejar un espacio después de cada coma, por ejemplo,
int i, j, k;
x = maximo(a, b, c, d);
a = b+3;
d += a;
391
APÉNDICE A. ESTILO EN C
pe no es muy diciente
peso_esp puede ser
pesoEsp puede ser
392
A.2. EJEMPLO
A.2 Ejemplo
#define N 20
#define
11================================================
int main(void)
{
int i, j, k;
double x, y;
fore. .. ){
fore. .. ){
if e. .. ){
}
else{
393
APÉNDICE A. ESTILO EN C
if( ... H
}
}
}
}
11================================================
void funcionl( ... )
{
II comentarios
II mas comentarios
int m, n;
float u; II indica ...
11------------------------------------------------
double funcion2( ...
{
II comentarios
II mas comentarios
int i, j;
double x; II x indica .. .
double zz; II indica .. .
394
A.3. ESTRUCTURAS DE CONTROL
}
el se {
i f ( ... ) ...
else ... ;
if ( ){
}
else ...
if ( ){
395
APÉNDICE A. ESTILO EN C
for( ... ) {
while( ... ) {
do {
} while ( ... );
switch( i ) {
case 1:
break;
case 4:
396
A.3. ESTRUCTURAS DE CONTROL
break;
case 8: case 9:
break;
default:
397
,
Indice analítico
11,45 %e, 31
&, 31, 78, 79, 109 %f,31
&&, 45 %i, 31
'\0',98 %lf,31
(double), 36 %p, 31, 110
(float), 36 %s, 31, 99
(int),36 %u, 31
*, 22, 78, 109 \n, 7
**, 116 a, 145
*=, 27 abreviaciones, 26
+, 22
acos, 29
++, 22, 23
Adams-Bashforth
+=, 27 fórmula de, 363
-, 22, 23 Adams-Moulton
--, 22, 24 fórmula de, 367
-=, 27 adición, 22
/,22 algoritmo
/=, 27 de Euclides, 54
<,45 alloc.h,85
«, 8 ámbito
<=, 45 global, 82
=, 21 local, 82
==, 45 ANSI e, 70
>, 45 aproximación, 285
>=, 45 aproximación por mínimos cua-
», 33 drados, 306
?, 171, 173 apuntador, 78
%, 22, 23 apuntadores, 109
%c, 31 a apuntadores, 116
%d, 31 a estructuras, 177, 180
398
ÍNDICE ANALÍTICO
399
ÍNDICE ANALÍTICO
coseno, 53 %e, 31
cosh, 29 ecuación cuadrática, 43
cout, 8, 33 ecuaciones
ctype.h,85 diferenciales ordinarias, 337
cuadratura ecuaciones diferenciales
de Gauss, 326 con condiciones de frontera,
de Gauss-Legendre, véase cua- 376
dratura de Gauss de orden superior, 373
cuerpo de una función, 69 lineales con condiciones de
frontera, 379
%d, 31 sistemas de, 371
decremento, 24 ecuaciones normales, 247
default, 17 else, 17, 41
#define, 164 encadenamiento, 6
delete, 17, 132 endl, 8
densidad, 254 enlace, 6
derivación entrada de datos, 30
numérica, 332 enum, 17
derivadas parciales, 246 EOF, 34, 148
desviación estándar, 148 errno.h,85
determinante, 229 error, 331
diagonal estrictamente dominan- de compilación, 5
te por filas, 242 de ejecución, 6
diferencias global, 317, 318, 320, 323,
divididas de Newton, 293 339
finitas, 302 orden del, 359
diferencias finitas, 379 local, 317, 320, 339
diferente, 45 método de Euler, 360
distancia entre dos vectores, 183 método de Heun, 360
división, 22 método del punto medio,
entre enteros, 23 360
sintética, 134 método RK4, 360
do, 17 método RK5, 360
do while, 54, 58, 60 método RK6, 360
doble precisión, 19 orden del, 359
double, 17, 19, 20, 31, 35, 158 método de Euler, 339
double( ),37 orden del, 359
(double), 36 escritura
400
ÍNDICE ANALÍTICO
401
ÍNDICE ANALÍTICO
402
ÍNDICE ANALÍTICO
403
ÍNDICE ANALÍTICO
RK6,360 prototipo, 68
orden de convergencia, 262, 264 public, 17
ordenamiento, 194 punteros, véase apuntadores
overflow, 75 punto flotante, 19
punto medio
%p, 31, 110 método del, 344, 348
palabra clave, 16 orden del método de, 360
parámetro, 68
por defecto, 81 r,145
por referencia, 76-78, 88 r+, 145
por valor, 76, 77 RAND_MAX, 130
pausa, 70 randO, 130
pivote, 217 Raphson, véase método de Newton-
pivoteo Raphson
parcial, 217 register,17
total, 218 residuo entero, 23
polinomios return,17
de Legendre, 331 RK, véase método de Runge-Kutta
polinomios de Lagrange, 290 RK4, véase método RK4
pow, 29 RKF, véase Runge-Kutta-Fehlberg
precedencia de los operadores Runge-Kutta
aritméticos, 24 método de, 347
precisión Runge-K u tta-Fehlberg
doble, 19 método de, 354, 356
sencilla, 19
printf, 7 %s, 31, 99
prioridad de los operadores arit- salida de resultados, 30
méticos, 24 scanf, 30, 34
private,17 Scilab, 200
producto Seidel, véase método de Gauss-
de complejos, 177, 180 Seidel
de matrices, 94, 97, 117, 120- serie de Taylor, 51, 53
123, 125, 128, 129 seudosolución, 248
escalar, 126, 128, 183 short, 17
programa short int, 35, 158
ejecutable, 6 signed, 17
fuente, 5 sin, 29
promedio, 89, 91, 113, 115, 148 sinh, 29
protected,17 sistema
404
ÍNDICE ANALÍTICO
tabla
de diferencias divididas, 296
de diferencias finitas, 302
tan, 29
tanh, 29
tasa de convergencia, 262
template, 17
this, 17
405
Introducción a e
y a métodos numéricos
SE TERMINÓ DE IMPRIMIR
EN BOGOTÁ EL MES DE
ABRIL DE 2004 EN LAS
PRENSAS EDITORIALES DE
UNIBIBLOS, UNIVERSIDAD
NACIONAL DE COLOMBIA