1 MANUALF VILLAR B.pdf

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

UNIVERSIDAD AUTNOMA DE CHIAPAS FACULTAD DE INGENIERA

4

Algoritmo

1. Escoger los valores del intervalo.

2. Comprobar la existencia de una raz en el intervalo [ ] , verificando que

( ) ( )

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.

()

( )

( )

+

1.- Mtodo de Biseccin


5

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 .

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 ( ( ) ).

( ) ( ) > , es positivo,

no contiene a la raz

( ) ( ) > , es positivo,

no contiene a la raz

1)

3)

2)


6

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:


7

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.


8

Cdigo de programacin:

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

#include

#pragma hdrstop

#include "Unit1.h"

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

#pragma package(smart_init)

#pragma resource "*.dfm"

#include

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(prodCaption=AnsiString(prod);}

else{

Label2->Caption="Escoja otros valores";}

}

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

//botn calcular raz


{


9



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(deltaCaption=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);


10

if(prod0){x1=xm;}

n++;

i++;

}

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

//reset


{

i=1;

n=1;

Label6->Caption="";

Label7->Caption="";

Label8->Caption="";

Label9->Caption="";

Label10->Caption="";



}

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


11

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:

( )

( )

Partiendo de una funcin ( ) , cuya derivada es ( ) y recordando que:

( ) y

Entonces tenemos lo siguiente:

()

Raz

Pendiente = ()

()

()

() ()

2.- Mtodo de Newton Raphson


12

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.

Casos especiales

a) ( ) , 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 , | | > | |

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.

La frmula se

vuelve a realizar

otra vez, cada vez

se acerca ms a la

raz, por eso se

llama de

recurrencia.

En la grfica observamos el

caso del crculo vicioso, al

cual no tendremos una

solucin por este mtodo,

hay que evitar caer en l.


13

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 ( ) con las mismas

condiciones: detener el proceso si un resultado es igual a cero.

Si el proceso continu, calcula: ( )

( ), | | 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.


14

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.


15

Cdigo de programacin

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

#include

#pragma hdrstop

#include "Unit1.h"

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



#include

double x1,Tol,n=0,m=0,y1,dy1,x2,y2,dy2,x3,y3,s1,s2;

TForm1 *Form1;

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


: 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++;}

}


16

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 (s2s2){

y3=x3*x3*x3-x3-1;



Label5->Caption="Raz aproximada.";

m=1;}

else{

x1=x2;

x2=x3;}

}

}

}

Label6->Caption = "Iteraciones +AnsiString(n);

}

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


17

//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++.


18

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

( ) +

+ +

+

+ +

+

+ +

+

+ +

+

+ +

+ + +

+ (Residuo)

3.- Mtodo de Lin-Bairstow

Al hacer el producto

nos da trminos

semejantes, son los

que se sealan con

una flecha.


19

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 la factorizacin del polinomio es que y sean iguales a cero, por lo tanto:

( ) ( )

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

( )

( )

Donde

La condicin para

que el polinomio sea

factorizable es que

y


20

El numerador es

igual a

Para definir el error tenemos las siguientes ecuaciones

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

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:

Valor

inicial

Valor recin

Polinomio de orden

n Funcin Polinomio de orden n-2 Residu

Par de races

Dr. Herrera:

A partir de aqu

todas las frmulas

las anex yo

porque en el

anterior no estaban

todas


21

Hacer y leer

.

Calcular:

Checar

Si No

Calcular Nanchy

Checar que

| | ,

| |

Si

No

Text

Hacer

,

Algoritmo:

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


22

Programacin

Interfaz grfica propuesta:

Programacin por botn:

Botn Paso a pasito:

Lee los valores para , 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:

Lee los valores para , la tolerancia, y si se requiere, tambin de y ,

de lo contrario su valor inicial es cero. Dentro de una estructura de repeticin while


23

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.


24

Cdigo de programacin

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

#include

#pragma hdrstop

#include "Unit1.h"

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



#include

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;

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


: 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;


25

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 (errorCaption="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



26

{








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 (errorCaption="El error es menor a la tolerancia establecida.";

m=1;}

else{

p=p2;

q=q2;

i++;}


27

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";


28

}

}

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

//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;

}

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


29

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:

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:

4.- Mtodo de Jacobi

Las condiciones que se

deben cumplir son:


30

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.


31

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.


32

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.

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.

Valores iniciales


33

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.


34

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.


35

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.


36

Cdigo de programacin:

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

#include

#pragma hdrstop

#include "Unit1.h"

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



#include

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;












37













Edit1->Left=328;

Edit2->Left=424;

Edit6->Left=328;

Edit7->Left=424;

Edit3->Visible=false;






















Edit1->SetFocus();

n=2;

}

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

//botn 3x3


