Manual Metodos Numericos

UNIVERSIDAD AUTNOMA DE CHIAPAS
FACULTAD DE INGENIERA
INGENIERA CIVIL
APUNTES DE
MTODOS NUMRICOS
2da Edicin
APUNTES DE
MTODOS NUMRICOS
No busques ser una persona de xito,
busca ser una persona de valores...
Albert Einstein.
Rubn Herrera Galicia

Frida Carolina Villalobos Rivas
Heri Jacob Villar Snchez
I.
Solucin numrica de ecuaciones de una variable

1. Mtodo de Biseccin .4
2. Mtodo de Newton Raphson ...11
3. Mtodo de Lin Bairstow ..18
II.
Solucin numrica de sistemas de ecuaciones lineales y no lineales

4. Mtodo de Jacobi: Sistemas de ecuaciones no lineales ..29
5. Mtodo de Gauss-Seidel ..52
6. Mtodo de Newton: Sistemas de ecuaciones no lineales 72
III.
Interpolacin, derivacin e integracin numrica

7. Interpolacin de Newton y Lagrange ..83
8. Derivacin numrica ...97
Primera derivada
( )
Segunda derivada
( )
9. Integracin numrica .109

Mtodo del trapecio
Mtodo de Simpson 1/3
IV.
Solucin numrica de ecuaciones diferenciales ordinarias

10. Mtodo de Euler y Euler mejorado .117
11. Mtodo de Runge-Kutta (Euler modificado) ..126
12. Mtodo de la Serie de Taylor .132
V.
Solucin numrica de ecuaciones en derivadas parciales

13. Mtodo de diferencias finitas .138

1.- Mtodo de Biseccin
()
( )
( )
Algoritmo
1. Escoger los valores
del intervalo.
] , verificando que
2. Comprobar la existencia de una raz en el intervalo [
( ) ( )
de no ser as, ser necesario regresar al paso 1 y escoger otros valores para
3. Tomar
y calcular (
).
4. Si ( )
, se encontr la raz de la funcin. Fin del mtodo. De lo contrario ir al
paso 5.
5. Sea T la tolerancia deseada ( el margen de error aceptado), si:
se encontr una aproximacin a la raz con un margen de error menor a T. Fin del
mtodo. De lo contrario ir al paso 6.
6. Si ( ) ( )
, entonces hacer
y repetir desde 3. De lo contrario
hacer
y repetir desde 3.

En otras palabras:
El mtodo consiste en encontrar la raz de una funcin f(x) a partir de la biseccin de dos
aproximaciones hechas a la raz.
Sabiendo la grfica de la funcin facilita su uso,
de lo contrario hay que ser abusados, es por
eso que la funcin se evala con las
aproximaciones
y luego se multiplican
para ver que el producto sea negativo
( ( ) ( )
).
Con esto nos damos cuenta si la raz se
encuentra en el intervalo de las aproximaciones dadas. Porque si no estuviera en ese
intervalo el producto sera positivo, ya que el resultado de su evaluacin seria de signos
iguales ya sea ambos negativos o positivos y por lo tanto el intervalo no contendra a la
raz, y debemos buscar otros
.
( ) ( ) > , es positivo,
no contiene a la raz
( ) ( ) > , es positivo,
no contiene a la raz
Lo que el mtodo hace es ir acortando los intervalos, hasta que se hagan tan pequeos
que casi son la raz, y digo casi porque es una aproximacin a la raz, o hasta la tolerancia
que nosotros tengamos que ser casi igual a 0 ( ( )
).
2)
1)
3)

Programacin del mtodo.

Ahora que conocemos el mtodo, tendremos la habilidad de pasarlo a una maquina o
computadora, es decir crear una aplicacin. A continuacin se utilizar el programa
Builder c++ para la creacin de dicha aplicacin.
Interfaz propuesta:
Descripcin de los botones de la aplicacin:
Botn Calcular producto:

Captura los valores
del intervalo, evala la funcin en dichos puntos; calcula el
producto y muestra el resultado debajo de la etiqueta ( ) ( ) .
Botn Calcular raz:
Captura los valores
del intervalo y el margen de error aceptado; calcula el valor de
y evala la funcin en dicho punto. Si el resultado es igual a cero detiene el proceso y
muestra los resultados para
, ( ) debajo de la etiqueta correspondiente; de no ser
as contina el proceso calculando:

Si el resultado es menor al margen de error detiene el proceso y muestra los resultados;

de lo contrario contina, efectuando el producto:
( )
Si el resultado es menor que cero, asigna a

el valor de
(
). Si es mayor que
cero asigna a
el valor de
(
) y repite el proceso desde el clculo de
Botn Calcular paso a pasito:
Calcula la raz de la funcin paso a paso y muestra los valores obtenidos en cada uno; es
decir, captura los valores de
del intervalo y calcula:
, (
), ( )
),
mostrndolos debajo de su respectiva etiqueta. Cuenta el nmero de iteraciones, adems

de asignar un nuevo valor ha
para realizar las siguientes, dependiendo de la
condicin:
Si ( )
;(
Si ( )
)> ;(
Botn Reset:
Reinicia el nmero de iteraciones y borra los datos escritos en el formulario.

Cdigo de programacin:
//---------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
#include <math.h>
double x1,x2,y1,y2,prod,Tol,
aux,ym,xm,delta,i=1,n=1,dif;
TForm1 *Form1;
//---------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------//botn calcular producto
void __fastcall TForm1::Button1Click(TObject *Sender)
{
x1=Edit1->Text.ToDouble();
y1= x1*x1*x1-x1-1;
y2= x2*x2*x2-x2-1;
prod=y1*y2;
if(prod<0){
Label2->Caption=AnsiString(prod);}
else{
Label2->Caption="Escoja otros valores";}
}
//---------------------------//botn calcular raz
{

Tol=Edit3->Text.ToDouble();
aux=0;
while (aux!=1){
xm=(x1+x2)/2;
ym=xm*xm*xm-xm-1;
if(ym==0){aux=1;}
delta=fabs((x2-x1)/2);
if(delta<Tol){aux=1;}
y1= x1*x1*x1-x1-1;
prod=y1*ym;
if(prod<0){x2=xm;}
if(prod>0){x1=xm;}
}
Label4->Caption=AnsiString(xm);
Label5->Caption=AnsiString(ym);
}
//-------------------------------------------------//botn calcular paso a pasito
{
if(i==1){
x2=Edit2->Text.ToDouble();}
Label6->Caption=AnsiString(n);
Label7->Caption=AnsiString(x1);
xm=(x1+x2)/2;
ym=xm*xm*xm-xm-1;
y1= x1*x1*x1-x1-1;
prod=y1*ym;
dif=(x2-x1)/2;
Label9->Caption=AnsiString(xm);
Label10->Caption=AnsiString(ym);
Label11->Caption=AnsiString(prod);
Label12->Caption=AnsiString(dif);

if(prod<0){x2=xm;}
if(prod>0){x1=xm;}
n++;
i++;
}
//---------------------------//reset
{
i=1;
n=1;
Label6->Caption="";
Label7->Caption="";
Label8->Caption="";
Label9->Caption="";
Label10->Caption="";
}
//----------------------------
10

2.- Mtodo de Newton Raphson

Es un mtodo grfico para encontrar races de funciones, aplicando la propiedad de la
derivada:
El valor de la derivada en un punto es igual a la pendiente de la recta tangente que pasa
por ese punto.
Este mtodo se basa en la interpretacin geomtrica de la derivada para obtener la frmula
de la recurrencia:
()
( )
Pendiente = ( )
( )
Raz
Partiendo de una funcin (

(
) , cuya derivada es
)
) y recordando que:
Entonces tenemos lo siguiente:

( )
( )

11

Despejando
en la ecuacin, obtenemos:
( )
( )
Que es conocida como la frmula de Newton-Raphson.

Geomtricamente lo que est pasando con este mtodo es que al calcular la derivada con
un punto dado, est pendiente al cortar con el eje x nos da un nuevo punto
el cual est
cada vez ms cerca de la raz, y este nuevo nos da otro valor que est mucho ms prximo
que el anterior, y as sucesivamente hasta acercarse a la raz o hasta que la deferencia sea
cercana a cero.
La frmula se
vuelve a realizar
otra vez, cada vez
se acerca ms a la
raz, por eso se
llama de
recurrencia.
Si observamos en la grfica
se van formando como una
especie de zigzag, donde las
aproximaciones son cada
vez menores y se acercan a
la raz.
Casos especiales
( )
, cuando suceda esto quiere decir que se encontr a la raz, aunque claro
mayormente es un nmero aproximado a cero.
( )
b)
, cuando suceda esto, debemos escoger otro valor para
para poder aplicar la
formula, ya que no es posible la divisin entre cero.
c) El circulo vicioso, es cuando la derivada nos manda de nuevo al mismo lugar, es decir
caemos en un crculo vicioso y nunca encontrar la raz, porque esta no corta al eje de las x.
|>|
|
d) Divergencia aparente, cuando
,|
a)
En la grfica observamos el
caso del crculo vicioso, al
cual no tendremos una
solucin por este mtodo,
hay que evitar caer en l.
12

Programacin del mtodo

Interfaz propuesta
Acciones por botn

Botn Calcular raz:
Lee los valores para
y tolerancia, calcula ( ): si ( )
detiene el proceso, pues
significa que se encontr la raz, si ( )
contina el proceso calculando ( ). Si
( )
detiene el proceso al tratarse de un punto crtico (mximo o mnimo de la
funcin). Si
( )
contina calculando
y sumando 1 al contador de
iteraciones.
Dentro de una estructura de repeticin while calcula ( ) y
condiciones: detener el proceso si un resultado es igual a cero.
Si el proceso continu, calcula:
( ) con las mismas
| y
| ;
compara estos ltimos y acta de acuerdo a las siguientes condiciones:
Si
, imprime el mensaje: Crculo Vicioso. Seleccione otro valor de x1. y
detiene el proceso.
13

Si
> , imprime el mensaje: El mtodo diverge aparentemente. Seleccione
otro valor de x. y detiene el proceso.
Si
>
y
> , calcula ( ). Imprime , ( ) debajo de la etiqueta
correspondiente y el mensaje Raz aproximada. Detiene el proceso.
En caso de no cumplirse ninguna condicin, reasigna valores a las variables:

y
y reinicia el bucle hasta encontrar la raz o hasta que se cumpla alguna condicin
de las arriba mencionadas.
Botn Reset:
Borra los datos escritos en el formulario y reinicia el contador de iteraciones y la variable
auxiliar. Posiciona el puntero en el primer Edit.
14

Cdigo de programacin
//---------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------#pragma package(smart_init)
#include <math.h>
double x1,Tol,n=0,m=0,y1,dy1,x2,y2,dy2,x3,y3,s1,s2;
TForm1 *Form1;
//---------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------//botn calcular raz
{
y1=x1*x1*x1-x1-1;
if(y1==0){
Label4->Caption=AnsiString(y1);
m=1;}
else{
dy1=3*x1*x1-1;
if(dy1==0){
Label5->Caption="x1 es un punto crtico. Seleccione otro valor
de x1.";
m=1;}
else{
x2=x1-(y1/dy1);
n++;}
}
15

while(m!=1){
y2=x2*x2*x2-x2-1;
if(y2==0){
m=1;}
else{
dy2=3*x2*x2-1;
if(dy2==0){
Label5->Caption="x2 es un punto crtico. Seleccione otro valor
de x1.";
m=1;}
else{
x3=x2-(y2/dy2);
n++;
s1= fabs(x2-x1);
s2= fabs(x3-x2);
if(s1==s2){
Label5->Caption="Crculo Vicioso. Seleccione otro valor de
x1.";
m=1;}
else if(s2>s1){
Label5->Caption="El mtodo diverge aparentemente.
Seleccione otro valor de x.";
m=1;}
else if (s2<s1&&Tol>s2){
y3=x3*x3*x3-x3-1;
Label5->Caption="Raz aproximada.";
m=1;}
else{
x1=x2;
x2=x3;}
}
}
}
Label6->Caption = "Iteraciones +AnsiString(n);
}
//----------------------------
16

//botn reset
{
Label3->Caption="";
Label4->Caption="";
Label5->Caption="Observaciones...";
Label6->Caption="";
Edit1->Text="";
Edit1->SetFocus();
Edit2->Text="";
n=0;
m=0;
}
//---------------------------------------------------------------
De esta forma es como se programara la aplicacin en lenguaje c++.
17

3.- Mtodo de Lin-Bairstow

Este mtodo se usa para encontrar races de ecuaciones, tanto reales como imaginarias.
Se apoya en la factorizacin numrica, encontrando races por pares, para polinomios de
tipo:
( )
Consideraremos ahora este polinomio de grado

( )
( )
La idea es factorizar al polinomio ( ) y dejarlo de la siguiente forma

( )
+ )(
)+
( )
Se habr factorizado el polinomio numricamente cuando

