Documentos de Académico
Documentos de Profesional
Documentos de Cultura
1 Manualf Villar B PDF
1 Manualf Villar B PDF
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.
I.
II.
III.
( )
Segunda derivada
( )
IV.
V.
()
( )
( )
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)
Interfaz propuesta:
), ( )
),
;(
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();
x2=Edit2->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
void __fastcall TForm1::Button2Click(TObject *Sender)
{
10
()
( )
Pendiente = ( )
( )
Raz
) , cuya derivada es
)
) y recordando que:
( )
11
Despejando
en la ecuacin, obtenemos:
( )
( )
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
( )
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:
| y
| ;
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.
14
Cdigo de programacin
//---------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
#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
void __fastcall TForm1::Button1Click(TObject *Sender)
{
x1=Edit1->Text.ToDouble();
Tol=Edit2->Text.ToDouble();
y1=x1*x1*x1-x1-1;
if(y1==0){
Label3->Caption=AnsiString(x1);
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
16
//botn reset
void __fastcall TForm1::Button3Click(TObject *Sender)
{
Label3->Caption="";
Label4->Caption="";
Label5->Caption="Observaciones...";
Label6->Caption="";
Edit1->Text="";
Edit1->SetFocus();
Edit2->Text="";
n=0;
m=0;
}
//---------------------------------------------------------------
17
( )
+ )(
)+
( )
( )
+
+
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
( )
( )
( )
( )
Donde
19
Valor
inicial
A partir de aqu
todas las frmulas
las anex yo
porque en el
anterior no estaban
todas
Valor recin
( )
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
( )
( )
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
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:
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
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
#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
void __fastcall TForm1::Button1Click(TObject *Sender)
{
if(k==0){i=0;}
if(i==0)
{
a0=Edit1->Text.ToDouble();
a1=Edit2->Text.ToDouble();
a2=Edit3->Text.ToDouble();
a3=Edit4->Text.ToDouble();
a4=Edit5->Text.ToDouble();
a5=Edit6->Text.ToDouble();
Tol=Edit7->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
25
26
27
28
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:
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.
|
30
|>| |+|
|+|
|>|
|+|
|+|
|+|
|
| |+| |+| |
| |
| |+| |+| |
| |
|
|+|
|
|+|
|
Calculando:
| |+|
|
|+|
|
| |+| |+| |
| |
| |+| |+| |
| |
|
|+|
|
|+|
|
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:
(
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
32
Programacin:
Interfaz grfica propuesta
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:
.
Para un arreglo de 3x3: Lee los datos de la matriz formada por el sistema de ecuaciones:
.
Para un arreglo de 2x2: 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
.
.
.
35
Cdigo de programacin:
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
#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;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn 2x2
void __fastcall TForm1::Button5Click(TObject *Sender)
{
Image1->Visible=false;
Image38->Visible=false;
Image39->Visible=true;
Image2->Left=352;
Image3->Left=448;
Image7->Left=352;
Image8->Left=448;
Image4->Visible=false;
Image5->Visible=false;
Image9->Visible=false;
Image10->Visible=false;
Image12->Visible=false;
Image13->Visible=false;
Image14->Visible=false;
Image15->Visible=false;
Image16->Visible=false;
Image17->Visible=false;
36
37
38
39
40
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
42
43
44
45
46
47
48
49
50
51
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:
Interfaz grfica propuesta
53
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:
.
Para un arreglo de 3x3: Lee los datos de la matriz formada por el sistema de ecuaciones:
.
Para un arreglo de 2x2: 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.
Para matrices de orden 4x4:
.
54
.
.
55
56
57
58
59
60
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
62
63
64
65
66
67
68
69
70
71
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
)
]
)
( )
Donde J es el Jacobiano:
( )]
72
La ecuacin (1) tiene analoga con la ecuacin (2) del mtodo de Newton Raphson para
encontrar races de ecuaciones:
(
( )
(
(
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
( )]
+
[
[
[
Sabiendo que:
+ y
73
[
[
Al realizar las operaciones requeridas obtenemos las frmulas de recurrencia, las cuales
son:
(
( )
)+
( )
( )
( )
Finalmente las ecuaciones 5 y 6 son nuestras frmulas de recurrencia, las cuales deben ser
diferentes de cero:
y
Haciendo
+
+
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:
Interfaz grfica propuesta
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.
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
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
#include "math.h"
double x1, y1, x2, y2, Tol, n, aux=0, c1, c2, dx, dy,i;
TForm1 *Form1;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn aproximar solucin
void __fastcall TForm1::Button1Click(TObject *Sender)
{
x1=Edit1->Text.ToDouble();
y1=Edit2->Text.ToDouble();
Tol=Edit3->Text.ToDouble();
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
78
79
80
81
82
Polinomio interpolador
()
83
)+
)(
)+
)(
Dnde:
[ ]
[
Siendo [
)+
)(
)+
)(
)(
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
( )
+
:
(
)+
)(
(
)+
)+
)(
)(
)(
cero
)
(
(
(
+
(
)
+
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
(
(
)
)
+ ( + )
( )
( + )( + )
(
( )
)
(
(
+
)+(
( + )( + )(
)+(
87
Interpolacin de Lagrange
( )+
( )+
( )+
( )
, ( )
, ( )
, ( )
Esto implica:
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
(
(
(
(
(
(
(
(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)
)
)
)
(
(
)(
)(
(
+
(
)(
)(
)(
)(
)
(
)(
+
) (
)(
)(
)
(
+
)(
) (
)(
)(
)(
)(
)
)
)(
)(
)
)
88
Dnde:
(
)(
+
)(
(
)
)(
)(
)(
)(
)
)(
)(
Puesto que estos trminos aparecen en los dems coeficientes del polinomio, conviene
llamarlos:
)(
)(
)(
)(
)(
)(
)(
)(
)) + ( (
( (
+(
)+(
+(
)) + (
))
))
))) + ( ( (
)) + (
)+(
)+(
))) + (
( (
)) + (
)))
)+(
)) + (
)))
(
))
Ejemplo:
i
(
(
)(
)(
0
-2
1
1
1
3
2
2
5
( ), ( ), ( ) y
)(
)(
)
)
3
-3
7
( ).
)(
)(
)(
89
(
(
( )
)(
)(
(
(
( )
)(
)(
(
(
( )
)(
)(
)
)
)(
)(
)(
)(
)
)
)(
)(
)(
)(
(
)
)
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
)(
( )
)+(
)+(
)+(
)(
)
)(
(
)(
)
)(
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:
Interfaz grfica propuesta
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
Cdigo de programacin
//---------------------------------------------------------------#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;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn calcular coeficientes
void __fastcall TForm1::Button1Click(TObject *Sender)
{
y0=Edit1->Text.ToDouble();
y1=Edit2->Text.ToDouble();
y2=Edit3->Text.ToDouble();
y3=Edit4->Text.ToDouble();
x0=Edit5->Text.ToDouble();
x1=Edit6->Text.ToDouble();
x2=Edit7->Text.ToDouble();
x3=Edit8->Text.ToDouble();
//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
94
95
96
97
Funciones
Datos
Datos
13
19
25
Derivacin numrica
Datos
Datos
98
Serie de Taylor
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
, . ,
99
( )
( )
( )
( )
+ (
)
( )
)+
( )+ (
( )+ (
)(
( )
Evaluando en
:
( )
+ (
( )
( )
( )
por la derecha.
:
( )
+ (
( )
( )+ (
( )
( )
por la izquierda.
100
( )
( )+(
)(
)(
( )
Polinomio interpolador
( )
+
( )
)+
+
)(
[(
)+(
[(
)+(
)
)]
Evaluando en
(Por la derecha):
( )
( )
)]
(Central):
( )
+
( )
[(
)+(
)]
)+(
)]
(Por la izquierda):
( )
( )
+
(
[(
+
101
[(
[(
)(
)(
)+(
)(
( )
)+(
)(
)]
( )
Evaluando:
( )
( )
( )
( )
( )
( )
( )
( )
Derecha
( )
Izquierda
Orden 1
( )
( )
( )
Derecha
Orden 2
( )
( )
( )
Central
( )
Izquierda
102
( )
( )
( )
( )
Derecha
Central
Orden 3
+
( )
( )
( )
( )
Central
Izquierda
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.
( )
( )
( )
( )+(
)+
+
)(
[(
)(
(
)(
)+(
( )
)
)
)]
( )
[(
( )
[ (
)(
)+ (
)+(
)(
)+ (
)+(
)]
)(
)]
( )
( )
103
Evaluando:
( )
( )
( )
( )
Derecha
Central
( )
Izquierda
Por la derecha:
Central:
Por la izquierda:
( )
( )
( )
( )
( )
Programacin
Interfaz grfica propuesta
104
105
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
int i=2,a,b;
double Y[100],y0,y1,y2,h,der,cen,izq;
TForm1 *Form1;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------void __fastcall TForm1::FormActivate(TObject *Sender)
{
Edit1->SetFocus();
}
//---------------------------------------------------------------//botn capturar Y[i]
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Y[i]=Edit1->Text.ToDouble();
Label2->Caption="n= "+AnsiString(i-1);
Edit1->Text="";
Edit1->SetFocus();
a=i-4;
i++;
b=1;
}
//---------------------------------------------------------------//botn mostrar datos +
void __fastcall TForm1::Button2Click(TObject *Sender)
{
106
107
//botn segunda
void __fastcall TForm1::Button5Click(TObject *Sender)
{
h=Edit2->Text.ToDouble();
y0=Edit5->Text.ToDouble();
y1=Edit6->Text.ToDouble();
y2=Edit7->Text.ToDouble();
cen=(y2-(2*y1)+y0)/(h*h) ;
Edit11->Text=AnsiString(cen);
}
//---------------------------------------------------------------//botn reset
void __fastcall TForm1::Button6Click(TObject *Sender)
{
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
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.- ( )
( )+ ( )
( )+ ( )
109
( )+ ( )
( )
( )
( )
+
(
)+
)
( )
)(
( )
)+
( )
)(
)
(
110
( )
( ) (
*
( )
)(
(
*(
( )
( )
)(
(*
)(
)(
+
)
( )
)+
*(
)+
( (
( ) (
*
( )
((
( )
( )
) )
[(
) ]
)
( )
( )
( )
Finalmente
( )
( )
( )
( )
( )+(
(
)(
)+
)(
+
)
(
( )
)(
111
Integrando:
[ ]
[(
) ]
(
*
)(
)
)( )
)
(
*
)(
)(
)(
[(
) ]
+
(
)(
)
)
((
) ]
)
(
[(
)(
)(
) )
112
( )
)+
)+( )
+
(
Programacin
Interfaz grfica propuesta
113
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma link "PERFGRAP"
#pragma resource "*.dfm"
double Y[20], X[20], h, trapecio, simpson;
int k;
TForm1 *Form1;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn rea
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Y[0]=Edit1->Text.ToDouble();
Y[1]=Edit2->Text.ToDouble();
Y[2]=Edit3->Text.ToDouble();
Y[3]=Edit4->Text.ToDouble();
Y[4]=Edit5->Text.ToDouble();
Y[5]=Edit6->Text.ToDouble();
Y[6]=Edit7->Text.ToDouble();
Y[7]=Edit8->Text.ToDouble();
Y[8]=Edit9->Text.ToDouble();
Y[9]=Edit10->Text.ToDouble();
Y[10]=Edit11->Text.ToDouble();
h=Edit13->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
115
116
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:
( )
( )
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
117
Valor anterior.
(
)+ (
Se tiene la ecuacin:
(
)+ (
(
)+ (
( )
)
( )
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
)) +
)) + (
)(
)
)
+
( + )
+
+
+
( )+
(
( +
)+
( +
)+ (
( )
+
(
Frmula de recurrencia
119
Programacin:
Interfaz grfica propuesta
y
.
y
.
120
121
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma link "PERFGRAP"
#pragma resource "*.dfm"
#include <math.h>
double Y[20], X[20], h, a, b;
int k;
TForm1 *Form1;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn euler
void __fastcall TForm1::Button1Click(TObject *Sender)
{
h=Edit1->Text.ToDouble();
X[0]=Edit2->Text.ToDouble();
Y[0]=Edit3->Text.ToDouble();
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]);
Edit5->Text=AnsiString(X[2]);
Edit6->Text=AnsiString(X[3]);
Edit7->Text=AnsiString(X[4]);
Edit8->Text=AnsiString(X[5]);
Edit9->Text=AnsiString(X[6]);
Edit10->Text=AnsiString(X[7]);
Edit11->Text=AnsiString(X[8]);
Edit12->Text=AnsiString(X[9]);
Edit13->Text=AnsiString(X[10]);
122
123
124
125
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.
Euler mejorado
)+ (
)+ (
))
Euler modificado
, evitando despejar.
1. Poner de la forma:
(
+
(
126
)+
))
Considrese
(
))
Ejemplo:
( )
+
Poner en la forma
( )
+
(
( )
(
(
))
( ))
(
)))
127
Programacin
Interfaz grfica propuesta
y
.
128
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma link "PERFGRAP"
#pragma resource "*.dfm"
#include <math.h>
double Y[20], X[20], h, k1, k2;
int k;
TForm1 *Form1;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn calcular
void __fastcall TForm1::Button1Click(TObject *Sender)
{
h=Edit1->Text.ToDouble();
X[0]=Edit2->Text.ToDouble();
Y[0]=Edit3->Text.ToDouble();
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);
}
Edit4->Text=AnsiString(X[1]);
Edit5->Text=AnsiString(X[2]);
Edit6->Text=AnsiString(X[3]);
Edit7->Text=AnsiString(X[4]);
Edit8->Text=AnsiString(X[5]);
Edit9->Text=AnsiString(X[6]);
129
130
//botn reset
void __fastcall TForm1::Button3Click(TObject *Sender)
{
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();
Form1->Visible=false;
Form1->Visible=true;
}
//----------------------------------------------------------------
131
( )
( )
* () es el orden de la derivada, no
confundir con exponente.
Considerese
(
para
)
)(
) +
(
) +
)(
+
( )
( )
( )
[ (
+
)]
( )
132
Sustituyendo ( ) y ( ) en ( )
(
)+
)]
( )
Ecuacin de recurrencia
)) son iguales a la
Ejemplo:
Sea
[ +
[ +
(
+
+
(
)+
+
)+
+
[
]
]
133
Programacin
Interfaz grfica propuesta:
134
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma link "PERFGRAP"
#pragma resource "*.dfm"
#include <math.h>
double Y[20], X[20], h,a,b;
int k;
TForm1 *Form1;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn calcular
void __fastcall TForm1::Button1Click(TObject *Sender)
{
h=Edit1->Text.ToDouble();
X[0]=Edit2->Text.ToDouble();
Y[0]=Edit3->Text.ToDouble();
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
136
137
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 .
( )
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.
)
[
( ), es decir,
( )
constante.
( )
Ecuacin de difusin.
141
(
(
+
(
Elpticas
Ecuacin de Poisson
(
)
+
+
+
Mtodo de Jacobi
(
((
) +(
) +(
) +(
+(
) +(
) )
Mtodo de Gauss-Seidel
(
((
+(
) )
142
Programacin
Interfaz propuesta:
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
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
#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;
//---------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------//botn Jacobi
void __fastcall TForm1::Button1Click(TObject *Sender)
{
A[0][1]=Edit1->Text.ToDouble();
A[0][2]=Edit2->Text.ToDouble();
A[0][3]=Edit3->Text.ToDouble();
A[1][0]=Edit4->Text.ToDouble();
A[2][0]=Edit9->Text.ToDouble();
A[3][0]=Edit14->Text.ToDouble();
A[1][4]=Edit8->Text.ToDouble();
A[2][4]=Edit13->Text.ToDouble();
A[3][4]=Edit18->Text.ToDouble();
A[4][1]=Edit19->Text.ToDouble();
A[4][2]=Edit20->Text.ToDouble();
A[4][3]=Edit21->Text.ToDouble();
for(i=1;i<=3;i++){
for(j=1;j<=3;j++)
145
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]);
Edit6->Text=AnsiString(A[1][2]);
Edit7->Text=AnsiString(A[1][3]);
Edit10->Text=AnsiString(A[2][1]);
Edit11->Text=AnsiString(A[2][2]);
Edit12->Text=AnsiString(A[2][3]);
Edit15->Text=AnsiString(A[3][1]);
Edit16->Text=AnsiString(A[3][2]);
Edit17->Text=AnsiString(A[3][3]);
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{
Edit22->Text=AnsiString(A[1][1]);
Edit23->Text=AnsiString(A[1][2]);
Edit24->Text=AnsiString(A[1][3]);
Edit25->Text=AnsiString(A[2][1]);
Edit26->Text=AnsiString(A[2][2]);
Edit27->Text=AnsiString(A[2][3]);
Edit28->Text=AnsiString(A[3][1]);
Edit29->Text=AnsiString(A[3][2]);
Edit30->Text=AnsiString(A[3][3]);
146
if(jacobi<2){
Label3->Caption="Jacobi "+ AnsiString(jacobi)+" iteracin. Error=
"+ FormatFloat("0.##########", error1);}
else{
Label3->Caption="Jacobi "+AnsiString(jacobi)+" iteraciones. Error=
"+ FormatFloat("0.##########", error1);}
}
if(w==0){w=1;}
jacobi++;
}
//---------------------------------------------------------------//botn Gauss
void __fastcall TForm1::Button2Click(TObject *Sender)
{
B[0][1]=Edit1->Text.ToDouble();
B[0][2]=Edit2->Text.ToDouble();
B[0][3]=Edit3->Text.ToDouble();
B[1][0]=Edit4->Text.ToDouble();
B[2][0]=Edit9->Text.ToDouble();
B[3][0]=Edit14->Text.ToDouble();
B[1][4]=Edit8->Text.ToDouble();
B[2][4]=Edit13->Text.ToDouble();
B[3][4]=Edit18->Text.ToDouble();
B[4][1]=Edit19->Text.ToDouble();
B[4][2]=Edit20->Text.ToDouble();
B[4][3]=Edit21->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]);
Edit6->Text=AnsiString(B[1][2]);
Edit7->Text=AnsiString(B[1][3]);
Edit10->Text=AnsiString(B[2][1]);
Edit11->Text=AnsiString(B[2][2]);
Edit12->Text=AnsiString(B[2][3]);
Edit15->Text=AnsiString(B[3][1]);
Edit16->Text=AnsiString(B[3][2]);
Edit17->Text=AnsiString(B[3][3]);
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{
Edit22->Text=AnsiString(B[1][1]);
Edit23->Text=AnsiString(B[1][2]);
Edit24->Text=AnsiString(B[1][3]);
Edit25->Text=AnsiString(B[2][1]);
Edit26->Text=AnsiString(B[2][2]);
Edit27->Text=AnsiString(B[2][3]);
Edit28->Text=AnsiString(B[3][1]);
Edit29->Text=AnsiString(B[3][2]);
Edit30->Text=AnsiString(B[3][3]);
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
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)
150