{


38




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;






39


















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;








40

















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;























41


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= fabs(a1)+fabs(a2)+fabs(a3);

s2= fabs(b0)+fabs(b2)+fabs(b3);

s3= fabs(c0)+fabs(c1)+fabs(c3);

s4= fabs(d0)+fabs(d1)+fabs(d2);


42

q1=s1/fabs(a0);

q2=s2/fabs(b1);

q3=s3/fabs(c2);

q4=s4/fabs(d3);

m=q1+q2+q3+q4;

if(q1Enabled=true;}

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){







43








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(q1Enabled=true;}

else if(q1Caption="El mtodo no garantiza convergencia.";


Button3->Enabled=true;}

A1=a1/a0;

A2=a2/a0;

F0=f0/a0;

B0=b0/b1;

B2=b2/b1;

F1=f1/b1;

C0=c0/c2;


44

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(q1Enabled=true;


else if(q1Enabled=true;}

else{

Label3->Caption="El mtodo no garantiza convergencia. :/";



A1=a1/a0;

F0=f0/a0;

B0=b0/b1;

F1=f1/b1;}}

i=0;

k=0;

}


45

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

//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(DxText=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);



46



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(DxText=AnsiString(y2);

Edit28->Text=AnsiString(z2);







aux=1;}

x1=x2;

y1=y2;

z1=z2;


47

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(DxText=AnsiString(x2);

Edit27->Text=AnsiString(y2);





aux=1;}

x1=x2;

y1=y2;

i++;}}


k=0;

}

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

//botn calcular paso a paso


{

if(n==4){


48

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);











x1=x2;

y1=y2;

z1=z2;

w1=w2;}


49

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);









x1=x2;

y1=y2;

z1=z2;}

else {

if (k==0){

i=0;






50

x2=F0-(A1*y1);

y2=F1-(B0*x1);

dx=x2-x1;

dy=y2-y1;

Dx=fabs(dx);

Dy=fabs(dy);







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="";


51

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="";

Button2->Enabled=true;


}

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


52

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.

5.- Mtodo de Gauss Siedel


53

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.


54

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.



55



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.


56

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

#include

#pragma hdrstop

#include "Unit1.h"

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



#include

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;















57










Edit1->Left=328;

Edit2->Left=424;

Edit6->Left=328;

Edit7->Left=424;























Edit1->SetFocus();

n=2;

}

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

//botn 3x3


{





58

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;










59















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;











60














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();


61

n=4;}

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

//botn capturar/convergencia


{

if(n==4){





















if(a0==0||b1==0||c2==0||d3==0){





}

else{

s1= fabs(a1)+fabs(a2)+fabs(a3);

s2= fabs(b0)+fabs(b2)+fabs(b3);

s3= fabs(c0)+fabs(c1)+fabs(c3);

s4= fabs(d0)+fabs(d1)+fabs(d2);

q1=s1/fabs(a0);

q2=s2/fabs(b1);

q3=s3/fabs(c2);

q4=s4/fabs(d3);


62

m=q1+q2+q3+q4;

if(q1Enabled=true;}

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){











63




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(q1Enabled=true;}

else if(q1Caption="El mtodo no garantiza convergencia.";



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 {



64






if(a0==0||b1==0){





else{

s1= fabs(a1);

s2= fabs(b0);

q1=s1/fabs(a0);

q2=s2/fabs(b1);

m=q1+q2;

if(q1Enabled=true;


else if(q1Enabled=true;}

else{

Label3->Caption="El mtodo no garantiza convergencia.";



A1=a1/a0;

F0=f0/a0;

B0=b0/b1;

F1=f1/b1;}}

i=0;

k=0;

}

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


65

//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);











aux=1;}


66

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);









aux=1;}

x1=x2;

y1=y2;

z1=z2;

i++;}}


67

else {



while(aux!=1){

x2=F0-(A1*y1);

y2=F1-(B0*x2);

dx=x2-x1;

dy=y2-y1;

Dx=fabs(dx);

Dy=fabs(dy);







aux=1;}

x1=x2;

y1=y2;

i++;}}


k=0;

}

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

//botn calcular paso a paso


{

if(n==4){

if (k==0){

i=0;



68





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);











x1=x2;

y1=y2;

z1=z2;

w1=w2;}

else if(n==3){

if (k==0){

i=0;



69




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);









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);


70

Dy=fabs(dy);







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="";


71

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="";



}

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


72

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:

+

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:

[

]

Y lo podemos determinar de la siguiente manera:

| | [ ( )]

6.- Mtodo de Newton: Sistemas de ecuaciones no lineales

Corresponden a

la ecuacin de

una

circunferencia y

de una hiprbola

respectivamente


73

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 *

+


74

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.


75

Programacin:


Interpretacin por botn

Botn Aproximar solucin:

Lee los valores para 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)


76

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.


77

Cdigo de programacin //--------------------

Documents

1 MANUALF VILLAR B.pdf