y
sean ceros o
cercanos a cero. Y entonces los factores de
+ ( ) + sern las races del polinomio
los cuales se obtienen mediante la frmula general.
Al hacer el producto del polinomio (2) tenemos
( )
+
+
Al hacer el producto
nos da trminos
semejantes, son los
que se sealan con
una flecha.
(Residuo)
18

Se igualan los coeficientes de ambas funciones (1) y (2), ya que son iguales y tenemos
+
+
+
Donde se observa la siguiente regla:
+
Con excepcin de
Ahora despejamos a b en cada una
La condicin para
que el polinomio sea
factorizable es que
La condicin para la factorizacin del polinomio es que

lo tanto:
sean iguales a cero, por
( )
( )
Despejando a p de la ecuacin (3) y a q de la ecuacin (2)
( )
( )
Donde
19

Para definir el error tenemos las siguientes ecuaciones

Dr. Herrera:
Valor
inicial
A partir de aqu
todas las frmulas
las anex yo
porque en el
anterior no estaban
todas
Valor recin
Sustituyendo la ecuacin (5) en el valor de p recin calculado, tenemos
( )
Si corremos raya del lado derecho nos damos cuenta que el trmino es semejante a
El numerador es
igual a
Sustituyendo en la ecuacin a
y despejando a
tenemos la siguiente frmula:
( )
De la misma manera con la ecuacin (6) al realizar lo anterior llegamos a la siguiente

frmula:
( )
Las cuales son las frmulas que usar este mtodo para calcular los nuevos valores que
deben tomar p y q para que el polinomio pueda ser factorizable y de esta manera encontrar
las races buscadas del polinomio.
La ventaja que tiene este mtodo es que podemos encontrar las races tanto reales como
imaginarias del polinomio, esto se puede conocer mediante la aplicacin de la frmula
general a los valores para los cuales es factorizable la funcin ( ) en el polinomio
cuadrtico ( +
+ )
Se puede decir que:
Polinomio de orden
n
Funcin
Polinomio de orden n-2
Residu
Par de races
20

Algoritmo:
Hacer
y leer
.
Calcular:

Checar
No
Si
Calcular
Nanchy
Checar que
|
|
|
|
No
Hacer
Si
Text
Estos son los pasos a seguir del mtodo de Lin-bairstow, el cual nos es til para conocer las
races imaginarias de un polinomio si es que las contiene.
Cabe recordar que las races imaginarias siempre vienen dadas por parejas ya que existe el
conjugado por cada raz imaginaria encontrada.
Est adaptado para un polinomio de grado n=5, para otros polinomios se usan hasta
21

Programacin
Interfaz grfica propuesta:
Programacin por botn:

Botn Paso a pasito:
, la tolerancia, y si se requiere, tambin de y ,
de lo contrario su valor inicial es cero. Calcula
y
con las frmulas
anteriormente mencionadas; si
es igual a cero muestra un mensaje advirtiendo que el
mtodo no funciona con el polinomio indicado, en caso contrario calcula los valores de
y
y los nuevos valores para y . Determina el valor absoluto de
y
y toma el
mayor de ellos como error y si ste es menor que la tolerancia establecida muestra un
mensaje en el formulario. Imprime
, el error y el nmero de
iteraciones del mtodo.
Botn De una patada:
, la tolerancia, y si se requiere, tambin de y ,
de lo contrario su valor inicial es cero. Dentro de una estructura de repeticin while
22

calcula
y ; si
es igual a cero imprime un mensaje advirtiendo que el
mtodo no funciona con el polinomio indicado y detiene el proceso, en caso contrario
contina calculando los valores de
y
y los nuevos valores para y . Determina el
valor absoluto de
y
y toma el mayor de ellos como error y si ste es menor que la
tolerancia establecida imprime un mensaje en el formulario y detiene el proceso, de lo
contrario inicia nuevamente los clculos, con los nuevos valores de y . Si el contador de
iteraciones es mayor que 200 muestra un mensaje advirtiendo que el mtodo no converge
para el polinomio indicado. Imprime
, el error y el nmero de
iteraciones del mtodo.
Botn Calcular races:
Calcula las dos primeras races del polinomio con la frmula general, utilizando los valores
de y como b y c, respectivamente, siendo a=1. Calcula el valor del discriminante y si
este es menor que cero, utiliza el valor absoluto y calcula la parte real y la parte imaginaria
de la raz, imprimindolas en el Edit correspondiente. De lo contrario, calcula las races
reales y las imprime en el Edit que corresponde.
Botn Reset:
Borra todos los datos escritos en el formulario y reinicia el contador de iteraciones y la
variable auxiliar. Posiciona el puntero en el puntero en el primer Edit.
23

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#include <math.h>
double a0,a1,a2,a3,a4,a5,b0,b1,b2,b3,b4,b5,p,q,Tol,deltap,deltaq,
p2,q2,error,m,i,k=0,d,rx1,rx2,ixr,ix;
TForm1 *Form1;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//paso a pasito
{
if(k==0){i=0;}
if(i==0)
{
a0=Edit1->Text.ToDouble();
if(CheckBox1->Checked==True){
p=Edit14->Text.ToDouble();
q=Edit15->Text.ToDouble();}
else{
p=0;
q=0;}
}
b0=a0;
b1=a1-p*b0;
24

b2=a2-p*b1-q*b0;
b3=a3-p*b2-q*b1;
b4=a4-p*b3-q*b2;
b5=a5-q*b3;
if(b3==0){
Label6->Caption="El mtodo no funciona para el polinomio
indicado.";}
else
{
deltap=(b4/b3);
deltaq=(b5/b3);
p2=deltap+p;
q2=deltaq+q;
deltap= fabs(deltap);
deltaq= fabs(deltaq);
if(deltap < deltaq){error=deltaq;}
else{error=deltap;}
if (error<Tol){
Label6->Caption="El error es menor a la tolerancia establecida.";}
p=p2;
q=q2;
}
Edit8->Text=AnsiString(b0);
Edit14->Text=AnsiString(p);
Edit15->Text=AnsiString(q);
Edit16->Text=AnsiString(error);
Label7->Caption="Iteraciones: "+AnsiString(i);
i++;
k++;
}
//---------------------------------------------------------------//de una patada
25

{
i=0;
m=0;
if(CheckBox1->Checked==True){
q=Edit15->Text.ToDouble();}
else{
p=0;
q=0;}
while(m!=1){
b0=a0;
b1=a1-p*b0;
b2=a2-p*b1-q*b0;
b3=a3-p*b2-q*b1;
b4=a4-p*b3-q*b2;
b5=a5-q*b3;
if(b3==0){
Label6->Caption="El mtodo no funciona para el polinomio
indicado.";
m=1;}
else{
deltap=(b4/b3);
deltaq=(b5/b3);
p2=deltap+p;
q2=deltaq+q;
deltap= fabs(deltap);
deltaq= fabs(deltaq);
if(deltap < deltaq){error=deltaq;}
else{error=deltap;}
if (error<Tol){
Label6->Caption="El error es menor a la tolerancia establecida.";
m=1;}
else{
p=p2;
q=q2;
i++;}
26

if(i>200){
Label6->Caption="El mtodo no converge para dicha funcin.";
m=1;}
}
}
Edit14->Text=AnsiString(p);
Edit15->Text=AnsiString(q);
Edit16->Text=AnsiString(error);
k=0;
}
//---------------------------------------------------------------//calcular races
{
q=Edit15->Text.ToDouble();
d=p*p-(4*q);
if(d>=0) {
rx1=(-p+(pow(d,0.5)))/2;
rx2=(-p-(pow(d,0.5)))/2;
Edit17->Text=AnsiString(rx1);
Edit18->Text=AnsiString(rx2);}
else{
d=fabs(d);
//parte real de la raz
ixr=-p/2;
//parte imaginaria de la raz
ix=(pow(d,0.5))/2;
Edit19->Text=FormatFloat("0.####",ixr)+ " + " +
FormatFloat("0.####",ix)+" i";
Edit20->Text=FormatFloat("0.####",ixr)+ " - " +
FormatFloat("0.####",ix)+" i";
27

}
}
//---------------------------------------------------------------//reset
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
Edit1->SetFocus();
CheckBox1->Checked=False;
Label7->Caption="Nmero de iteraciones.";
i=0;
k=0;
}
//----------------------------------------------------------------
28

4.- Mtodo de Jacobi
Este mtodo nos sirve para resolver ecuaciones lineales. Supongamos el siguiente sistema
de ecuaciones:
+
Este mtodo trata de calcular un nuevo valor para cada variable, tomando como base el
sistema de ecuaciones, para desarrollar las frmulas debemos despejar una variable por
cada ecuacin, con ellas obtendremos los nuevos valores
que nos acercaran a
las soluciones del sistema:
Las condiciones que se
deben cumplir son:
Para que se pueda desarrollar este mtodo, los coeficientes de la diagonal deben ser
distintos de cero:
A las ecuaciones anteriores tambin la podemos representar de la siguiente manera, es decir

le podemos dar la siguiente correspondencia:
29

Esta son las frmulas que usar este mtodo para calcular los nuevos valores de cada una de
las variables, esta accin se llevar a cabo hasta que lleguemos a la tolerancia o una
aproximacin cercana a cero. Para ello nos ayudamos en la siguiente frmula de error.
|
Donde el criterio de paro ser:

(
Convergencia del mtodo

Para que lleguemos a la solucin es indispensable que sea convergente, de lo contrario no
llegaremos al resultado deseado. Para saber si el sistema es convergente, lo debemos de
tomar como un tipo de matriz:
Si la matriz de coeficientes originales del sistema de ecuaciones es diagonalmente

dominante, es muy probable que el mtodo sea convergente para dicho sistema.
Una matriz se dice matriz diagonalmente dominante, si en cada uno de los renglones, el
valor absoluto del elemento de la diagonal principal es mayor que la suma de los valores
absolutos de los elementos restantes del mismo rengln.
30

A veces la matriz de un sistema de ecuaciones no es diagonalmente dominante pero

cuando se cambian el orden de las ecuaciones o las incgnitas el nuevo sistema puede tener
matriz de coeficientes diagonalmente dominante.
La matriz es fuertemente dominante si:
|
|>| |+|
|+|
| |> | |+| |+| |

| |>| |+| |+| |
|
|>|
|+|
|+|
Otra forma de especificarlo es de la siguiente manera:

| |+|
|
|+|
|
| |+| |+| |
| |
| |+| |+| |
| |
|
|+|
|
|+|
|
Calculando:
| |+|
|
|+|
|
| |+| |+| |
| |
| |+| |+| |
| |
|
|+|
|
|+|
|
Teniendo estas ecuaciones podemos saber si un sistema es fuerte o dbilmente dominante, o

en su defecto que sea aparentemente dominante o no dominante.
31

Recordemos que:
Reordenar el sistema y colocar en la diagonal los coeficientes de mayor valor absoluto,
ello puede hacer converger hacia la solucin
Ahora podemos decir lo siguiente de un sistema:
a).- Fuertemente dominante:
(
b).- Dbilmente dominante:

(
Donde
Esta son las condiciones que debe cumplir el sistema para que el mtodo pueda converger a
una raz o solucin del sistema, mientras el sistema sea convergente llegaremos a una
solucin, se pueden tomar distintas rutas, pero si todas convergen, entonces llegaremos a
una solucin.
Valores iniciales
De esta forma sabremos si el sistema converge a una solucin, de lo contrario el mtodo no

nos garantiza encontrar la solucin al sistema de ecuaciones.
32

Programacin:
Interfaz grfica propuesta
Interpretacin por botn:

Botn 2x2:
El formulario muestra por defecto un arreglo matricial de 4x4, al presionar el botn oculta y
reordena los Edits del formulario, de tal forma que se muestre slo un arreglo de 2x2;
oculta tambin todos los Edits relacionados con las variables que no forman parte del
sistema de ecuaciones.
Botn 3x3:
Oculta y reordena los Edits del formulario, de tal forma que se muestre slo un arreglo
matricial de 3x3; oculta tambin todos los Edits relacionados con las variables que no
forman parte del sistema de ecuaciones.
33

Botn 4x4:
Muestra y reordena todos los Edits del formulario, en la forma en que se encontraban
originalmente.
Botn Capturar/convergencia:
Para un arreglo de 4x4: Lee los datos de la matriz formada por el sistema de ecuaciones:
.
.
.
Comprueba que los elementos de la diagonal sean iguales a cero, si alguno cumple esa
condicin imprime una advertencia diciendo que los elementos de la diagonal principal
deben ser distintos de cero y desactiva los botones Calcular aproximacin y Calcular
paso a pas0. De lo contrario comprueba que la matriz sea dominante, comparando los
elementos de la diagonal con los dems:
Si el valor absoluto de cada elemento de la diagonal es mayor a la suma de los
valores absolutos de los dems elementos de la fila donde se encuentra, imprime un
mensaje diciendo que la matriz es fuertemente dominante.
Si el valor absoluto de uno o ms elementos de la diagonal es igual a la suma de los
valores absolutos de los dems elementos de la fila donde se encuentra, sin que
ninguno sea menor que dicha suma, imprime un mensaje diciendo que la matriz es
dbilmente dominante.
Si no cumple ninguna condicin quiere decir que no es una matriz dominante por lo
que es posible que el mtodo no sea convergente para la matriz en cuestin, por lo
que imprime un mensaje que advierte que no se garantiza la convergencia del
mtodo, y desactiva el botn Calcular aproximacin.
Por ltimo normaliza los coeficientes de las ecuaciones anteriormente mostradas, con los
datos necesarios, dependiendo del orden de la matriz.
Botn Calcular aproximacin:
Lee el valor de la tolerancia deseada y los valores iniciales de las variables a calcular,
dependiendo del orden de la matriz.
34

Para matrices de orden 4x4:

.
.
.
Dentro de una estructura de repeticin while :

Calcula nuevos valores para cada una con las ecuaciones anteriormente descritas y calcula
el error para cada una de ellas, restando el valor inicial al recin calculado. Compara los
valores absolutos de los errores con la tolerancia establecida y si todos son menores a sta,
imprime un mensaje sealando que se ha encontrado una aproximacin, sustituye los
nuevos valores en las ecuaciones originales para comprobar los resultados y los imprime, al
igual que los valores recin calculados y el error de cada uno en los Edits correspondientes.
Tambin muestra un mensaje con el nmero de iteraciones realizadas y detiene el proceso.
De no cumplir la condicin: Reasigna valores a las variables, siendo ahora el valor inicial
igual al recin calculado (
) y aumenta en uno el contador de iteraciones. Reinicia el
proceso.
Botn Calcular paso a paso:
La primera vez que se pulsa: Lee el valor de la tolerancia deseada y los valores iniciales de
las variables a calcular, dependiendo del orden de la matriz.
.
.
.
En las siguientes iteraciones toma como valor inicial el valor recin calculado en las
operaciones efectuadas.
imprime un mensaje sealando que se ha encontrado una aproximacin. Sustituye los
nuevos valores en las ecuaciones originales para comprobar los resultados.
Reasigna valores a las variables, siendo ahora el valor inicial igual al recin calculado
(
). Imprime los valores recin calculados, sus respectivos errores y el valor de la
ecuacin en funcin de los nuevos valores en los Edits correspondientes. Tambin imprime
un mensaje con el nmero de iteraciones, y aumenta en uno el contador.
35

Cdigo de programacin:
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include <math.h>
double
n=4,m,k,a0,a1,a2,a3,b0,b1,b2,b3,c0,c1,c2,c3,d0,d1,d2,d3,f0,f1,f2,f
3,s1,s2,s3,s4,q1,q2,q3,q4,F0,F1,F2,F3,A1,A2,A3,B0,B2,B3,C0,C1,C3,D
0,D1,D2,x1,x2,y1,y2,z1,z2,w1,w2,tol,F01,F11,F21,F31,dx,dy,dz,dw,
Dx,Dy,Dz,Dw,i,aux;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn 2x2
{
Image1->Visible=false;
Image39->Visible=true;
Image2->Left=352;
Image3->Left=448;
Image7->Left=352;
Image8->Left=448;
36

Edit1->Left=328;
Edit2->Left=424;
Edit6->Left=328;
Edit7->Left=424;
Edit3->Visible=false;
Edit1->SetFocus();
n=2;
}
//---------------------------------------------------------------//botn 3x3
{
37

Image2->Left=256;
Image3->Left=352;
Image4->Left=448;
Image7->Left=256;
Image8->Left=352;
Image9->Left=448;
Image12->Left=256;
Image13->Left=352;
Image14->Left=448;
Edit1->Left=232;
Edit2->Left=328;
Edit3->Left=424;
Edit6->Left=232;
Edit7->Left=328;
Edit8->Left=424;
Edit11->Left=232;
Edit12->Left=328;
Edit13->Left=424;
Edit3->Visible=true;
38

Edit1->SetFocus();
n=3;
}
//---------------------------------------------------------------//botn 4x4
{
Image2->Left=160;
Image3->Left=256;
Image4->Left=352;
Image5->Left=448;
Image7->Left=160;
Image8->Left=256;
Image9->Left=352;
Image10->Left=448;
Image12->Left=160;
Image13->Left=256;
Image14->Left=352;
Image15->Left=448;
39

Edit1->Left=136;
Edit2->Left=232;
Edit3->Left=328;
Edit4->Left=424;
Edit6->Left=136;
Edit7->Left=232;
Edit8->Left=328;
Edit9->Left=424;
Edit11->Left=136;
Edit12->Left=232;
Edit13->Left=328;
Edit14->Left=424;
40

Edit1->SetFocus();
n=4;
}
//---------------------------------------------------------------//botn capturar/convergencia
{
if(n==4){
f0=Edit5->Text.ToDouble();
b0=Edit6->Text.ToDouble();
c0=Edit11->Text.ToDouble();
d0=Edit16->Text.ToDouble();
if(a0==0||b1==0||c2==0||d3==0){
Label3->Caption="Los elementos de la diagonal principal deben ser
distintos de cero.";
Button2->Enabled=false;
}
else{
s1=
s2=
s3=
s4=
fabs(a1)+fabs(a2)+fabs(a3);
fabs(b0)+fabs(b2)+fabs(b3);
fabs(c0)+fabs(c1)+fabs(c3);
fabs(d0)+fabs(d1)+fabs(d2);
41

q1=s1/fabs(a0);
q2=s2/fabs(b1);
q3=s3/fabs(c2);
q4=s4/fabs(d3);
m=q1+q2+q3+q4;
if(q1<1&&q2<1&&q3<1&&q4<1){
Label3->Caption="La matriz es fuertemente dominante.";
Button2->Enabled=true;
Button3->Enabled=true;}
else if(q1<=1&&q2<=1&&q3<=1&&q4<=1&&m<4){
Label3->Caption="La matriz es dbilmente dominante.";
else{
Label3->Caption="El mtodo no garantiza convergencia.";
A1=a1/a0;
A2=a2/a0;
A3=a3/a0;
F0=f0/a0;
B0=b0/b1;
B2=b2/b1;
B3=b3/b1;
F1=f1/b1;
C0=c0/c2;
C1=c1/c2;
C3=c3/c2;
F2=f2/c2;
D0=d0/d3;
D1=d1/d3;
D2=d2/d3;
F3=f3/d3;}}
else if(n==3){
42

if(a0==0||b1==0||c2==0){
Button3->Enabled=false;}
else{
s1= fabs(a1)+fabs(a2);
s2= fabs(b0)+fabs(b2);
s3= fabs(c0)+fabs(c1);
q1=s1/fabs(a0);
q2=s2/fabs(b1);
q3=s3/fabs(c2);
m=q1+q2+q3;
if(q1<1&&q2<1&&q3<1) {
else if(q1<=1&&q2<=1&&q3<=1&&m<3){
else{
A1=a1/a0;
A2=a2/a0;
F0=f0/a0;
B0=b0/b1;
B2=b2/b1;
F1=f1/b1;
C0=c0/c2;
43

C1=c1/c2;
F2=f2/c2;}}
else {
if(a0==0||b1==0){
else{
s1= fabs(a1);
s2= fabs(b0);
q1=s1/fabs(a0);
q2=s2/fabs(b1);
m=q1+q2;
if(q1<1&&q2<1){
Label3->Caption="La matriz es fuertemente dominante. :)";
else if(q1<=1&&q2<=1&&m<2){
Label3->Caption="La matriz es dbilmente dominante. :(";
else{
Label3->Caption="El mtodo no garantiza convergencia. :/";
A1=a1/a0;
F0=f0/a0;
B0=b0/b1;
F1=f1/b1;}}
i=0;
k=0;
}
44

//---------------------------------------------------------------//botn calcular aproximacin
{
i=0;
aux=0;
if(n==4){
y1=Edit22->Text.ToDouble();
z1=Edit23->Text.ToDouble();
w1=Edit24->Text.ToDouble();
tol=Edit25->Text.ToDouble();
while(aux!=1){
x2=F0-(A1*y1)-(A2*z1)-(A3*w1);
y2=F1-(B0*x1)-(B2*z1)-(B3*w1);
z2=F2-(C0*x1)-(C1*y1)-(C3*w1);
w2=F3-(D0*x1)-(D1*y1)-(D2*z1);
dx=x2-x1;
dy=y2-y1;
dz=z2-z1;
dw=w2-w1;
Dx=fabs(dx);
Dy=fabs(dy);
Dz=fabs(dz);
Dw=fabs(dw);
if(Dx<tol&&Dy<tol&&Dz<tol&&Dw<tol) {
Label4->Caption="Se encontr una aproximacin!";
F01=(a0*x2)+(a1*y2)+(a2*z2)+(a3*w2);
F11=(b0*x2)+(b1*y2)+(b2*z2)+(b3*w2);
F21=(c0*x2)+(c1*y2)+(c2*z2)+(c3*w2);
F31=(d0*x2)+(d1*y2)+(d2*z2)+(d3*w2);
Edit26->Text=AnsiString(x2);
Edit27->Text=AnsiString(y2);
Edit28->Text=AnsiString(z2);
Edit29->Text=AnsiString(w2);
Edit30->Text=AnsiString(dx);
Edit31->Text=AnsiString(dy);
Edit32->Text=AnsiString(dz);
Edit33->Text=AnsiString(dw);
Edit34->Text=AnsiString(F01);
45

aux=1;}
x1=x2;
y1=y2;
z1=z2;
w1=w2;
i++;}}
else if(n==3){
while(aux!=1){
x2=F0-(A1*y1)-(A2*z1);
y2=F1-(B0*x1)-(B2*z1);
z2=F2-(C0*x1)-(C1*y1);
dx=x2-x1;
dy=y2-y1;
dz=z2-z1;
Dx=fabs(dx);
Dy=fabs(dy);
Dz=fabs(dz);
if(Dx<tol&&Dy<tol&&Dz<tol) {
F01=(a0*x2)+(a1*y2)+(a2*z2);
F11=(b0*x2)+(b1*y2)+(b2*z2);
F21=(c0*x2)+(c1*y2)+(c2*z2);
aux=1;}
x1=x2;
y1=y2;
z1=z2;
46

i++;}}
else {
while(aux!=1){
x2=F0-(A1*y1);
y2=F1-(B0*x1);
dx=x2-x1;
dy=y2-y1;
Dx=fabs(dx);
Dy=fabs(dy);
if(Dx<tol&&Dy<tol) {
F01=(a0*x2)+(a1*y2);
F11=(b0*x2)+(b1*y2);
aux=1;}
x1=x2;
y1=y2;
i++;}}
k=0;
}
//---------------------------------------------------------------//botn calcular paso a paso
{
if(n==4){
47

if (k==0){
i=0;
Label4->Caption="";}
x2=F0-(A1*y1)-(A2*z1)-(A3*w1);
y2=F1-(B0*x1)-(B2*z1)-(B3*w1);
z2=F2-(C0*x1)-(C1*y1)-(C3*w1);
w2=F3-(D0*x1)-(D1*y1)-(D2*z1);
dx=x2-x1;
dy=y2-y1;
dz=z2-z1;
dw=w2-w1;
Dx=fabs(dx);
Dy=fabs(dy);
Dz=fabs(dz);
Dw=fabs(dw);
Label4->Caption="Se encontr una aproximacin!";}
F01=(a0*x2)+(a1*y2)+(a2*z2)+(a3*w2);
F11=(b0*x2)+(b1*y2)+(b2*z2)+(b3*w2);
F21=(c0*x2)+(c1*y2)+(c2*z2)+(c3*w2);
F31=(d0*x2)+(d1*y2)+(d2*z2)+(d3*w2);
x1=x2;
y1=y2;
z1=z2;
w1=w2;}
48

else if(n==3){
if (k==0){
i=0;
x2=F0-(A1*y1)-(A2*z1);
y2=F1-(B0*x1)-(B2*z1);
z2=F2-(C0*x1)-(C1*y1);
dx=x2-x1;
dy=y2-y1;
dz=z2-z1;
Dx=fabs(dx);
Dy=fabs(dy);
Dz=fabs(dz);
F01=(a0*x2)+(a1*y2)+(a2*z2);
F11=(b0*x2)+(b1*y2)+(b2*z2);
F21=(c0*x2)+(c1*y2)+(c2*z2);
x1=x2;
y1=y2;
z1=z2;}
else {
if (k==0){
i=0;
49

x2=F0-(A1*y1);
y2=F1-(B0*x1);
dx=x2-x1;
dy=y2-y1;
Dx=fabs(dx);
Dy=fabs(dy);
F01=(a0*x2)+(a1*y2);
F11=(b0*x2)+(b1*y2);
x1=x2;
y1=y2;}
i++;
k++;
}
//---------------------------------------------------------------//botn reset
{
Edit1->Text="";
Edit1->SetFocus();
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
50

Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
Edit21->Text="";
Edit22->Text="";
Edit23->Text="";
Edit24->Text="";
Edit25->Text="";
Edit26->Text="";
Edit27->Text="";
Edit28->Text="";
Edit29->Text="";
Edit30->Text="";
Edit31->Text="";
Edit32->Text="";
Edit33->Text="";
Edit34->Text="";
Edit35->Text="";
Edit36->Text="";
Edit37->Text="";
Label4->Caption="";
Label5->Caption="";
}
//----------------------------------------------------------------
51

5.- Mtodo de Gauss Siedel
Este mtodo es similar al mtodo anterior, el de Jacobi, tambin para sistemas de

ecuaciones lineales, a diferencia de Jacobi, ahora Gauss retoma los valores ya calculados, y
los usa para calcular los nuevos valores de las dems variables:
Recordemos la ecuacin del mtodo de Jacobi, ahora usando los nuevos valores ya
calculados. De esta forma es ms rpido el proceso.
De esta forma al igual que el mtodo de Jacobi, para un nmero n+1 de variables,
necesitar un nmero n de valores iniciales.
Las interacciones son de la misma manera que el mtodo anterior, de igual forma el criterio
de paro y el criterio para la convergencia del mtodo sern las mismas que para el mtodo
de Jacobi, por lo que no se vuelven a enunciar en esta seccin, queda al lector regresar al
tema anterior para revisar las formulas y los criterios de convergencia.
52

Programacin:
Interpretacin por botn

Botn 2x2:
El formulario muestra por defecto un arreglo matricial de 4x4, al presionar el botn oculta y
reordena los Edits del formulario, de tal forma que se muestre slo un arreglo de 2x2;
oculta tambin todos los Edits relacionados con las variables que no forman parte del
sistema de ecuaciones.
Botn 3x3:
Oculta y reordena los Edits del formulario, de tal forma que se muestre slo un arreglo
matricial de 3x3; oculta tambin todos los Edits relacionados con las variables que no
forman parte del sistema de ecuaciones.
53

Botn 4x4:
Muestra y reordena todos los Edits del formulario, en la forma en que se encontraban
originalmente.
Botn Capturar/convergencia:
.
.
.
Comprueba que los elementos de la diagonal sean iguales a cero, si alguno cumple esa
condicin imprime una advertencia diciendo que los elementos de la diagonal principal
deben ser distintos de cero y desactiva los botones Calcular aproximacin y Calcular
paso a pas0. De lo contrario comprueba que la matriz sea dominante, comparando los
elementos de la diagonal con los dems:
Si el valor absoluto de cada elemento de la diagonal es mayor a la suma de los
valores absolutos de los dems elementos de la fila donde se encuentra, imprime un
mensaje diciendo que la matriz es fuertemente dominante.
Si el valor absoluto de uno o ms elementos de la diagonal es igual a la suma de los
valores absolutos de los dems elementos de la fila donde se encuentra, sin que
ninguno sea menor que dicha suma, imprime un mensaje diciendo que la matriz es
dbilmente dominante.
Si no cumple ninguna condicin quiere decir que no es una matriz dominante por lo
que es posible que el mtodo no sea convergente para la matriz en cuestin, por lo
que imprime un mensaje que advierte que no se garantiza la convergencia del
mtodo, y desactiva el botn Calcular aproximacin.
Por ltimo normaliza los coeficientes de las ecuaciones anteriormente mostradas, con los
datos necesarios, dependiendo del orden de la matriz.
Botn Calcular aproximacin:
Lee el valor de la tolerancia deseada y los valores iniciales de las variables a calcular,
dependiendo del orden de la matriz.
.
54


.
.
Dentro de una estructura de repeticin while:

imprime un mensaje sealando que se ha encontrado una aproximacin, sustituye los
nuevos valores en las ecuaciones originales para comprobar los resultados y los imprime, al
igual que los valores recin calculados y el error de cada uno en los Edits correspondientes.
Tambin muestra un mensaje con el nmero de iteraciones realizadas y detiene el proceso.
De no cumplir la condicin: Reasigna valores a las variables, siendo ahora el valor inicial
igual al recin calculado (
) y aumenta en uno el contador de iteraciones. Reinicia el
proceso.
Botn Calcular paso a paso:
La primera vez que se pulsa: Lee el valor de la tolerancia deseada y los valores iniciales de
las variables a calcular, dependiendo del orden de la matriz.
.
.
.
En las siguientes iteraciones toma como valor inicial el valor recin calculado en las
operaciones efectuadas.
imprime un mensaje sealando que se ha encontrado una aproximacin. Sustituye los
nuevos valores en las ecuaciones originales para comprobar los resultados.
Reasigna valores a las variables, siendo ahora el valor inicial igual al recin calculado
(
). Imprime los valores recin calculados, sus respectivos errores y el valor de la
ecuacin en funcin de los nuevos valores en los Edits correspondientes. Tambin imprime
un mensaje con el nmero de iteraciones, y aumenta en uno el contador.
55

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include <math.h>
double n=4,m,k,a0,a1,a2,a3,b0,b1,b2,b3,c0,c1,c2,c3,d0,d1,d2,d3,f0,
f1,f2,f3,s1,s2,s3,s4,q1,q2,q3,q4,F0,F1,F2,F3,A1,A2,A3,B0,B2,B3,C0,
C1,C3,D0,D1,D2,x1=0,x2,y1,y2,z1,z2,w1,w2,tol,F01,F11,F21,F31,dx,
dy,dz,dw,Dx,Dy,Dz,Dw,i,aux;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn 2x2
{
Image2->Left=352;
Image3->Left=448;
Image7->Left=352;
Image8->Left=448;
56

Edit1->Left=328;
Edit2->Left=424;
Edit6->Left=328;
Edit7->Left=424;
Edit1->SetFocus();
n=2;
}
//---------------------------------------------------------------//botn 3x3
{
57

Image2->Left=256;
Image3->Left=352;
Image4->Left=448;
Image7->Left=256;
Image8->Left=352;
Image9->Left=448;
Image12->Left=256;
Image13->Left=352;
Image14->Left=448;
Edit1->Left=232;
Edit2->Left=328;
Edit3->Left=424;
Edit6->Left=232;
Edit7->Left=328;
Edit8->Left=424;
Edit11->Left=232;
Edit12->Left=328;
Edit13->Left=424;
58

Edit1->SetFocus();
n=3;
}
//---------------------------------------------------------------//botn 4x4
{
Image2->Left=160;
Image3->Left=256;
Image4->Left=352;
Image5->Left=448;
Image7->Left=160;
Image8->Left=256;
Image9->Left=352;
Image10->Left=448;
Image12->Left=160;
Image13->Left=256;
Image14->Left=352;
Image15->Left=448;
59

Edit1->Left=136;
Edit2->Left=232;
Edit3->Left=328;
Edit4->Left=424;
Edit6->Left=136;
Edit7->Left=232;
Edit8->Left=328;
Edit9->Left=424;
Edit11->Left=136;
Edit12->Left=232;
Edit13->Left=328;
Edit14->Left=424;
Edit1->SetFocus();
60

n=4;}
//---------------------------------------------------------------//botn capturar/convergencia
{
if(n==4){
if(a0==0||b1==0||c2==0||d3==0){
}
else{
s1=
s2=
s3=
s4=
fabs(a1)+fabs(a2)+fabs(a3);
fabs(b0)+fabs(b2)+fabs(b3);
fabs(c0)+fabs(c1)+fabs(c3);
fabs(d0)+fabs(d1)+fabs(d2);
q1=s1/fabs(a0);
q2=s2/fabs(b1);
q3=s3/fabs(c2);
q4=s4/fabs(d3);
61

m=q1+q2+q3+q4;
if(q1<1&&q2<1&&q3<1&&q4<1){
else if(q1<=1&&q2<=1&&q3<=1&&q4<=1&&m<4){
else{
A1=a1/a0;
A2=a2/a0;
A3=a3/a0;
F0=f0/a0;
B0=b0/b1;
B2=b2/b1;
B3=b3/b1;
F1=f1/b1;
C0=c0/c2;
C1=c1/c2;
C3=c3/c2;
F2=f2/c2;
D0=d0/d3;
D1=d1/d3;
D2=d2/d3;
F3=f3/d3;}}
else if(n==3){
62

if(a0==0||b1==0||c2==0){
else{
s1= fabs(a1)+fabs(a2);
s2= fabs(b0)+fabs(b2);
s3= fabs(c0)+fabs(c1);
q1=s1/fabs(a0);
q2=s2/fabs(b1);
q3=s3/fabs(c2);
m=q1+q2+q3;
if(q1<1&&q2<1&&q3<1) {
else if(q1<=1&&q2<=1&&q3<=1&&m<3){
else{
A1=a1/a0;
A2=a2/a0;
F0=f0/a0;
B0=b0/b1;
B2=b2/b1;
F1=f1/b1;
C0=c0/c2;
C1=c1/c2;
F2=f2/c2;}}
else {
63

if(a0==0||b1==0){
else{
s1= fabs(a1);
s2= fabs(b0);
q1=s1/fabs(a0);
q2=s2/fabs(b1);
m=q1+q2;
if(q1<1&&q2<1){
else if(q1<=1&&q2<=1&&m<2){
else{
A1=a1/a0;
F0=f0/a0;
B0=b0/b1;
F1=f1/b1;}}
i=0;
k=0;
}
//----------------------------------------------------------------
64

//botn calcular aproximacin
{
i=0;
aux=0;
if(n==4){
while(aux!=1){
x2=F0-(A1*y1)-(A2*z1)-(A3*w1);
y2=F1-(B0*x2)-(B2*z1)-(B3*w1);
z2=F2-(C0*x2)-(C1*y2)-(C3*w1);
w2=F3-(D0*x2)-(D1*y2)-(D2*z2);
dx=x2-x1;
dy=y2-y1;
dz=z2-z1;
dw=w2-w1;
Dx=fabs(dx);
Dy=fabs(dy);
Dz=fabs(dz);
Dw=fabs(dw);
F01=(a0*x2)+(a1*y2)+(a2*z2)+(a3*w2);
F11=(b0*x2)+(b1*y2)+(b2*z2)+(b3*w2);
F21=(c0*x2)+(c1*y2)+(c2*z2)+(c3*w2);
F31=(d0*x2)+(d1*y2)+(d2*z2)+(d3*w2);
aux=1;}
65

x1=x2;
y1=y2;
z1=z2;
w1=w2;
i++;}}
else if(n==3){
while(aux!=1){
x2=F0-(A1*y1)-(A2*z1);
y2=F1-(B0*x2)-(B2*z1);
z2=F2-(C0*x2)-(C1*y2);
dx=x2-x1;
dy=y2-y1;
dz=z2-z1;
Dx=fabs(dx);
Dy=fabs(dy);
Dz=fabs(dz);
F01=(a0*x2)+(a1*y2)+(a2*z2);
F11=(b0*x2)+(b1*y2)+(b2*z2);
F21=(c0*x2)+(c1*y2)+(c2*z2);
aux=1;}
x1=x2;
y1=y2;
z1=z2;
i++;}}
66

else {
while(aux!=1){
x2=F0-(A1*y1);
y2=F1-(B0*x2);
dx=x2-x1;
dy=y2-y1;
Dx=fabs(dx);
Dy=fabs(dy);
F01=(a0*x2)+(a1*y2);
F11=(b0*x2)+(b1*y2);
aux=1;}
x1=x2;
y1=y2;
i++;}}
k=0;
}
//---------------------------------------------------------------//botn calcular paso a paso
{
if(n==4){
if (k==0){
i=0;
67

x2=F0-(A1*y1)-(A2*z1)-(A3*w1);
y2=F1-(B0*x2)-(B2*z1)-(B3*w1);
z2=F2-(C0*x2)-(C1*y2)-(C3*w1);
w2=F3-(D0*x2)-(D1*y2)-(D2*z2);
dx=x2-x1;
dy=y2-y1;
dz=z2-z1;
dw=w2-w1;
Dx=fabs(dx);
Dy=fabs(dy);
Dz=fabs(dz);
Dw=fabs(dw);
F01=(a0*x2)+(a1*y2)+(a2*z2)+(a3*w2);
F11=(b0*x2)+(b1*y2)+(b2*z2)+(b3*w2);
F21=(c0*x2)+(c1*y2)+(c2*z2)+(c3*w2);
F31=(d0*x2)+(d1*y2)+(d2*z2)+(d3*w2);
x1=x2;
y1=y2;
z1=z2;
w1=w2;}
else if(n==3){
if (k==0){
i=0;
68

x2=F0-(A1*y1)-(A2*z1);
y2=F1-(B0*x2)-(B2*z1);
z2=F2-(C0*x2)-(C1*y2);
dx=x2-x1;
dy=y2-y1;
dz=z2-z1;
Dx=fabs(dx);
Dy=fabs(dy);
Dz=fabs(dz);
F01=(a0*x2)+(a1*y2)+(a2*z2);
F11=(b0*x2)+(b1*y2)+(b2*z2);
F21=(c0*x2)+(c1*y2)+(c2*z2);
x1=x2;
y1=y2;
z1=z2;}
else {
if (k==0){
i=0;
x2=F0-(A1*y1);
y2=F1-(B0*x2);
dx=x2-x1;
dy=y2-y1;
Dx=fabs(dx);
69

Dy=fabs(dy);
F01=(a0*x2)+(a1*y2);
F11=(b0*x2)+(b1*y2);
x1=x2;
y1=y2;}
i++;
k++;
}
//---------------------------------------------------------------//botn reset
{
Edit1->Text="";
Edit1->SetFocus();
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
70

Edit22->Text="";
Edit23->Text="";
Edit24->Text="";
Edit25->Text="";
Edit26->Text="";
Edit27->Text="";
Edit28->Text="";
Edit29->Text="";
Edit30->Text="";
Edit31->Text="";
Edit32->Text="";
Edit33->Text="";
Edit34->Text="";
Edit35->Text="";
Edit36->Text="";
Edit37->Text="";
Label4->Caption="";
Label5->Caption="";
}
//----------------------------------------------------------
71

6.- Mtodo de Newton: Sistemas de

ecuaciones no lineales
Este mtodo nos servir para encontrar la solucin a un sistema no lineal es decir de
exponentes diferentes a 1. Para su anlisis se propondr el siguiente sistema:
+
Corresponden a
la ecuacin de
una
circunferencia y
de una hiprbola
respectivamente
La figura anterior muestra grficamente al sistema de ecuaciones, donde se encuentran una

circunferencia y una hiprbola.
La frmula de recurrencia de este mtodo es la siguiente:
(
(
)
]
)
( )
Donde J es el Jacobiano:
lo podemos determinar de la siguiente manera:

| |
( )]
72

La ecuacin (1) tiene analoga con la ecuacin (2) del mtodo de Newton Raphson para
encontrar races de ecuaciones:
(
( )
Para encontrar la frmula de recurrencia del sistema propuesto se procede a lo siguiente:

(
(
(
Se saca el Jacobiano:
[
| |
( )
Se deja al lector sacar la adjunta a la matriz, una manera es por cofactores o por la frmula de la
adjunta, si es una matriz de orden mayor se realizan por mtodos ya conocidos.
Posteriormente se precede a conocer a
( )]
+
[
Podemos verificar la inversa haciendo
[
[
Sabiendo que:
+ y
73

Ahora sustituimos los valores ya calculados en la frmula (1):
[
[
Al realizar las operaciones requeridas obtenemos las frmulas de recurrencia, las cuales
son:
(
( )
)+
( )
Reduciendo trminos semejantes tenemos:
( )
( )
Finalmente las ecuaciones 5 y 6 son nuestras frmulas de recurrencia, las cuales deben ser
diferentes de cero:
y
Haciendo
, tenemos las siguientes ecuaciones:
+
+
Recordando que estas ecuaciones son para el sistema analizado, nicamente para ello, para
saber las frmulas para otros sistemas se tiene que realizar el mismo procedimiento,
aplicando la formula (1), hasta obtener las frmulas de recurrencia requeridas para la
solucin del sistema no lineal.
74

Programacin:
Interpretacin por botn
Botn Aproximar solucin:

y , la tolerancia y el nmero de iteraciones deseadas, las cuales
debern cumplir ciertas condiciones:
y
deben ser distintos de cero para no indeterminar el resultado, puesto que
ambas variables se encuentran en el denominador de las ecuaciones de recurrencia.
La tolerancia y el nmero de iteraciones establecidos deben ser mayores que cero.

Si alguna de estas condiciones no se cumple, muestra una advertencia y borra dicho valor y
posiciona el cursor sobre l para corregirlo.
Si todas las condiciones se cumplen contina el proceso calculando, dentro de una
estructura de repeticin while,
y
con ayuda de las ecuaciones (5) y (6)
75

anteriormente mostradas; calcula el error de cada variable, restando el valor inicial al valor
recin calculado.
Compara los errores con la tolerancia y si ambos son menores que sta detiene el proceso e
imprime un mensaje informando que se ha encontrado un valor menor a la tolerancia, de lo
contrario imprime un mensaje diciendo que no se encontr un valor menor a la tolerancia y
reasigna valores a las variables, el valor recin calculado es ahora el valor inicial para la
siguiente iteracin
y
y aumenta en uno el contador de iteraciones. Si ste
llega al lmite de las iteraciones establecidas detiene el proceso.
Sustituye los nuevos valores en las ecuaciones originales para comprobar los resultados.
Imprime los valores de
y , los resultados de las ecuaciones en funcin de los valores
recin calculados y el nmero de iteraciones realizadas.
Botn Paso a paso:
La primera vez que se presiona el botn lee los valores para
y
y la tolerancia, si los
valores no cumplen con las condiciones anteriormente mencionadas, muestra un mensaje
sealando que datos es necesario corregir, los borra y posiciona el cursor sobre ellos. De
cumplirse todas las condiciones realizan los clculos de
y
con ayuda de las
ecuaciones (5) y (6), y calcula el error de cada variable, restando el valor inicial al valor
recin calculado.
Compara los errores con la tolerancia y si ambos son menores que sta detiene el proceso e
imprime un mensaje informando que se ha encontrado un valor menor a la tolerancia, de lo
contrario imprime un mensaje diciendo que no se encontr un valor menor a la tolerancia y
reasigna valores a las variables,
y
y aumenta en uno el contador de
iteraciones.
Sustituye los nuevos valores en las ecuaciones originales para comprobar los resultados.
Imprime los valores de
y , los resultados de las ecuaciones en funcin de los valores
recin calculados y el nmero de iteraciones realizadas.
Botn Limpiar valores:
Borra los datos escritos en el formulario y posiciona el puntero en el primer Edit. Reinicia
el valor de la variable auxiliar.
76

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "math.h"
double x1, y1, x2, y2, Tol, n, aux=0, c1, c2, dx, dy,i;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn aproximar solucin
{
n=Edit4->Text.ToDouble();
aux=0;
i=0;
if (x1==0||y1==0||Tol<=0||n<=0)
{
if (x1==0&&y1==0&&Tol<=0&&n<=0){
ShowMessage("x1 y y1 deben ser distintos de cero, la tolerancia y
n mayores que cero.");
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit1->SetFocus();}
else if (x1==0&&y1==0&&Tol<=0){
ShowMessage("x1 y y1 deben ser distintos de cero y la tolerancia
mayor que cero.");
Edit1->Text="";
Edit2->Text="";
77

Edit3->Text="";
Edit1->SetFocus();}
else if (x1==0&&y1==0&&n<=0)
{ShowMessage("x1 y y1 deben distintos de cero y n mayor que
cero.");
Edit1->Text="";
Edit2->Text="";
Edit4->Text="";
Edit1->SetFocus();}
else if (y1==0&& Tol<=0&& n<=0)
{ShowMessage("x1 debe ser distinto de cero, la tolerancia y n
mayores que cero.");
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit2->SetFocus();}
else if (x1==0&& Tol<=0&&n<=0)
{ShowMessage("x1 debe ser distinto de cero, la tolerancia mayor
que cero y n mayor que 2.");
Edit1->Text="";
Edit3->Text="";
Edit4->Text="";
Edit1->SetFocus();}
else if (x1==0&& y1==0)
{ShowMessage("x1 y y1 deben ser distintos de cero.");
Edit1->Text="";
Edit2->Text="";
Edit1->SetFocus();}
else if (x1==0&& Tol<=0)
{ShowMessage("x1 debe ser distinto de cero y la tolerancia mayor
que cero");
Edit1->Text="";
Edit3->Text="";
Edit1->SetFocus();}
else if (x1==0&&n<=0)
{ShowMessage("x1 debe ser distinto de cero y n mayor que cero.");
Edit1->Text="";
Edit4->Text="";
Edit1->SetFocus();}
else if (y1==0&& Tol<=0)
{ShowMessage("y1 debe ser distinto de cero y la tolerancia mayor
que cero.");
Edit2->Text="";
Edit3->Text="";
78

Edit2->SetFocus();}
else if (y1==0&&n<=0)
{ShowMessage("y1 debe ser distinto de cero y n mayor que cero.");
Edit2->Text="";
Edit4->Text="";
Edit2->SetFocus();}
else if (Tol<=0&&n<=0)
{ShowMessage("La tolerancia debe ser mayor que cero y n mayor que
cero.");
Edit3->Text="";
Edit4->Text="";
Edit3->SetFocus();}
else if (x1==0)
{ShowMessage("x1 debe distinto de cero.");
Edit1->Text="";
Edit1->SetFocus();}
else if (y1==0)
{ShowMessage("y1 debe distinto de cero.");
Edit2->Text="";
Edit2->SetFocus();}
else if (Tol<=0)
{ShowMessage("La Tolerancia debe ser mayor que cero");
Edit3->Text="";
Edit3->SetFocus();}
else {
ShowMessage("n debe ser mayor que cero.");
Edit4->Text="";
Edit4->SetFocus();}
}
else{
while(aux!=1&&i<n){
x2=(x1/2)+(11/(4*x1));
y2=(y1/2)+(9/(4*y1));
dx=fabs(x2-x1);
dy=fabs(y2-y1);
if (dx<Tol && dy<Tol){
Label8->Caption="Se encontr un valor menor a la tolerancia.";
aux=1;}
79

else{
Label8->Caption="No se encontr un valor menor a la tolerancia.
(Intente con un mayor nmero de iteraciones).";}
x1=x2;
y1=y2;
i++;
}
c1=(x2*x2)+(y2*y2);
c2=(x2*x2)-(y2*y2);
Edit7->Text=AnsiString(c1);
Edit4->Text=AnsiString(i);
}
}
//---------------------------------------------------------------//botn paso a paso
{
if (aux<=1){
i=0;}
if (x1==0||y1==0||Tol<=0){
if (x1==0&&y1==0&&Tol<=0){
ShowMessage("x1 y y1 deben ser distintos de cero y la tolerancia
mayor que cero.");
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit1->SetFocus();}
else if (x1==0&& y1==0)
{ShowMessage("x1 y y1 deben ser distintos de cero.");
Edit1->Text="";
Edit2->Text="";
Edit1->SetFocus();}
else if (x1==0&& Tol<=0)
80

{ShowMessage("x1 debe ser distinto de cero y la tolerancia mayor
que cero");
Edit1->Text="";
Edit3->Text="";
Edit1->SetFocus();}
else if (y1==0&& Tol<=0)
{ShowMessage("y1 debe ser distinto de cero y la tolerancia mayor
que cero.");
Edit2->Text="";
Edit3->Text="";
Edit2->SetFocus();}
else if (x1==0)
{ShowMessage("x1 debe distinto de cero.");
Edit1->Text="";
Edit1->SetFocus();}
else if (y1==0)
{ShowMessage("y1 debe distinto de cero.");
Edit2->Text="";
Edit2->SetFocus();}
else if (Tol<=0)
{ShowMessage("La Tolerancia debe ser mayor que cero");
Edit3->Text="";
Edit3->SetFocus();}
}
else{
x2=(x1/2)+(11/(4*x1));
y2=(y1/2)+(9/(4*y1));
dx=fabs(x2-x1);
dy=fabs(y2-y1);
if (dx<Tol && dy<Tol){
Label8->Caption="Se encontr un valor menor a la tolerancia.";}
else{
Label8->Caption="No se encontr un valor menor a la tolerancia.
(Intente con un mayor nmero de iteraciones).";}
x1=x2;
y1=y2;
c1=(x2*x2)+(y2*y2);
c2=(x2*x2)-(y2*y2);
aux=aux+2;
i++;
81

Edit4->Text=AnsiString(i);}
}
//---------------------------------------------------------------//botn limpiar valores
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit1->SetFocus();
Label8->Caption="";
aux=0;
}
//----------------------------------------------------------------
82

7.- Interpolacin: Newton y Lagrange

Este mtodo sirve para encontrar un polinomio a partir de datos.
i
El polinomio debe satisfacer que al sustituir

debe ser exactamente igual a su
correspondiente . Es decir, el polinomio ( ) que pasa exactamente por los cuatro puntos
( ),
( ),
( ),
( ) es la solucin del problema.
Este mtodo nos ayudar a encontrar un polinomio, con el cual podremos predecir valores
que no se nos proporcionan.
Interpolar significa encontrar valores dentro del intervalo si quisiramos encontrar
valores fuera del intervalo se llamara extrapolacin. Lo que se quiere con este mtodo es
predecir valores intermedios a partir del polinomio interpolador.
Polinomio interpolador
Con el polinomio interpolador

podremos predecir los valores
intermedios en el intervalo sin
la necesidad de ms datos.
()
83

( ) es un polinomio interpolador si se usa para predecir valores en el intervalo

[
].
( ) es un polinomio extrapolador si se usa para predecir valores en la proximidad
][
del intervalo [
+ ].
Interpolacin de Newton Diferencias divididas

La idea es obtener un polinomio de la forma:
( )
)+
)(
)+
)(
Dnde:
[ ]
[
Siendo [
] las diferencias divididas finitas.
El polinomio interpolador para el caso de tener 4 datos es:

( )
)+
)(
)+
)(
)(
Pasa exactamente por los cuatro puntos. El clculo de los coeficientes es el siguiente:
Para
( )
+
,
(
:
)+
)(
)+
)(
)(
( )
Para
( )
+
,
(
:
)+
)(
( )
, obtenemos
+
+
Despejando
)+
)(
)(
)
)
Notemos que es una
pendiente
84

Para
( )
+
:
(
)+
)(
(
)+
)+
)(
)(
)(
De lo cual podemos hacer un despeje parcial para lograr la siguiente igualdad:

(
Ahora en el numerador del miembro izquierdo de la igualdad, le sumamos un

(
+ ), de tal manera que no se altere la igualdad:
(
cero
A continuacin, aplicamos un poco de lgebra para as obtener los siguientes resultados:

(
)
(
(
(
+
(
)
+
Por lo tanto:
Para
( )
+
+
:
(
)+
)+
)(
(
)+
)(
(
)+
)(
(
)(
)(
)(
)
)
85

En donde se observa que cada coeficiente representa la diferencia de las dos diferencias
divididas anteriores.
Puede ser de mucha utilidad ordenar las diferencias divididas en una tabla, como se muestra
a continuacin:
Tabla para generar los coeficientes:
Las diferencias se encuentran en el orden en el que se han colocado las flechas, retomando
como numeradores a los valores ya obtenidos, teniendo cuidado con los denominadores, ya
que estos no se toman de alado sino de la ltima diferencia o la ms inferior de la cadena.
86

( )
+(
+(
+(
))
)+
( (
)+
+
)
))
Esta tabla nos permite visualizar mejor el polinomio y simplifica la programacin, la cual
se ha de realizar posteriormente.
Ejemplo:
Para realizar el clculo, nos apoyamos de la tabla anterior, lo cual sera de la siguiente
manera:
-2
-1
(
(
)
)
Se acomod de la siguiente manera ya que las

son iguales a las
, y no afecta al
resultado. Por lo que el polinomio interpolador queda de la siguiente manera:
Por lo que el polinomio interpolador es:
( )
+ ( + )
( )
( + )( + )
(
( )
)
(
(
+
)+(
( + )( + )(
)+(
87

Interpolacin de Lagrange
Este mtodo pretende obtener un polinomio de la forma:

( )
( )+
( )+
( )+
( )
El cual debe satisfacer que:

( )
, ( )
, ( )
, ( )
Esto implica:
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
Los polinomios que cumplen son 4:

( )
( )
( )
( )
(
(
(
(
(
(
(
(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)
)
)
)
Si sustituimos estos valores en la ecuacin principal tendremos el siguiente polinomio:

( )
(
(
)(
)(
(
+
(
)(
)(
)(
)(
)
(
)(
+
) (
)(
)(
)
(
+
)(
) (
)(
)(
)(
)(
)
)
)(
)(
)
)
Desarrollando el polinomio y factorizando, obtenemos un polinomio de la forma:

( )
88

Dnde:
(
)(
+
)(
(
)
)(
)(
)(
)(
)
)(
)(
Puesto que estos trminos aparecen en los dems coeficientes del polinomio, conviene
llamarlos:
)(
)(
)(
)(
)(
)(
)(
)(
)) + ( (
( (
+(
)+(
+(
)) + (
))
))
))) + ( ( (
)) + (
)+(
)+(
))) + (
( (
)) + (
)))
)+(
)) + (
)))
(
))
Lo cual simplifica la programacin, la cual se realizar posteriormente.
Ejemplo:
i
Calculamos los valores para

( )
(
(
)(
)(
0
-2
1
1
1
3
2
2
5
( ), ( ), ( ) y
)(
)(
)
)
3
-3
7
( ).
)(
)(
)(
89

(
(
( )
)(
)(
(
(
( )
)(
)(
(
(
( )
)(
)(
)
)
)(
)(
)(
)(
)
)
)(
)(
)(
)(
(
)
)
)(
)(
)(
)(
)(
)(
)(
Por lo tanto el polinomio interpolador para este conjunto de datos es igual a:

( )
)(
)(
)(
)(
( )
)+(
)+(
)+(
)(
)
)(
(
)(
)
)(
Finalmente tenemos:
( )
Este es el polinomio que nos servir para encontrar los valores intermedios en el intervalo
dado, lo cual nos servir como ya dijimos, para calcular valores desconocidos, siempre que
se encuentren en el intervalo establecido.
90

Programacin:
Botn Calcular coeficientes:

Lee los valores para ,
,
,
, ,
,
y
. Dependiendo del mtodo
seleccionado realiza las operaciones que son requeridas en cada caso.
Para el mtodo de Newton: calcula las diferencias divididas y utiliza las que corresponden
para calcular los valores de , ,
y , segn las frmulas anteriormente mostradas.
Realiza las operaciones para encontrar los coeficientes del polinomio interpolador.
Imprime los datos en el formulario.
Para el mtodo de Lagrange: calcula los valores para
,
,
y
sin tomar en
cuenta los trminos en funcin de . Realiza las operaciones correspondientes para
encontrar los coeficientes del polinomio interpolador. Imprime los datos en el formulario.
91

Botn Graficar:
Lee los coeficientes del polinomio interpolador. Realiza la grfica de dicho polinomio
sobre un eje coordenado.
Botn Reset:
Borra los datos escritos y las grficas trazadas en el formulario. Deshace la seleccin de los
Radio Buttons y posiciona el puntero en el primer Edit.
92

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma
#pragma
#pragma
#pragma
package(smart_init)
link "PERFGRAP"
link "pies"
resource "*.dfm"
double x0, x1, x2, x3, y0, y1, y2, y3, b0, b1, b2, b3, ab1, bb1,
ab2, a, b, c, d, a0, a1, a2, a3, x, y, k, inicio;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn calcular coeficientes
{
//mtodo de Newton
if(RadioButton1->Checked==true)
{
b0=y0;
b1=(y1-y0)/(x1-x0);
ab1=(y2-y1)/(x2-x1);
bb1=(y3-y2)/(x3-x2);
b2=(ab1-b1)/(x2-x0);
93

ab2=(bb1-ab1)/(x3-x1);
b3=(ab2-b2)/(x3-x0);
Label2->Caption=FormatFloat("0.#####",b0);
//coeficientes del polinomio
b=b2+(b3*(-x0-x1-x2));
c=b1+(b2*(-x0-x1))+(b3*((x0*(x1+x2))+(x1*x2)));
d=b0-(b1*x0)+(b2*x0*x1)-(b3*x0*x1*x2);
Edit10->Text=AnsiString(b);
Edit11->Text=AnsiString(c);
Edit12->Text=AnsiString(d);
}
//mtodo de Lagrange
if(RadioButton2->Checked==true)
{
a0=y0/((x0-x1)*(x0-x2)*(x0-x3));
a1=y1/((x1-x0)*(x1-x2)*(x1-x3));
a2=y2/((x2-x0)*(x2-x1)*(x2-x3));
a3=y3/((x3-x0)*(x3-x1)*(x3-x2));
Label2->Caption=FormatFloat("0.#####",a0)+" (x ("+AnsiString(x1)+"))"+" (x -("+AnsiString(x2)+"))"+ " (x ("+AnsiString(x3)+"))";
94

//coeficientes del polinomio
a=a0+a1+a2+a3;
b=(a0*(-x1-x2-x3))+(a1*(-x0-x2-x3))+(a2*(-x0-x1-x3))+(a3*(-x0-x1x2));
c=(a0*((x1*(x2+x3))+(x2*x3)))+(a1*((x0*(x2+x3))+(x2*x3)))+(a2*((x0
*(x1+x3))+(x1*x3)))+(a3*((x0*(x1+x2))+(x1*x2)));
d=(-a0*(x1*x2*x3)) +(-a1*( x0*x2*x3))+(-a2*( x0*x1*x3))+(-a3*(
x0*x1*x2));
Edit9->Text=AnsiString(a);
Edit10->Text=AnsiString(b);
Edit11->Text=AnsiString(c);
Edit12->Text=AnsiString(d);
}
}
//---------------------------------------------------------------//botn graficar
{
//ejes
Canvas->Pen->Color=clBlack;
Canvas->Pen->Width=3;
Canvas->PenPos=TPoint(656,128);
Canvas->LineTo(656,504);
//puntas de los ejes
95

//grfica de la funcin
Canvas->Pen->Color=0x008A50D1;
a=Edit9->Text.ToDouble();
b=Edit10->Text.ToDouble();
c=Edit11->Text.ToDouble();
d=Edit12->Text.ToDouble();
inicio=-400;
x=inicio/15;
y=15*((a*x*x*x)+(b*x*x)+(c*x)+d);
Canvas->PenPos=TPoint(656+15*inicio,320-y);
for(k=inicio;k<=300;k++)
{
x=k/15;
y=15*((a*x*x*x)+(b*x*x)+(c*x)+d);
Canvas->LineTo(656+15*x,320-y);
}
}
//---------------------------------------------------------------//botn reset
{
Form1->Visible=false;
Form1->Visible=true;
RadioButton1->Checked=false;
RadioButton2->Checked=false;
96

Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit1->SetFocus();
Label2->Caption="";
Label3->Caption="";
Label4->Caption="";
Label5->Caption="";
}
//----------------------------------------------------------------
97

8.- Derivacin Numrica

Tipos de derivacin:
La derivacin clsica se opera sobre funciones
Funciones
Funciones
La derivacin cuando se conoce la funcin
Datos
Datos
13
19
25
Derivacin numrica
Datos
Datos
98

En la derivacin numrica partimos de datos y como resultado tambin obtenemos datos,

para esto se tendrn que evaluar con la ayuda de sus vecinos, a la combinacin que se haga
se le llamar ventana, si tenemos de grado
tendremos que usar a 3 nmeros, es
decir al nmero que se pretenda derivar y al de su derecha y al de su izquierda, si tenemos
el grado
se usarn 4 nmeros como mnimo, en esta se pueden hacer combinaciones
con los nmeros de sus extremos del nmero a derivar, entre mayor sea el nmero de
valores agregados mayor ser la exactitud.
Se basa en el principio del polinomio interpolador y del desarrollo de la serie de Taylor,
como ya mencionamos entre mayor nmero de pares tengamos habr mayor precisin.
Se tendr que derivar la serie de Taylor para obtener una frmula para la derivacin
numrica, la cual tendr la siguiente forma.
Funcin de error
Serie de Taylor
Los pasos a seguir sern los siguientes:

1) Conjunto de pares de datos (
).
2) Polinomio interpolador de orden n.
3) Derivar el polinomio interpolador.
4) Frmula de orden n para el clculo de la primera derivada.
En otras palabras:
A partir de un conjunto de datos se construye un polinomio interpolador
El salto es
constante
Complementar el polinomio interpolador con una funcin de error para obtener por
completo a la funcin que represente de manera exacta a los datos. Es decir, se desarrolla
una serie de Taylor alrededor de los puntos analizados.
( )
( )+ ( )
Derivar a ( )
Sustituir
, . ,
para obtener las distintas frmulas para la derivacin
99

Desarrollo de la serie de Taylor
( )
( )
( )
( )
+ (
)
( )
)+
( )+ (
( )+ (
)(
( )
Evaluando en
:
( )
+ (
( )
( )
( )
por la derecha.
:
( )
+ (
( )
( )+ (
( )
( )
por la izquierda.
Frmulas de orden dos (

Si
) para la primera derivada numrica.
, entonces tenemos tres pares de puntos
100

( )
( )+(
)(
)(
( )
Polinomio interpolador
( )
+
( )
)+
+
)(
[(
)+(
[(
)+(
)
)]
Evaluando en
(Por la derecha):
( )
( )
)]
(Central):
( )
+
( )
[(
)+(
)]
)+(
)]
(Por la izquierda):
( )
( )
+
(
[(
+
101

Derivando el factor de error:

)(
[(
[(
)(
)(
)+(
)(
( )
)+(
)(
)]
( )
Evaluando:
( )
( )
( )
( )
En esta existe menor

error, ya que su
denominador es mayor.
( )
( )
Tabla para la primera derivada de orden
( )
( )
Derecha
( )
Izquierda
Orden 1
( )
( )
( )
Derecha
Orden 2
( )
( )
( )
Central
( )
Izquierda
102

( )
( )
( )
( )
Derecha
Central
Orden 3
+
( )
( )
( )
Segunda derivada de orden
( )
Central
Izquierda
(para 3 pares de datos).
Para ello se procede a los mismos pasos anteriores con la diferencia de que ahora ser la
segunda derivada para el polinomio interpolador, de igual forma para el desarrollo de la
serie de Taylor.
( )
( )
( )
( )+(
)+
+
)(
[(
)(
(
)(
)+(
( )
)
)
)]
( )
La segunda derivada de la funcin de error:

( )
[(
( )
[ (
)(
)+ (
)+(
)(
)+ (
)+(
)]
)(
)]
( )
( )
103

Evaluando:
( )
( )
( )
( )
Derecha
Central
( )
Izquierda
Teniendo de esta forma las siguientes frmulas:
Por la derecha:
Central:
Por la izquierda:
( )
( )
( )
( )
( )
Programacin
104

Funciones por botn

Botn Capturar Y[i]:
Captura los valores para
de datos ingresados.
y los guarda en un arreglo lineal. Muestra el nmero
Botn Mostrar datos +:

Muestra los valores de
, ubicando el primer dato debajo de la etiqueta
la
primera vez que se presiona, las siguientes ocasiones se recorren los datos hacia la
izquierda, mostrando los datos siguientes para poder visualizar todos.
Botn Mostrar datos -:
Muestra los valores de
, ubicando el primer dato debajo de la etiqueta
la
primera vez que se presiona, las siguientes ocasiones recorre los datos hacia la derecha,
mostrando los datos anteriores, esto es cuando se han recorrido previamente hacia la
izquierda.
Botn Reset:
Borra los datos escritos en el formulario y reinicia la variable que posiciona los datos en el
arreglo. Posiciona el puntero en el primer Edit.
105

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
int i=2,a,b;
double Y[100],y0,y1,y2,h,der,cen,izq;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------void __fastcall TForm1::FormActivate(TObject *Sender)
{
Edit1->SetFocus();
}
//---------------------------------------------------------------//botn capturar Y[i]
{
Y[i]=Edit1->Text.ToDouble();
Label2->Caption="n= "+AnsiString(i-1);
Edit1->Text="";
Edit1->SetFocus();
a=i-4;
i++;
b=1;
}
//---------------------------------------------------------------//botn mostrar datos +
{
106

if(b==1){i=-1;}
if(i<a){i++;}
Edit3->Text=AnsiString(Y[i]);
Edit4->Text=AnsiString(Y[i+1]);
b=0;
}
//---------------------------------------------------------------//botn mostrar datos void __fastcall TForm1::Button3Click(TObject *Sender)
{
if(b==1){i=1;}
if(i!=0){i--;}
Edit3->Text=AnsiString(Y[i]);
b=0;
}
//---------------------------------------------------------------//botn primera
{
h=Edit2->Text.ToDouble();
der=(-y2+(4*y1)-(3*y0))/(2*h);
cen=(y2-y0)/(2*h);
izq=((3*y2)-(4*y1)+y0)/(2*h);
Edit8->Text=AnsiString(der);
Edit9->Text=AnsiString(cen);
Edit10->Text=AnsiString(izq);
}
//----------------------------------------------------------------
107

//botn segunda
{
cen=(y2-(2*y1)+y0)/(h*h) ;
Edit11->Text=AnsiString(cen);
}
//---------------------------------------------------------------//botn reset
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit1->SetFocus();
Label2->Caption="n=";
a=2;
}
//----------------------------------------------------------------
108

9.- Integracin Numrica
Como sabemos una aplicacin de la integral es el clculo del rea bajo la curva, pues bien
ahora hallaremos eso a partir de una serie de datos ya dados o conocidos los cuales pasan
por la curva o polinomio ( ).
Para poder desarrollar la integracin numrica se procedern a realizar los siguientes
pasos:
1.- Desarrollar la serie de Taylor alrededor de pares de puntos
Orden
1
2
3
Pares de
puntos
2
3
4
2.- Integrar a ( )
( )
3.- ( )
( )+ ( )
( )+ ( )
Veremos dos casos o ms bien dos mtodos:

Mtodo del trapecio.
Mtodo de Simpsom
109

Regla del Trapecio

( )
( )+ ( )
( )
( )
( )
+
(
)+
)
( )
)(
Tenemos que integrar:

( )
( )
)+
Integrando la funcin de error:

( )
( )
)(
Integrando por partes, donde:

(
)
(
110

( )
( ) (
*
( )
)(
(
*(
( )
( )
)(
(*
)(
)(
+
)
( )
)+
*(
)+
( (
( ) (
*
( )
((
( )
( )
) )
[(
) ]
)
( )
Sustituyendo, obtenemos que:
( )
( )
Finalmente
( )
( )
Regla de Simpson 1/3
( )
( )
( )+(
(
)(
)+
)(
+
)
(
( )
)(
111

Integrando:
[ ]
[(
) ]
(
*
)(
)
)( )
)
(
*
)(
)(
)(
[(
) ]
+
(
)(
)
)
((
) ]
)
(
[(
)(
)(
) )
112

Sustituyendo, obtenemos que:
( )
)+
)+( )
+
(
Programacin
Descripcin por botn

Botn rea:
Lee los valores de
y de (el salto). Utiliza las frmulas de la regla del trapecio y
de Simpson 1/3 para realizar los clculos, con ayuda de una estructura de repeticin for.
Botn Graficar:
Lee los valores de
,
y . Calcula los valores para
sumando el salto
ms el valor anterior de . Traza la grfica resultante de unir los puntos de la funcin
descrita, sobre un eje coordenado.
Botn Reset:
Borra los datos escritos en el formulario y posiciona el puntero en el primer Edit.
113

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma link "PERFGRAP"
double Y[20], X[20], h, trapecio, simpson;
int k;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn rea
{
Y[0]=Edit1->Text.ToDouble();
trapecio=0;
simpson=0;
for(k=0;k<10;k++){
trapecio=trapecio+((Y[k]+Y[k+1])*(h/2));}
for(k=0;k<9;k=k+2){
114

simpson=simpson+((Y[k]+(4*(Y[k+1]))+Y[k+2])*(h/3));}
Edit14->Text=AnsiString(trapecio);
Edit15->Text=AnsiString(simpson);
}
//---------------------------------------------------------------//botn graficar
{
X[0]=Edit12->Text.ToDouble();
for (k=1;k<=10;k++){
X[k]=X[k-1]+h;
}
Canvas->Pen->Color=0x00C08080;
115

Canvas->PenPos=TPoint(672+X[0]*15,311);
for(k=0; k<=10;k++)
{
Canvas->LineTo(672+(X[k])*15,311-(Y[k])*15);
}
Canvas->LineTo(672+(X[10])*15,311);
}
//---------------------------------------------------------------//botn reset
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
Edit1->SetFocus();
}
//----------------------------------------------------------------
116

10.- Mtodo de Euler
Este mtodo nos servir para la solucin de ecuaciones diferenciales de primer orden.
( )
En esta ecuacin encontramos lo que llamamos PVI es decir, problema de valor inicial,
para desarrollar este mtodo se procede de la manera siguiente:
1.- Poner a la ecuacin en la forma

(
( )
2.- Dividir en intervalos iguales

(
( )
En este paso se pasa de una funcin continua a una funcin discreta. Posteriormente hay
que aproximar a la derivada con su diferencia finita.
( )
3.- Sustituyendo (2) y (3) en (1) tenemos
(
( )
Frmula de
recurrencia
De esta forma llegamos a la frmula de recurrencia, la solucin se traduce en un problema

de valor inicial (PVI).
117

Mtodo de Euler mejorado E++

(
) se sustituye por un promedio:

(
Valor anterior.
(
)+ (
Se tiene la ecuacin:
(
)+ (
(
)+ (
( )
)
( )
En donde se aprecia que el trmino

se encuentra en los dos miembros de la ecuacin,
por lo que tenemos que hay que despejar.
Ejemplo:
Encontrar la frmula de recurrencia para resolver la ecuacin diferencial de manera
numrica con las condiciones iniciales dadas.
[
Euler:
Pasar a la forma
)
+
+
+
(
)+
Frmula de recurrencia
118

Una vez encontrado la frmula se evala en los datos y se obtiene:

(
)) +
)) + (
)(
)
)
Euler mejorado E++:

+
+
( + )
+
+
+
( )+
(
( +
)+
( +
)+ (
( )
+
(
Frmula de recurrencia
119

Programacin:
Descripcin por botn

Botn Euler:
para
y
y
.
, dentro de una estructura de repeticin calcula los valores
Para : sumando (el salto) al valor anterior. Para

con ayuda de la frmula de
recurrencia anteriormente calculada con el mtodo de Euler simple. Muestra dichos valores
en los Edits correspondientes.
Botn Euler ++:
para
y
y
.
120

Para : sumando el salto al valor anterior. Para

con ayuda de la frmula de
recurrencia calculada anteriormente con el mtodo de Euler mejorado. Muestra dichos
valores en los Edits correspondientes.
Botn Graficar:
Realiza una grfica de la funcin con los puntos calculados sobre un eje coordenado.
Botn Reset:
121

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include <math.h>
double Y[20], X[20], h, a, b;
int k;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn euler
{
for(k=1;k<=10;k++)
{
Y[k]=(Y[k-1]*(1-2*h))+(X[k-1]*(exp(2*X[k-1]))*h);
X[k]=X[k-1]+h;
}
Edit4->Text=AnsiString(X[1]);
122

Edit14->Text=AnsiString(Y[1]);
}
//botn euler++
//---------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender)
{
a=(1-h)/(1+h);
b=h/(2+2*h);
for(k=1;k<=10;k++)
{
X[k]=X[k-1]+h;
Y[k]=(a*Y[k-1])+(b*((X[k-1]*exp(2*X[k-1]))+(X[k]*exp(2*X[k]))) );
}
123

}
//---------------------------------------------------------------//botn graficar
{
Canvas->PenPos=TPoint(272+X[0]*150,382-Y[0]*150);
for(k=1; k<=10;k++)
{
Canvas->LineTo(272+X[k]*150,382-Y[k]*150);
}
}
//---------------------------------------------------------------//botn reset
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
124

Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
Edit21->Text="";
Edit22->Text="";
Edit23->Text="";
Edit1->SetFocus();
}
//----------------------------------------------------------------
125

11.- Mtodo de Runge-Kutta
A este mtodo se le conoce tambin como Euler modificado. Es igual que el mtodo de
Euler mejorado pero en la ecuacin de la pendiente no se despeja
en la ecuacin de Euler sin mejorar.
, sino que se evala
Euler mejorado
)+ (
En donde desaparece el trmino
Euler sin mejorar
)+ (
))
Euler modificado
, evitando despejar.
1. Poner de la forma:
(
Usar un intervalo equidistante:

+
+
(
2. Aproximar a la pendiente con el promedio y aproximar a la derivada con su

diferencia finita:
(
)+ (
+
(
))
126

)+
))
Considrese
(
))
Podemos simplificar la frmula de recurrencia a

+
Ejemplo:
( )
+
Poner en la forma
( )
+
(
( )
(
(
))
( ))
(
)))
127

Programacin
Descripcin por botn

Botn Calcular:
para
y
y
.
Para : suma el valor anterior ms el del salto.

Para
utiliza la frmula de recurrencia calculada en el ejemplo antes mostrado;
apoyndose de las variables auxiliares
y
. Muestra los resultados en los Edits
correspondientes.
Botn Graficar:
Botn Reset:
128

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include <math.h>
double Y[20], X[20], h, k1, k2;
int k;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn calcular
{
for(k=1;k<=10;k++)
{
X[k]=X[k-1]+h;
k1=h*((exp(-2*X[k-1]))-(4*Y[k-1]));
k2=h*((exp(-2*X[k]))-(4*(Y[k-1]+k1)));
Y[k]=Y[k-1]+((k1+k2)/2);
}
129

}
//---------------------------------------------------------------//botn graficar
{
Canvas->PenPos=TPoint(272+X[0]*150,382-(Y[0])*150);
for(k=1; k<=10;k++)
{
Canvas->LineTo(272+X[k]*150,382-(Y[k])*150);
}
}
//----------------------------------------------------------------
130

//botn reset
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
Edit21->Text="";
Edit22->Text="";
Edit23->Text="";
Edit1->SetFocus();
}
//----------------------------------------------------------------
131

12.- Mtodo de la serie de Taylor
Un desarrollo de la funcin ( ) en el vecindario de (

) est dado por la ecuacin ( ),
( )
donde
son las derivadas de orden
evaluadas en el punto .
( )
( )
( )
* () es el orden de la derivada, no
confundir con exponente.
Considerese
(
para
)
)(
) +
(
) +
)(
+
( )
En un problema de valor inicial PVI se dispone de un valor inicial ( ) y de una ecuacin

del tipo ( ).
(
( )
Usando un intervalo equidistante

(
( )
Consideracin: la segunda derivada de una funcin compuesta.

(
+
[ (
+
)]
( )
132

Sustituyendo ( ) y ( ) en ( )
(
)+
)]
( )
Ecuacin de recurrencia
Donde podemos notar que los primeros trminos ( +

frmula del mtodo de Euler simple anteriormente vista.
)) son iguales a la
Ejemplo:
Sea
Algoritmo.1. Encontrar las derivadas parciales

Dado que
(
[ +
[ +
2. Finalmente sustituir en la ecuacin ( )

+
(
+
+
(
)+
+
)+
+
[
]
]
133

Programacin
Interfaz grfica propuesta:

Botn Calcular:
y . Si
muestra un mensaje indicando que dicho valor
debe ser distinto de cero, borra y posiciona el puntero en el Edit para corregirlo.
Si
calcula los valores para
y
dentro de una estructura de
repeticin. Para : suma el valor anterior de dicha variable ms el del salto. Para : utiliza
la frmula de recurrencia calculada en el ejemplo. Por ltimo, muestra los resultados en los
Edits correspondientes.
Botn Graficar:
Botn Reset:
134

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include <math.h>
double Y[20], X[20], h,a,b;
int k;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn calcular
{
if(X[0]==0){
ShowMessage("x0 debe ser distinto de cero.");
Edit2->Text="";
Edit2->SetFocus();}
else{
for(k=1;k<=10;k++)
{
a=exp(X[k-1])/(X[k-1]);
b=exp(X[k-1])/(X[k-1]*X[k-1]);
Y[k]=Y[k-1]+(h*(Y[k-1]+a))+((h*h/2)*(Y[k-1]+2*a-b));
X[k]=X[k-1]+h;
}
135

}
}
//---------------------------------------------------------------//botn graficar
{
136

Canvas->PenPos=TPoint(272+X[0]*45,382-(Y[0])*45);
for(k=1; k<=10;k++)
{
Canvas->LineTo(272+X[k]*45,382-(Y[k])*45);
}
}
//---------------------------------------------------------------//botn reset
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
Edit21->Text="";
Edit22->Text="";
Edit23->Text="";
Edit1->SetFocus();
}
//----------------------------------------------------------------
137

13.-Mtodo de diferencias finitas
Las ecuaciones diferenciales parciales son representaciones matemticas que modelan la

evolucin temporal y espacial de sistemas fsicos reales.
Clasificacin
Se clasifican en base a sus caractersticas de propagacin en: hiperblicas, parablicas y
elpticas.
Se diferencian tambin porque en ellas aparecen las derivadas (todas de segundo orden
respecto al espacio) :
y sin derivada, respectivamente.
Hiperblicas
Puede ser que la raz de su nombre se deba a que esta ecuacin tiene la forma de una
ecuacin hiperblica.
138

Parablicas
De la misma manera puede ser que la raz de su nombre se deba a que efectivamente
tambin posee la forma de una ecuacin parablica.
Elpticas
(
As tambin esta.
+
139

Hiperblicas
Dnde:
: Es la velocidad de propagacin.
( +
Parablicas
[
( )
Ecuacin de difusin.
Dnde:
(
): Es el coeficiente de difusin.
( ): Es la densidad del material que se difunde en direccin de .
Describe procesos que tienen gradientes de densidad de un material que se difunde.

Se parte de la ecuacin de continuidad
+
( )
Ecuacin de continuidad.
140

Dnde:
: Es el flujo del material que se difunde.
Un cambio de densidad corresponde a una diferencia entre el flujo entrante y el flujo
saliente.
Dnde:
: Es la densidad del material.
Ley de Fick
( )
Dnde:
: Es el coeficiente de difusin.
El flujo del material que se difunde corresponde al gradiente local de la densidad.
Combinando (2) y (3)

[
*Divergencia del gradiente.

En una dimensin
)
[
( ), es decir,
( )
constante.
( )
Ecuacin de difusin.
141

(
(
+
(
Elpticas
Ecuacin de Poisson
(
Fuentes o prdidas de calor interno.

Ausencia de derivada respecto al tiempo.
Se aplican en sistemas con valores en la frontera.
Ecuacin de Laplace
+
(
+
)
+
+
+
Mtodo de Jacobi
(
((
) +(
) +(
) +(
+(
) +(
) )
Mtodo de Gauss-Seidel
(
((
+(
) )
Los superndices indican la posicin respecto al tiempo y los subndices, respecto al

espacio.
142

Programacin
Interfaz propuesta:

Botn Jacobi:
Lee los valores iniciales del sistema, de los Edits en color gris, y los guarda en un arreglo
bidimensional. Por defecto, los valores de los elementos de un arreglo son iguales a cero, lo
cual evita la necesidad de escribir valores iniciales para los elementos a calcular, ubicados
en el centro.
Dentro de una estructura de repeticin for calcula los elementos centrales del sistema
haciendo un promedio de los 4 los valores ms cercanos, ubicados arriba, abajo y a los
costados; guardndolos en una variable auxiliar, puesto que los valores recin calculados
sern utilizados hasta la siguiente iteracin.
Dentro de otra estructura de repeticin for calcula el error de los elementos calculados,
restando el valor inicial al valor final. Compara los datos para seleccionar el mayor, al cual
tomaremos como error total. Reasigna el valor del elemento del sistema a la variable
auxiliar correspondiente.
Dependiendo del mtodo que se utilice primero para calcular los valores centrales del
sistema, imprime los datos en el lugar que corresponde.
143

Si se oprime en primer lugar el botn Jacobi muestra los resultados en los Edits
resaltados en color azul; de lo contrario, muestra los resultados en los Edits en verde.
Imprime en una etiqueta debajo del lugar donde se muestra el sistema, el mtodo utilizado,
el nmero de iteraciones y el error total.
Botn Jacobi:
Lee los valores iniciales del sistema, de los Edits en color gris, y los guarda en un arreglo
bidimensional.
Dentro de una estructura de repeticin for calcula los elementos centrales del sistema
haciendo un promedio de los 4 los valores ms cercanos, ubicados arriba, abajo y a los
costados; en este caso tambin utilizamos una variable auxiliar para calcular los valores,
pues nos servir para guardar el valor final sin perder el valor inicial de la variable. Calcula
el error de los elementos calculados, restando el valor inicial al valor final. Compara los
datos para seleccionar el mayor, al cual tomaremos como error total. Reasigna las variables.
Si se oprime en primer lugar el botn Gauss muestra los resultados en los Edits resaltados
en color azul; de lo contrario, muestra los resultados en los Edits en verde. Imprime en una
etiqueta debajo del lugar donde se muestra el sistema, el mtodo utilizado, el nmero de
iteraciones y el error total.
Botn Reset:
Borra los datos escritos en el formulario y reinicia los contadores de iteraciones y la
variable auxiliar.
144

//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include <math.h>
double A[10][10], B[10][10], a[10][10], b[10][10], EA[10][10],
EB[10][10],error1, error2;
int i,j,w=0,jacobi=1, gauss=1;
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn Jacobi
{
A[0][1]=Edit1->Text.ToDouble();
for(i=1;i<=3;i++){
for(j=1;j<=3;j++)
145

{a[i][j]=0.25*((A[i+1][j])+(A[i-1][j])+(A[i][j+1])+(A[i][j-1]));}
}
//uso de una variable auxiliar
for(i=1;i<=3;i++){
for(j=1;j<=3;j++)
{
EA[i][j]=fabs((a[i][j])-(A[i][j]));
//clculo del error
if((EA[i][j])>(EA[i][j+1])){
EA[i][j+1]=EA[i][j];}
A[i][j]=a[i][j];}
}
//reasignacin de variables
error1=EA[1][3];
if(error1<EA[2][3]){error1=EA[2][3];}
if(error1<EA[3][3]){error1=EA[3][3];}
if(w==0||w==1)
{
Edit5->Text=AnsiString(A[1][1]);
if(jacobi<2){
Label2->Caption="Jacobi "+ AnsiString(jacobi)+" iteracin. Error=
"+FormatFloat("0.##########", error1);}
else{
Label2->Caption="Jacobi "+AnsiString(jacobi)+" iteraciones. Error=
"+ FormatFloat("0.##########", error1);}
}
else{
146

if(jacobi<2){
Label3->Caption="Jacobi "+ AnsiString(jacobi)+" iteracin. Error=
else{
Label3->Caption="Jacobi "+AnsiString(jacobi)+" iteraciones. Error=
}
if(w==0){w=1;}
jacobi++;
}
//---------------------------------------------------------------//botn Gauss
{
B[0][1]=Edit1->Text.ToDouble();
for(i=1;i<=3;i++){
for(j=1;j<=3;j++){
b[i][j]=0.25*((B[i+1][j])+(B[i-1][j])+(B[i][j+1])+(B[i][j-1]));
EB[i][j]=fabs((b[i][j])-(B[i][j]));
B[i][j]=b[i][j]; }
}
error2=EB[1][3];
if(error2<EB[2][3]){error2=EB[2][3];}
if(error2<EB[3][3]){error2=EB[3][3];}
147

if(w==0||w==2){
Edit5->Text=AnsiString(B[1][1]);
if(gauss<2){
Label2->Caption="Gauss-Seidel "+ AnsiString(gauss)+" iteracin.
Error= "+FormatFloat("0.##########", error2);}
else{
Label2->Caption="Gauss-Seidel "+AnsiString(gauss)+" iteraciones.
Error= "+FormatFloat("0.##########", error2);}
}
else{
if(gauss<2){
Label3->Caption="Gauss-Seidel "+ AnsiString(gauss)+" iteracin.
Error= "+ FormatFloat("0.##########", error2);}
else{
Label3->Caption="Gauss-Seidel "+AnsiString(gauss)+" iteraciones.
Error= "+ FormatFloat("0.##########", error2);}
}
if(w==0){w=2;}
gauss++;
}
//----------------------------------------------------------------
148

//botn reset
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
Edit21->Text="";
Edit22->Text="";
Edit23->Text="";
Edit24->Text="";
Edit25->Text="";
Edit26->Text="";
Edit27->Text="";
Edit28->Text="";
Edit29->Text="";
Edit30->Text="";
Label2->Caption="";
Label3->Caption="";
w=0;
jacobi=1;
gauss=1;
}
//----------------------------------------------------------------
149

Crditos
Autor Intelectual:
Dr. Rubn Herrera Galicia (Catedrtico)
1 Edicin:
Frida Carolina Villalobos Rivas (Semestre Agosto-Diciembre 2012)
2 Edicin (actual):
Heri Jacob Villar Snchez (Semestre Enero-Mayo 2013)
Manual de Mtodos Numricos

Universidad Autnoma de Chiapas
Facultad de Ingeniera
Licenciatura en Ingeniera Civil
Tuxtla Gutirrez Chiapas
150

Manual Metodos Numericos

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Manual Metodos Numericos

Загружено:

Авторское право:

Доступные форматы

UNIVERSIDAD AUTNOMA DE CHIAPAS

Rubn Herrera Galicia

Solucin numrica de ecuaciones de una variable

Solucin numrica de sistemas de ecuaciones lineales y no lineales

Interpolacin, derivacin e integracin numrica

9. Integracin numrica .109

Solucin numrica de ecuaciones diferenciales ordinarias

Solucin numrica de ecuaciones en derivadas parciales

UNIVERSIDAD AUTNOMA DE CHIAPAS

1.- Mtodo de Biseccin

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

Programacin del mtodo.

Descripcin de los botones de la aplicacin:

Botn Calcular producto:

UNIVERSIDAD AUTNOMA DE CHIAPAS

Si el resultado es menor al margen de error detiene el proceso y muestra los resultados;

Si el resultado es menor que cero, asigna a

mostrndolos debajo de su respectiva etiqueta. Cuenta el nmero de iteraciones, adems

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

2.- Mtodo de Newton Raphson

Partiendo de una funcin (

Entonces tenemos lo siguiente:

UNIVERSIDAD AUTNOMA DE CHIAPAS

Que es conocida como la frmula de Newton-Raphson.

UNIVERSIDAD AUTNOMA DE CHIAPAS

Programacin del mtodo

Acciones por botn

( ) con las mismas

compara estos ltimos y acta de acuerdo a las siguientes condiciones:

UNIVERSIDAD AUTNOMA DE CHIAPAS

En caso de no cumplirse ninguna condicin, reasigna valores a las variables:

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

De esta forma es como se programara la aplicacin en lenguaje c++.

UNIVERSIDAD AUTNOMA DE CHIAPAS

3.- Mtodo de Lin-Bairstow

Consideraremos ahora este polinomio de grado

La idea es factorizar al polinomio ( ) y dejarlo de la siguiente forma

Se habr factorizado el polinomio numricamente cuando

UNIVERSIDAD AUTNOMA DE CHIAPAS

La condicin para la factorizacin del polinomio es que

sean iguales a cero, por

Despejando a p de la ecuacin (3) y a q de la ecuacin (2)

UNIVERSIDAD AUTNOMA DE CHIAPAS

Para definir el error tenemos las siguientes ecuaciones

Sustituyendo la ecuacin (5) en el valor de p recin calculado, tenemos

tenemos la siguiente frmula:

De la misma manera con la ecuacin (6) al realizar lo anterior llegamos a la siguiente

Polinomio de orden n-2

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

Programacin por botn:

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS

UNIVERSIDAD AUTNOMA DE CHIAPAS