Manual de Teoria y Codigos de Metodos Numericos C++

Universidad Autnoma de
Chiapas
Facultad de Ingeniera
Ingeniera Civil
Programacin
Apuntes de Mtodos Numricos

Por Alumnos de 2 A
Por Alumnos de 2 A
NDICE
1. Metodo de Biseccion. (Equipo 1).......pag. 2

2. Mtodo de Newton Raphson. (Equipo 2)..pag. 17
3. Metodo de Ferrari: Solucion de ecuaciones
de cuarto grado. (Equipo 3)........pag. 41
4. Metodo de Mller. (Equipo 4).....pag. 57
5. Solucion de ecuaciones lineales por el mtodo
de eliminacin de Gauss. (Equipo 5)....pag. 79
6. Inversion de matrices por el mtodo de
descomposicin de L.U. (Equipo 6)......pag. 156
7. Interpolacion polinomial por el mtodo de
diferencias divididas. (Equipo 7)pag. 180
8. Primer derivada por mtodos numricos. (Equipo 9).....pag. 196
9. Segunda derivada numrica. (Equipo 10)....pag. 205
10.
Integracion numrica por el mtodo de

Simpson tres octavos. (Equipo 11)...........pag. 228
11.
Solucion de ecuaciones diferenciales por

el mtodo de Taylor(Equipo 12)...............pag. 239
12.
Logica difusa. (Equipo 13)......pag. 264
13.
Metodo de Newton para ecuaciones

no lineales. (Equipo14)......................pag. 269
14.
Resolucion de ecuaciones diferenciales

Ordinarias por el mtodo de
Runge-Kutta. (Equipo15).......pag. 283
15.
Logica difusa. (Equipo 16)..pag. 290

1
1. Mtodo de Biseccin
Si f es una funcin continua sobre el intervalo [a;b] y si f(a).f(b)<0,

entonces f debe tener un cero en (a;b). Dado que f(a).f(b)<0, la funcin cambia
de signo en el intervalo [a;b] y, por lo tanto, tiene por lo menos un cero en el
intervalo. sta es una consecuencia del teorema del valor intermedio para
funciones continuas.
El mtodo de biseccin explota esta idea ya que los extremos del
intervalo se van a ir acercando sistemticamente hasta obtener un intervalo de
longitud suficientemente pequea en el que se localiza un cero. El proceso de
decisin para subdividir el intervalo consiste en tomar el punto medio del
intervalo c = (a+b)/2 y luego analizar las tres posibilidades que pueden darse:
Si f(a) y f(c) tienen signos opuestos, entonces hay un cero en
Si f(c) y f(b) tienen signos opuestos, entonces hay un cero en
Si f(c)=0, entonces c es un cero.
[a;c].
[c;b].
Si ocurre la primera opcin, o bien la segunda, entonces se ha encontrado
un intervalo de mitad de ancho que el original que contiene una raz. Para
continuar el proceso, se renombra el nuevo intervalo ms pequeo como [a;b] y
se repite el proceso hasta que el intervalo sea tan pequeo como se desee.
Puesto que el proceso de biseccin genera una sucesin de intervalos
encajados, con sus correspondientes puntos medios, se usar la siguiente
notacin para tener registro de los detalles del proceso:
[a1;b1] es el intervalo de partida y c1=(a1+b1)/2 es su punto medio.
[a2;b2] es el segundo intervalo y c2=(a2+b2)/2 es su punto medio;

el intervalo [a2;b2] es la mitad de ancho que [a1;b1].
Despus de llegar al intervalo [an;bn], en el que tambin se

localiza un cero y cuyo punto medio est dado por c n=(an+bn)/2, se
construye el intervalo [an+1;bn+1], en el que tambin se localiza un cero, y
que mide la mitad que [an;bn]
Anlisis del error:

Con el objeto de analizar el mtodo de la biseccin, se llamar [a i;bi],
con i = 1, 2, 3, , a los intervalos que surgen en el proceso. Se pueden hacer
las siguientes observaciones sobre estos nmeros:
a1a2...anb1
la sucesin {an} converge porque es creciente

y est acotada superiormente.
b1b2...bna1
la sucesin {bn}
decreciente y est acotada inferiormente.
converge
porque
es
2
bn+1-an+1
= (bn-an)/2, n1
n-an)=
(b1-a1)/2(n-1) n1. (*)
Si se aplica lmite a esta ltima igualdad se obtiene:
Entonces, resulta que los lmites de ambas sucesiones son iguales:
Tomando el lmite en la desigualdad f(an).f(bn) 0, encontramos que

[f(r)]2 0, por lo tanto, debe ser f(r) = 0.
Se llamar [an,bn] al intervalo obtenido en el paso n-1. Si en este momento
se detiene el proceso, la raz se encontrar en ese intervalo. En este paso, la
mejor aproximacin ser el punto medio del intervalo,
El error en el paso n es:
(1) Dado que r (la raz buscada) est en una de las dos mitades del
intervalo [an, bn], la distancia del punto medio del intervalo a r debe ser
menor o igual que la mitad de la longitud del intervalo.
(2) Por la igualdad demostrada en (*)
Ventajas y desventajas:
Una gran ventaja de este mtodo es que siempre converge para
funciones continuas f(x). Adems, proporciona el tamao exacto del intervalo
en cada iteracin (en ausencia de errores de redondeo). Para aclarar esto, se
puede observar que en este mtodo despus de cada iteracin el tamao del
intervalo se reduce a la mitad; despus de n iteraciones, el intervalo original se
3
habr reducido 2n veces. Por lo anterior, si el intervalo original es de tamao M

y el criterio de convergencia aplicado al valor absoluto de la diferencia de dos
aproximaciones sucesivas es , se puede saber de antemano el nmero de
iteraciones que se requieren:
No obstante, una de las grandes desventajas que presenta este mtodo

es su velocidad de convergencia, la cual es bastante baja.
Orden de convergencia
Un algoritmo converge linealmente si existe una constante positiva K<1 tal
Que para todo n suficientemente grande. Tal K recibe el nombre de factor de

convergencia.
Como se puede observar, el mtodo de la biseccin es un mtodo lineal
debido a que el error en la iteracin siguiente es la mitad del error de la
iteracin previa solamente.
Aproximacin inicial y criterios de convergencia

El mtodo de la biseccin depende de la determinacin de un intervalo
inicial [a;b] en el que f(a) y f(b) tengan distinto signo. Una vez encontrado este
intervalo, no importa lo grande que sea, se podr empezar a iterar hasta que se
encuentre una raz con la precisin deseada. Por esta razn, se dice que este
mtodo es globalmente convergente.
Sin embargo, si f(x)=0 tiene varias races en [a;b], entonces se debe
encontrar un intervalo de partida distinto para hallar cada raz y no suele ser
fcil hallar estos intervalos ms pequeos en los que el signo de f(x) cambia.
En la seccin Conceptos bsicos se encuentran otros mtodos que
requieren, como garanta de su convergencia, que el punto inicial est cerca de
la raz buscada, por lo que se dice que son localmente convergentes. Estos
mtodos suelen converger ms rpidamente que los mtodos globales, de
manera que existen algoritmos hbridos que empiezan con un mtodo de
convergencia global y, cuando las aproximaciones obtenidas en las distintas
iteraciones se hallan cerca de la raz, cambian a un mtodo de convergencia
local.
Comprobacin de la convergencia
4
Es imprescindible establecer un criterio de parada para que el algoritmo

detenga las iteraciones cuando haya obtenido una aproximacin
suficientemente precisa
Como el objetivo es resolver f(x)=0, el valor xn debera verificar que:
As, el proceso iterativo producir puntos Pi= (xi; f(xi)) hasta que el ltimo
punto Pn se encuentre en la banda horizontal comprendida entre las rectas de
ecuaciones y= e y=-.
Otro criterio de parada involucra las abscisas. Se trata de determinar si la

sucesin {xn} converge y, para ello, se dibujan dos rectas verticales de
ecuaciones x=P+ y x=P- a cada lado de x=P. De esta manera, el proceso se
detendr cuando Pn est entre ambas rectas.
A continuacin mostramos la interfaz del programa, para luego la programacin

en builder C++, para poder encontrar lo raz de una funcin f(x) cualquiera.
Presionamos el botn de entrada i directamente nos manda a la siguiente

interfaz.
A continuacin un ejemplo del interfaz del programa con un polinomio

(x^4+3x^3 2 = 0).
6
Despus de haber realizado varias iteraciones llegamos a la raz aproximada

como se muestra en la interfaz.
Y para estar seguros de que es una raz del polinomio se muestra en la

siguiente grafica que efectivamente existe una aproximacin a la raz obtenida.
Esta programacin nos ayudara a encontrar una sola raz real de un polinomio
en caso de que exista y para ya no seguir haciendo laboriosos procedimientos
en esta interfaz es muy til porque solo introducimos el polinomio y despus de
unas cuantas iteraciones nos dice la raz. En caso de que este mtodo no
funcione hay muchos tipos de mtodos para encontrar una raz de un
polinomio.
A continuacin la programacin de la interfaz del mtodo de Biseccin.
Cdigos de programacin:
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
#include "Unit3.h"
//--------------------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
#include <math.h>
double a,b,c,d,e,p,q,Fx1,Fx2,Fx3,Fx4,Fx5,Fxl,Fr,Fxm,r,prod, i=1,x,h,t,j,l,m,
inicio,k,y,por;
//--------------------------------------------------------------------------__fastcall TForm2::TForm2(TComponent* Owner)

9
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button1Click(TObject *Sender)

{
//hablitando grafica
Button1->Enabled=true;
a=Edit1->Text.ToDouble();
b=Edit2->Text.ToDouble();
c=Edit3->Text.ToDouble();
d=Edit4->Text.ToDouble();
e=Edit5->Text.ToDouble();
p=Edit6->Text.ToDouble();
q=Edit7->Text.ToDouble();
h=Edit8->Text.ToDouble();
t=Edit9->Text.ToDouble();
j=Edit10->Text.ToDouble();
Fx1=a*(pow(p,4))+b*(pow(p,3))+c*(pow(p,2))+d*p+e;
Edit11->Text=AnsiString(Fx1);
Fx2=a*(pow(q,4))+b*(pow(q,3))+c*(pow(q,2))+d*q+e;
Fx3=a*(pow(h,4))+ b*(pow(h,3))+c*(pow(h,2))+d*h+e;
10
Fx4=a*(pow(t,4))+b*(pow(t,3))+c*(pow(t,2))+d*t+e;
Fx5=a*(pow(j,4))+b*(pow(j,3))+c*(pow(j,2))+d*j+e;
}
//---------------------------------------------------------------------------

{
l=Edit16->Text.ToDouble();
Fxl=a*(pow(l,4))+b*(pow(l,3))+c*(pow(l,2))+d*l+e;
m=Edit17->Text.ToDouble();
Fxm=a*(pow(m,4))+b*(pow(m,3))+c*(pow(m,2))+d*m+e;
r=(l+m)/2;
Edit18->Text=AnsiString(r);
Fr=a*(pow(r,4))+b*(pow(r,3))+c*(pow(r,2))+d*r+e;
Label15->Caption=AnsiString(r);
Label13->Caption=AnsiString(i);
i++;
}
11
//--------------------------------------------------------------------------void __fastcall TForm2::Button3Click(TObject *Sender)

{
prod=Fxl*Fr;
Edit19->Text=AnsiString(prod);
por=((m-l)/m)*100;
Edit20->Text=AnsiString(por);
Label16->Caption="Eso es todo Margaritos...!!!";
if(prod >0 ){
Edit16->Text="";
}
if(prod <0){
Edit17->Text="";
}
}
{
Form3->Show();
Form3->Canvas->Pen->Color=clGreen;
Form3->Canvas->Pen->Width=2;
Form3->Canvas->PenPos=TPoint(0,350);
Form3->Canvas->LineTo(1300,350);
12
for(x=-30;x<=30;x++){
Form3->Canvas->PenPos=TPoint(650+x*10,355);
Form3->Canvas->LineTo(650+x*10,345);
for(y=-30;y<=30; y++){
Form3->Canvas->PenPos=TPoint(645,350+y*10);
Form3->Canvas->LineTo(655,350+y*10);
}
Form3->Canvas->Pen->Color=clYellow;
x=-650;
Form3->Canvas->PenPos=TPoint(650+x,35010*(a*pow(x/10,4)+b*pow(x/10,3)+c*pow(x/10,2)+d*x/10+e));
for(x=-650;x<=650;x++){
Form3->Canvas->LineTo(650+x,35010*(a*pow(x/10,4)+b*pow(x/10,3)+c*pow(x/10,2)+d*x/10+e));
}
}
}
{
a=0;
b=0;
c=0;
13
d=0;
e=0;
p=0;
q=0;
r=0;
h=0;
t=0;
j=0;
Fx1=0;
Fx2=0;
Fx3=0;
Fx4=0;
Fx5=0;
Fr=0;
i=1
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="";
14
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
Label13->Caption="";
}
{
Close();
}
//---------------------------------------------------------------------------
15
Cdigo de programacin:
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit3.h"
TForm3 *Form3;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
Close();
}
//---------------------------------------------------------------------------
16
2. Mtodo de Newton - Raphson

El mtodo de Newton
(tambin
Mtodo
Newton-
Raphson o de Newton-
Fourier). Es un mtodo
grfico y analtico de
de
llamado
optimizacin iterativo, el cual permite encontrar las races de una funcin f(x),
aplicando a 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.
Para esto se toma la recta tangente a la funcin en un punto prximo a la

solucin y se calcula el punto de corte de esa tangente con el eje de las X.
Este mtodo se basa en la interpretacin geomtrica de la derivada para
obtener la frmula de la recurrencia, para hacer las iteraciones.
Partiendo de una funcin (xn), cuya derivada es (xn) y recordando que:

(xn) = m, y m = tan = Cateto opuesto / Cateto adyacente
Por lo consiguiente, la frmula de la derivada se expresa de la siguiente forma:
Despejando Xn+1 en la ecuacin obtenemos:
17
Conocida como la frmula de Newton Raphson.

Geomtricamente, este mtodo trabaja mediante un valor de arranque, que
evala a la derivada en ese punto, est pendiente al cortar con el eje de las x
nos da un nuevo punto Xn+1, punto el cual est cada vez ms cerca de la raz, y
este nuevo nos dar un nuevo valor que est mucho ms prximo que el
anterior, y as sucesivamente hasta acercarse a la raz real de la funcin (xn).
La frmula vuelve a realizar el mismo

proceso, el cual brinda un nuevo valor,
ms cercano a la raz, por eso se llama
de recurrencia o proceso iterativo.
Como se observa en la grfica, se va

formando como una especie de zigzag,
donde se nota que los nuevos puntos son
ms aproximados la raz de la funcin.
CASOS ESPECIALES.
o
o
o
Cuando son races mltiples, las del polinomio.

Cuando la derivada de la funcin es muy complicada de resolver.
Cuando existe divergencia en el mtodo.
18
Cuando se encuentran un punto crtico o de inflexin, debido a al valor

inicial X, donde se tendra una divisin por cero, o debido a la naturaleza
de la funcin.
Si observamos la grfica, se puede

notar los diferentes puntos de
inflexin de la funcin, lo cual hace
divergir el mtodo.
ERROR RELATIVO ENTRE DOS APROXIMACIONES SUCESIVAS.

Con lo cual se toma el error relativo como si la ltima aproximacin fuera el
valor exacto. Se detiene el proceso iterativo cuando este error relativo es
aproximadamente menor que una cantidad fijada previamente.
Ea = | (Xi-Xi-1/
Xi)* 100|
VENTAJAS.
Robustez
velocidad al encontrar la
raz
No
intervalos,
trabaja
en
sino
en
iteraciones.
Su indicador de efectividad es la repeticin de cifras (convergencia).
DESVENTAJAS.
Lenta convergencia debida a la naturaleza de una funcin en particular.
19
Cuando un punto de inflexin, (xn) = 0, ocurre en la cercana de una

raz.
No existe un criterio general de convergencia.
Tener un valor suficientemente cercano a la raz.
Apoyarse de herramientas grficas.
Conocimiento del problema fsico.
Evaluacin de la derivada.
PROGRAMACIN DEL MTODO.

Interfaz propuesta.
Acciones por botn.

Interfaz 1:
Botn ENTRAR.
Permite accesar al programa principal donde se construy el mtodo y a una

lista de recomendaciones.
Botn SALIR.
Permite salir y cerrar el programa.

Interfaz 2:
Botn CALCULAR RAZ.

20
Lee los valores de x4, x3,
x2, x y la constante, el
valor inicial propuesto para
nuestra
nmero de iteraciones que
realizara el programa.
Calcula la derivada de la
funcin (xn) segn
raz
el
los valores propuestos en las primeras casillas, dentro de una estructura for,
evala a (xn) y a (xn) con el valor inicial, si uno de ellas es = 0 el programa
cargara un error en una venta y determinara que la funcin diverge (debido a
diversos puntos de inflexin de (xn)) y no es posible implementar el mtodo,
en caso de que no sea as y (xn) 0 el proceso continua y calcula la

ecuacin de 1 en 1, valor por valor.
Sumando 1 en el contador de iteraciones, dato que se imprime en el Memo 1
ubicado en el Form3. Cuando los datos se vuelven a repetir es seal de que el

mtodo converge, entonces imprime el valor o raz (dato capturado en el
Memo2) que hace o aproxima a cero a (xn), considerando el porcentaje de
error (tabulado en el Memo7).
El botn, tambin cumple la funcin de activar el botn MOSTRAR
TABULACIN y al RadioGroup GRFICA.
Botn MOSTRAR TABULACIN.
Este botn acta como vinculo al Form3, donde se tabulan los siguientes
datos; nmero de iteraciones, valor propuesto y los valores obtenidos
por la ecuacin, la funcin origina evaluada, la funcin derivada
evaluada, el resultado del mtodo evaluado con los 3 datos anteriores a
este, y en el ltimo memo, el porcentaje de error por iteracin.
RadioGroup.
Radio Button 1 GRAFICA NORMAL
Muestra la grfica del polinomio, segn la funcin, en modo estndar
Radio Button 2 GRAFICA ZOOM
Muestra la grfica de la funcin en un 200% de acercamiento, respecto a

la grafica normal.
21
Radio Button 3 GRAFICA MEGA ZOOM
Muestra la grfica en un 300% de acercamiento, respecto a la grfica normal.
Botn REINICIAR.
Borra todos los datos y procesos guardados en el programa, y desactiva

los botones MOSTRAR TABULACIN y al grupo GRFICA,
elementos que se activaran nuevamente al introducir datos y oprimir el
botn CALCULAR RAZ.
Botn YA TENEMOS 10
Cierra la interfaz 2, sin guardar ningn dato, para asi poder a ingresar
nuevamente a l, mediante la interfaz 1.
ALGORITMO.
Algoritmo bsico, del comportamiento del programa:
1. Introducir la ecuacin al resolver f(x).

2. Introducir la derivada de la funcin a resolver f(x).
3. Introducir el mximo nmero de iteraciones Nmax.
4. Introducir el valor mximo del error porcentual a aproximado Tmax.
5. Seleccionar una aproximacin inicial cerca de la raz Xi.
6. Inicializar el contador i=1.
7. Mientras que i<= Nmax continuar los pasos.
8. Calcular la aproximacin a la raz mediante la ecuacin predictiva de
Newton Raphson.
9. Calcular el error porcentual aproximado.
10. Verificar que se cumpla la condicin |ep|<=Tmax. Si se cumple,
entonces sea encontrado la aproximacin final, si no ir al siguiente paso.
11. Hacer i=i+1.
12. Verificar si se cumple la condicin i<=Nmax. Si despus de Nmax

iteraciones no se ha cumplido que |ep|<=Tmax, el mtodo ha fracasado.
Terminar la ejecucin del logaritmo.
22
13. Imprimir los resultados.
CDIGO DE PROGRAMACIN.
UNIT 1.
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
//Incluyendo a los Unit 2 y 8
#include "Unit1.h"
#include "Unit2.h"
#include "Unit8.h"
#pragma resource "*.dfm" TForm1 *Form1;
//---------------------------------------------------------------------------
fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)
{
}
//--------------------------------------------------------------------------23
void
fastcall TForm1::Button1Click(TObject *Sender)
{
//Vinculacin del interfaz 1 a la 2
Form2->Show();
}
//--------------------------------------------------------------------------void
{
//Botn que cierra el programa por completo
Close();
}
//---------------------------------------------------------------------------
UNIT 2.
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
//Incuyendo los Unit del 3 al 7
#include "Unit2.h"
#include "Unit3.h"
#include "Unit4.h"
#include "Unit5.h"
#include "Unit6.h"
24
#include "Unit7.h"
//Incluyendo el diccionario matemtico
#include <math.h>
//Declarando variables double
double a, b, c, d, e, xn, it, da, db, dc, dd, de,x,y; double xn1, re, err, n, s,fx, dfx,
y1,y2,y3,y4,y5,y6,y7 ;
TForm2 *Form2;
//--------------------------------------------------------------------------fastcall TForm2::TForm2(TComponent* Owner)

: TForm(Owner)
{
}
//--------------------------------------------------------------------------void
{
//Botn que cierra el interfaz 2
Close();
}
25
//--------------------------------------------------------------------------void
{
// Programando Reset
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
RadioGroup1->Enabled=false;
Button2->Enabled=false;
RadioGroup1->ItemIndex=-1;
Edit1->SetFocus();
}
//--------------------------------------------------------------------------void
26
//Habilitar Graficas y Tabla de Iteraciones

RadioGroup1->Enabled=true;
//Leer los datos

xn=Edit6->Text.ToDouble();
it=Edit7->Text.ToDouble();
//Derivada de la funcin
da=a*4;
db=b*3;
dc=c*2;
dd=d;
de=0;
//Limpieza de los cuadros de Memos del "Form3"

Form3->Memo1->Clear();
27
//Habilitar grfica y Tabla de Iteraciones.
RadioGroup1->Enabled=true;
//Iniciando el nmero de Iteraciones

for(n=1;n<=it;n++)
{
Form3->Memo1->Lines->Add(n);//Agregando a iteraciones al Memo1
//Calculando la funcion F(x)
y4=a*pow(xn,4);
y3=b*pow(xn,3);
y2=c*pow(xn,2);
y1=d*xn;
fx=y4+y3+y2+y1+e;
28
Form3->Memo3->Lines->Add(fx);//Enviando resultados de la funcion al Memo3.
//Calculando la Deriva de la funcin F(x)

y5=da*pow(xn,3);
y6=db*pow(xn,2);
y7=dc*xn;
dfx=y5+y6+y7+dd;
Form3->Memo4->Lines->Add(dfx);//Enviando resultados de la derivada al
Memo4.
//Condicionando la impresin de la raz

if(dfx==0){
Form7->Show();
}
else{
// Calculando xn
Form3->Memo2->Lines->Add(xn);//Enviando xn al Memo2
//Calculando la divisin
s=fx/dfx;
29
Form3->Memo5->Lines->Add(s);//Enviando el cociente al Memo5.
//calculando xn+1
xn1= xn- s;
Form3->Memo6->Lines->Add(xn1);//Enviando xn+1 al Memo6
// Calculando Porcentaje de Error

err=((xn1-xn)/xn1)*100;
Form3->Memo7->Lines->Add(err); //Enviando resultado de excentricidad a
Memo7
//Condicionando escritura de rai
if (err<1&&err>-1)
{
//Escribiendo la raiz
Label10->Caption=AnsiString(xn);
}
xn=xn1;
}
}
}
//--------------------------------------------------------------------------void

30
{
//Mostrando tabulacin
Form3->Show();
}
//--------------------------------------------------------------------------void
fastcall TForm2::RadioGroup1Click(TObject *Sender)
// Grafica Normal
if(RadioGroup1->ItemIndex==0)
Form4->Show();
Form4->Canvas->Pen->Color=clBlack;
for(x=-65;x<=65;x++)
{
31
}
for(y=-35;y<=35;y++)}
{
Form4->Canvas->Pen->Color=clBlue;
x=-650;
Form4->Canvas->PenPos=TPoint(650+x,350-10*(a*pow(x/10,4)
+b*pow(x/10,3)+c*pow(x/10,2)+d*x/10+e));
for(x=-650;x<=650;x++)
{
Form4->Canvas->LineTo(650+x,350-10*
(a*pow(x/10,4)+b*pow(x/10,3)+c*pow(x/10,2)+d*x/10+e));
}
// Grafica ZOOM
32
Form5->Show();
Form5->Canvas->Pen->Color=clBlack; Form5->Canvas->Pen->Width=1;
for(x=-32;x<=32;x++)
{
}
for(y=-17;y<=17;y++)
{
}
x=-650;
Form5->Canvas->PenPos=TPoint(650+x,350-20*
(a*pow(x/20,4)+b*pow(x/20,3)+c*pow(x/20,2)
+d*x/20+e));
33
for(x=-650;x<=650;x++)
{
Form5->Canvas->LineTo(650+x,35020*(a*pow(x/20,4)+b*pow(x/20,3)+c*pow(x/20,2)
+d*x/20+e));
}
//Grafica MEGAZOOM
{
Form6->Show();
}
for(x=-16;x<=16;x++)
{
}
34
for(y=-8;y<=8;y++)
{
}
x=-650;
Form6->Canvas->PenPos=TPoint(650+x,35040*(a*pow(x/40,4)+b*pow(x/40,3)+c*pow(x/40,2)
+d*x/40+e));
for(x=-650;x<=650;x++)
{
Form6->Canvas->LineTo(650+x,35040*(a*pow(x/40,4)+b*pow(x/40,3)+c*pow(x/40,2)
+d*x/40+e));
}
}
//---------------------------------------------------------------------------
UNIT 3.
//--------------------------------------------------------------------------35
#include <vcl.h>
#pragma hdrstop
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------

: TForm(Owner)
{
}
//--------------------------------------------------------------------------void
{
//Botn cerrar
Close();
}
//-------------------------------------------------------------------------UNIT 4.
//--------------------------------------------------------------------------#include <vcl.h>
36
#pragma hdrstop
#include "Unit4.h"
: TForm(Owner)
{
}
//--------------------------------------------------------------------------void
{
//Botn cerrar
Close();
}
//--------------------------------------------------------------------------UNIT 5.
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit5.h"
//--------------------------------------------------------------------------37
: TForm(Owner)
{
}
//--------------------------------------------------------------------------void
{
//Botn cerrar
Close();
}
//--------------------------------------------------------------------------UNIT 6.
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit6.h"
//--------------------------------------------------------------------------38

: TForm(Owner)
{
}
//--------------------------------------------------------------------------void
{
//Botn cerrar
Close();
}
//-----------------------------------------------------------------------UNIT 7.
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit7.h"
: TForm(Owner)
{
}
39
//--------------------------------------------------------------------------UNIT 8.
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit8.h"
: TForm(Owner)
{
}
//--------------------------------------------------------------------------void
{
//Botn cerrar
Close();
}
//--------------------------------------------------------------------------De esta manera es como se programa el Mtodo de Newton Raphson en
leguaje C++.
40
3. Mtodo de Ferrari: Solucin de

ecuaciones de cuarto grado.
Una ecuacin de cuarto grado o ecuacin cuartica con una incgnita es una
ecuacin algebraica que se puede poner bajo la forma cannica: donde a, b, c,
d y e (siendo) son nmeros que pertenecen a un cuerpo, usualmente a los
reales o los complejos. Sea K un cuerpo, donde se pueden extraer races
cuadradas y cbicas (y por lo tanto tambin de cuarto orden, pues equivale a
extraer races cuadradas dos veces seguidas). En este cuerpo, es posible
factorizar por todo a, y la identidad siguiente es vlida:
En un cuerpo algebraicamente cerrado, se sabe que todo polinomio de grado 4
tiene cuatro races. Es el caso del cuerpo de los complejos, segn el Teorema
Fundamental del lgebra. El mtodo siguiente permite obtener las cuatro races
al mismo tiempo. Este mtodo es llamado "mtodo de Descartes", pues fue
dado por el matemtico francs Ren Descartes (1596-1650) en el ao de
1637 en su clebre libro "La Geometra". Aunque existan diferentes mtodos
para resolver las ecuaciones cuarticas, algunos son: mtodo de Ferrari, mtodo
de Descartes, mtodo de Euler, mtodo de Lagrange, mtodo de Alcal,
etctera.
41
Resolucin algebraica de la ecuacin general de cuarto grado:

Ax + Bx + Cx + Dx + E=0
1. SOLUCIN ALGEBRAICA
Tenemos una ecuacin de cuarto grado:
Ax + Bx + Cx + Dx + E=0
Ferrari menciona que el valor de A debe ser igual a 1, en caso contrario,
tendremos que dividir el polinomio entre A. Y quedar de la siguiente manera:
x + B/Ax + C/Ax + D/Ax + E/A=0
Tambin podemos escribir la ecuacin de esta forma:
x + ax + bx + cx+d=0
El mtodo de Ferrari nos proporciona una RESOLVENTE.
2. RESOLVENTE DE FERRARI
y -by + (ac-4ad)y +(4bd-ad-c )=0
Podemos cambiar la ecuacin por la siguiente forma:
x +ax +a x+ a=0
3. CUBICA DE FERRARI
En donde los valores tomados de a, b, c y d; son de la ecuacin de cuarto
grado
x + ax + bx + cx+d=0
4. Ya obtenida la cbica...
Para obtener las races de la ecuacin de cuarto grado. Usaremos el mtodo
de Cardano que consiste en calcular:
42
De la ecuacin anterior: x +ax +ax+a=0

5. DONDE:
a= (-b)
a=(ac-4d)
a=4bd-ad-c
6. RESOLVER LAS SIGUIENTES OPERACIONES

T=R-Q-R
Q=3a-a/9
R=9aa-27a-2a
S=R+Q-R
7. Obtenemos una raz real a partir de esta frmula de Cardano.
X=S+T-(1/3)a
Con esta raz regresamos al mtodo de Ferrari.
8. Ya obtenida una raiz real, partimos de las siguientes frmulas:

e=(a/4)-b+y
Si e0 utilizar:
f=ay-2c/e
Si e=0 utilizar:
f=(y/4)-d
43
9. De las dos ecuaciones dadas anteriormente de "f" y "e". Obtenemos

dos ecuaciones cuadrticas.
x+(a/2-e)x+(y/2)-f)
x+(a/2+e)x+(y/2+f)
10. Con estas dos ecuaciones cuadrticas podemos utilizar sencillamente
la frmula general.
x=-b/2a(-b^2-4ac)^1/2
En donde nos dar dos races reales, y dos races imaginarias
PROGRAMA:
44
Acciones por Botn
Formulario 1:
Botn Entrar:
El botn te manda a un segundo formulario donde podrs calcular las races de

un polinomio de cuarto grado.
Botn Salir:
El botn cierra por completo el programa.
Lnea de Programacin:
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
: TForm(Owner) { }
{
Form2->Show();
}
{
Close();
}
45
//---------------------------------------------------------------------------
Acciones por Botn
Botn Races:
El botn lee los datos que ingresamos y realiza una serie de pasos para que
nos encuentre las races del polinomio que estamos buscando y nos ponga los
resultados en los componentes Edit que programamos anteriormente.
Botn Regresar:
El botn nos regresar al men principal, usualmente lo utilizaremos para salir

del programa.
46
Lnea de Programacin:
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include <math.h>
#include <stdio.h>
double A,B,C,D,E,a,b,c,d,a1,a2,a3,q1,q2,q3,r1,r2,r3,r4,Q,R,S,s1,s2,s3,s4,s5;
double t1,t2,t3,t4,t5,T,y,e1,e2,e,f1,f2,f3,f,u1,u,v1,v,w1,w,z1,z,g1,g2,g3,g,i;
double x1,x2,x3,x4,y1,y2,y3,y4,Dis1,Dis2,Dis3,Dis4,Q1,R1,j,j2,o,o2,M,M1,M2,M3;
double M4,M5,M6,N,o1,o3;
TForm2 *Form2;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
A=Edit1->Text.ToDouble();
B=Edit2->Text.ToDouble();
C=Edit3->Text.ToDouble();
D=Edit4->Text.ToDouble();
E=Edit5->Text.ToDouble();
47
if(A!=0)
{
a=B/A;
b=C/A;
c=D/A;
d=E/A;
a1=-b;
a2=(a*c)-(4*d);
a3=(4*b*d)-((a*a)*d)-(c*c);
q1=a1*a1;
q2=3*a2;
q3=q1-q2;
Q=q3/9;
r1=2*(a1*a1*a1);
r2=9*(a1*a2);
r3=27*a3;
r4=r1-r2+r3;
R=r4/54;
Q1=Q*Q*Q;
R1=R*R;
if(R1<Q1)
{
j=sqrt(Q1);
j2=R/j;
o=acos(j2);
o1=sqrt(Q);
o2=o/3;
o3=a1/3;
y=(-2*o1*cos(o2))-(o3);
48
e1=(a*a)/4;
e2=abs(e1-b+y);
e=sqrt(e2);
}
else
{
M1=abs(R);
M2=R1-Q1;
M3=sqrt(M2);
M4=M1+M3;
M5=1/3;
M6=pow(M4,M5);
M=(-1*(R))*M6;
if(M==0)
{
N=0;
}
else
{
N=Q/a1;
}
y=(M+N)-(a1/3);
e1=(a*a)/4;
e2=abs(e1-b+y);
e=sqrt(e2);
}
if(e!=0)
{
f1=a*y;
f2=2*c;
f3=f1-f2;
49
f=f3/e;
i=1;
u1=a/2;
u=u1-e;
v1=y/2;
v=v1-f;
w1=a/2;
w=w1+e;
z1=y/2;
z=z1+f;
Dis1=(u*u)-(4*i*v);
if(Dis1==0)
{
x1=-u/2*i;
x2=x1;
y1=0;
y2=0;
Edit6->Text=AnsiString(x1);
Edit7->Text=AnsiString(y1);
}
if(Dis1>0)
{
x1=-u/2*i+sqrt(Dis1)/(2*i);
x2=-u/2*i-sqrt(Dis1)/(2*i);
y1=0;
y2=0;
50
}
if(Dis1>0&&u!=0)
{
x1=-u/2*i;
x2=-u/2*i;
y1=sqrt(-Dis1)/(2*i);
y2=-sqrt(-Dis1)/(2*i);
}
if(Dis1<0&&u==0)
{
x1=0;
x2=x1;
}
Dis2=(w*w)-(4*i*z);
if(Dis2==0)
{
x3=-w/2*i;
x4=x3;
y3=0;
y4=0;
51
}
if(Dis2>0)
{
x3=-w/2*i+sqrt(Dis2)/(2*i);
x4=-w/2*i-sqrt(Dis2)/(2*i);
y3=0;
y4=0;
}
if(Dis2>0&&w!=0)
{
x3=-w/2*i;
x4=-w/2*i;
}
if(Dis2<0&&w==0)
{
x3=0;
x4=x1;
52
}
}
if(e==0)
{
g1=y*y;
g2=g1/4;
g3=g2-d;
g=sqrt(g3);
i=1;
u1=a/2;
u=u1-e;
v1=y/2;
v=v1-g;
w1=a/2;
w=w1+e;
z1=y/2;
z=z1+g;
Dis3=(u*u)-(4*i*v);
if(Dis3==0)
{
x1=-u/2*i;
x2=x1;
y1=0;
y2=0;
53
}
if(Dis3>0)
{
x1=-u/2*i+sqrt(Dis3)/(2*i);
x2=-u/2*i-sqrt(Dis3)/(2*i);
y1=0;
y2=0;
}
if(Dis3>0&&u!=0)
{
x1=-u/2*i;
x2=-u/2*i;
}
if(Dis3<0&&u==0)
{
x1=0;
x2=x1;
54
}
Dis4=(w*w)-(4*i*z);
if(Dis4==0)
{
x3=-w/2*i;
x4=x3;
y3=0;
y4=0;
}
if(Dis4>0)
{
x3=-w/2*i+sqrt(Dis4)/(2*i);
x4=-w/2*i-sqrt(Dis4)/(2*i);
y3=0;
y4=0;
}
if(Dis4>0&&w!=0)
{
x3=-w/2*i;
x4=-w/2*i;
55
}
if(Dis4<0&&w==0)
{
x3=0;
x4=x1;
}
}
}
else
{
if(A==0)
{
Label13->Caption="No se puede realizar,es una ecuacin cbica!!";
}
}
}
{
Close();
}
//---------------------------------------------------------------------------
56
4. Mtodo de Mller
Este es un mtodo para encontrar las races de ecuaciones polinomiales
con races mltiples, de la forma general:
f n ( x) a0 a1 x a2 x 2 ....... an x n
Donde n es el orden del polinomio y las a son coeficientes constantes.

Continuando con los polinomios, estos cumplen con las siguientes reglas:
Para la ecuacin de orden n, hay n races reales o complejas. Se debe notar
que esas races no son necesariamente distintas.
Si n es impar, hay al menos una raz real.
Si las races complejas existen, existe un par conjugado.
Un predecesor del mtodo de Meller, es el mtodo de la secante o

mtodo de Newton Raphson, el cual obtiene races, estimando una proyeccin
de una lnea recta en el eje x, a travs de dos valores de la funcin (Figura 1).
El mtodo de Mller toma un punto de vista similar, pero requiere de tres
puntos para calcular la parbola, en otras palabras, proyecta una parbola a
travs de tres puntos (Figura 2).
El mtodo consiste en obtener los coeficientes de la parbola que pasa
por tres puntos elegidos, dichos coeficientes son sustituidos en la frmula
cuadrtica para obtener el valor o punto donde la parbola intercepta el eje x,
es decir, la raz estimada. La aproximacin se puede facilitar, si se escribe la
ecuacin de la parbola en una forma conveniente .En forma conveniente esta
sera:
f 2 ( x) a( x x2 ) 2 b( x x2 ) c
Ec.1
Una de las mayores ventajas de este mtodo, es que al trabajar con la

frmula cuadrtica es posible localizar tanto races reales como races
complejas.
57
FIG 1
FIG. 2
QU SON LAS RAICES DE UN POLINOMIO?

La raz de un polinomio es un nmero tal que hace que el polinomio
valga cero. Es decir, que cuando resolvamos un polinomio a cero, las
soluciones son las races del polinomio.
Ejemplo: el polinomio
f(x) = x2 + x - 12
Cuando lo igualamos a cero y lo resolvemos tenemos:
x2 + x - 12 = 0 Igualando a cero.
(x + 4)(x - 3) = 0
Factorizando.
x=-4
Solucin 1
x=3
Solucin 2
Puesto que x1 = - 4 y x2 = 3 son soluciones de f(x) entonces f( -4 )= 0 y f( 3 )=

0. Decimos entonces que x = - 4 y x = 3 son races del polinomio f(x)= x2+ x
12
58
NOTA!
El Teorema fundamental del lgebra nos dice que: El nmero de factores en
que se puede descomponer un polinomio es igual al grado del polinomio, es
decir: Todo polinomio de grado n tiene n races.
.Por tanto, en nuestra programacin, nicamente podremos encontrar
races de un polinomio hasta grado 4, esto quiere decir que el nmero de
races encontradas ser equivalente al nmero de grado del polinomio que
estemos evaluando.
REPRESENTACION GRFICA DE LAS RAICES DE UN POLINOMIO
RAICES REALES
Como las races de un polinomio hacen que este valga cero, en unplano
cartesiano esto lo identificamos como las intersecciones de la grfica del
polinomio con el eje de las X (abscisas). Esto es, los puntos en donde cruza la
grfica al eje horizontal tienen como abscisa la raz del polinomio graficado.
A continuacin presentamos algunas funciones con sus races, factores y
grficas:
Funcin
Races
Factorizacin
f(x)=
x2 + x
- 12
-4y3
f(x) = (x +
4) (x - 3)
f(x)= - 1, 2 y
3
x3 - 4
x2 + x
+6
Grfica
f(x) = (x +
1) (x - 2) (x
- 3)
59
f(x)= - 2, - 1, f(x) = (x +
1) (x + 2) (x
x4 - 5 1 y 2
- 1) (x - 2)
x2 + 4
f(x)= Cules
x3 + 4 son?
x2 + 3
x
f(x) =
Consideremos ahora otro caso en particular, expresando una funcin mediante

el cociente de polinomios
Ejemplo:
Si la funcin con la que se trabaja es un cociente de polinomios, estos
debern ser reducidos a la mnima expresin con el objetivo de simplicar su
manejo. Dicha simplicacin se lleva a cabo eliminando factores comunes, y la
tarea de encontrar dichos factores est estrechamente ligada al clculo de las
races de los polinomios que aparecen en el numerador y el denominador.
Consideremos la funcin:
Esta funcin tiene una singularidad removible en x=-2. Si eliminamos el factor

(x+2) en el numerador y el denominador, obtenemos la funcin
60
La cual coincide con f(x) excepto en x=-2. Las races involucradas en esta
funcin son:
Races de p(x) = 0, 3,
Races de q(x) = -1, 1.
Para analizar el comportamiento de f (x) una vez eliminado el factor x= -2, se

debe tomaren cuenta que estas races, organizadas en orden creciente (1,0,1,3), indican los intervalos de estudio que deben considerarse para la
funcin.
Observe la Figura 3.Las races de p(x) sealan los puntos en que f intercepta
el eje de las x mientras que las races de q(x) indican asntotas de la funcin.
f(x)
FIG. 3
Lo que se pretende demostrar es que

DADO
UN
COCIENTE
DE
()
POLINOMIOS
, LOSVALORES QUE ANULAN A P(X) SI INDICAN LAS
()
RACES DE LA FUNCIN, MIENTRAS QUE LOS VALORES QUE ANULAN A

Q(X) INDICARN LAS ASNTOTAS DE DICHA FUNCIN, MAS NO SUS
RACES TAMBIN.
RAICES IMAGINARIAS
61
y = xxx-4xx+5x
Las
races
de
la
funcin son:
X= 0, x=2+i, x=2-i
y = xxx-4xx+5x
y = x^(3)+x
y = x^(3)+x
Las races de la
funcin son:
X= 0, x=i, x=-i
CMO CALCULAR LA PARBOLA?

1. Para esto necesitaremos de tres puntos
, ( ) , , ( ) , ( ) .
0
1
2
2. La aproximacin la podemos escribir como:
f 2 ( x) a( x x2 ) b( x x2 ) c
2
3. Los coeficientes de la ecuacin 1, es decir, de la
parbola los calculamos resolviendo el siguiente sistema

de ecuaciones.
FORMULAS
a utilizar
0 = 1
0
1 = 2
1
0 =
(1 )(0 )
1 0
1 =
(2 )(1 )
2 1
1 0
1 +0
= 1 +
1
= ( )
62
2 (0 ) = (0 2 )2 + (0 2 ) +
Ec. 2
2 (1 ) = (1 2 )2 + (1 2 ) +
Ec. 3
2 (2 ) = (2 2 )2 + (2 2 ) +
La ecuacin 4 genera que, ( ) =
Ec. 4
DADA LA FUNCION ORIGINAL f(X), seguiremos los siguientes pasos:

4. Evaluar los valores de
0 , 1 2 en f(x).Obtendremos:
(0 ) = ?
(1 ) = ?
(2 ) = ?
5. Evaluar 0 1 sustituyendo los valores como indican las formulas.
Obtendremos:
0 =?
1 =?
6. Encontrar0 1 dadas las formulas. Obtendremos:
0 =?
1 =?
7. Ahora se encontrar a , (coeficientes de la parbola).
a) Para encontrar a se deber resolver la frmula correspondiente. Se

tendr:
=?
b) Para encontrar a se deber resolver la frmula correspondiente. Se
obtendr:
=?
c) Para encontrar a se deber resolver la evaluacin correspondiente, el
cualesnicamente ( ) = .
8. Habiendo encontrado , se resuelve la siguiente frmula:
63
3 2 =
2 4
-Despejando-
3 = 2 +
2
2 4
En el denominador se escoge el signo que coincida con el signo de b,

esta eleccin proporciona como resultado el denominador ms grande, lo
que dar la raz estimada ms cercana a x3.
+ 2 4 > 2 4
Es decir, si
Se escoge
+ 4 4
Si no, se escoge:
2 4
9. Se prosigue a calcular el error, este ser:
3 2
3
. 100 %[Frmula para calcular el margen de error]
10. Si pretendemos iterar, es decir, una vez que se determin x3 el proceso se
repetir, esto con el fin de tener una mayor aproximacin a la raz X3, por lo
cual esto traer de que un valor es descartado.
Al ser un mtodo de aproximacin, este se realiza de forma secuencial e

iterativamente, donde 1 , 2 3 remplazan los puntos 0 , 1 , 2 llevando el
error a un valor cercano a cero.
VENTAJAS Y DESVENTAJAS DEL METODO DE MLLER
VENTAJA
Por medio de este mtodo se encuentran tanto races reales como

complejas.
DESVENTAJA
En el mtodo de Mller se escoge el signo que coincida con el
signo de b, esta eleccin proporciona como resultado el
denominador ms grande, lo que dar la raz estimada ms cercana a
x2. Una vez que se determin x3 el proceso se repite, esto trae de que
un valor es descartado.
ESTRATEGIAS COMNMENTE USADAS
64
Si slo se localizan races reales, elegimos los dos valores originales

ms cercanos a la nueva raz.
Si tenemos races reales y complejas, se usa un mtodo secuencial.

Ej.
X1, X2, X3=X0, X1, X2
DATO ADICIONAL
Si adems deseamos conocer los puntos en los que f (x) posee mximos y
mnimos locales, el procedimiento consiste en encontrar las races de f(X).
Si queremos ubicar los puntos de inexin de la funcin, es necesario ahora
encontrar las races de f(x).
EJEMPLOS: Obtn las races de los polinomios mediante el mtodo de Mller.

1) () = 3 13 12 ;
0 = 4.5, 1 = 5.5, 2 = 5
(4.5) = (4.5)3 13(4.5) 12
= .
(5.5) = (5.5)3 13(5.5) 12
= .
(5) = (5)3 13(5) 12
0 = 5.5 4.5
1 = 5 5.5
=
= .
82.875 20.625
1
48 82.875
1 =
1
2
0 =
69.7562.25
1
2
= 15
=
= .
= .
1
+ 69.75
2
= .
Coeficientes de la parbola
65
Puesto que b es positivo, entonces, respecto al signo ubicado en el

denominador, elegir + :
3 = 5 +
2(48)
62.25 (62.25)2 4(15)(48)

3 = 3.976487042
3.976487042 5
. 100 %
3.976487042
= 25.73912469 %
COMO OBTENER LAS OTRAS DOS RAICES FALTANTES?

Puesto que mi polinomio es de tercer orden, y ya se obtuvo una de tres
races, entonces puedo dividir a mi ecuacin polinomial 3 13 12 entre x
= X3, es decir 4, con el fin de obtener una ecuacin de orden dos,
equivalente a mi primer polinomio de orden tres, evidentemente, encontrar las
races de un polinomio grado dos es prcticamente sencillo.
Efectuando divisin sinttica
1
0 13 12 |
4
16
12 | 4
________________________|________
1 4
3
0 |
:
2 + 4 + 3
66
Obteniendo races de 2 + 4 + 3 :
4 42 4(1)(3)
1,2 =
2(1)
1 = 1,
2 = 3
FORMULA
1,2 =
2 4
2
Ilustracin grafica de () = 3 13 12 y sus respectivas raices.
67
PROGRAMACION
Programando Form 1
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
TForm1 *Form1;
: TForm(Owner)
{
}
{
Form2->Show();
Form1->Visible=false;
/*--------------ENTRAR--------------*/
}
{
Close();
/*--------------SALIR--------------*/
}
//--------------------------------------------------------------------------68
Programando Form 2
//--------------------------------------------------------------------------#include <vcl.h>
#include <math.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
double
a,b,c,d,e,x0,x1,x2,x3,j,z,D,A,B,C,fx0,fx1,fx2,h0,h1,d0,d1,w,ER=100,Er=100,o,p,q,r,s,u,v,rx1,lxl,m,l,R1,
R2;
TForm2 *Form2;
: TForm(Owner)
{
}
{
Label3->Caption="";
Label4->Caption="";
Label5->Caption="";
69
if(Er>=0.00000000000001){
x0=Edit6->Text.ToDouble();
fx0=a*pow(x0,4)+b*pow(x0,3)+c*pow(x0,2)+d*x0+e;
h0=x1-x0;
h1=x2-x1;
if(h0==0|| h1==0||h1+h0==0)
{Label5->Caption="Prueba con otras aproximaciones";}
else{
/*--------------R1--------------*/
d0=(fx1-fx0)/h0;
d1=(fx2-fx1)/h1;
A=(d1-d0)/(h1+h0);
B=(A*h1)+d1;
C=fx2;
D=B*B-4*A*C;
if(D<0)
{Label3->Caption="posiblemente la funcin solo tenga raicesimaginarias,grafica y prueba nuevos
valores de x1,x2,x3!";}
else
{z=pow(D,0.5);
x3=x2-(2*C)/(B+z);
w=(x3-x2)/x3;
if(w<0)
{Er=(-w)*100;}
else
{Er=w*100;}
Edit15->Text=AnsiString(Er); }}}
else {Label4->Caption="EL ERROR es cero,Que mas quieres?!";}
}
//--------------------------------------------------------------------------70

{
Close();
/*--------------SALIR--------------*/
}
{
Label3->Caption="";
Label4->Caption="";
Label5->Caption="";
if(ER>=0.00000000000001){
c=Edit3->Text.ToDouble();/*--------------R2--------------*/
fx0=b*pow(x0,3)+c*pow(x0,2)+d*x0+e;
h0=x1-x0;
h1=x2-x1;
if(h0==0|| h1==0||h1+h0==0)
{Label5->Caption="Prueba con otras aproximaciones";}
else{
d0=(fx1-fx0)/h0;
d1=(fx2-fx1)/h1;
A=(d1-d0)/(h1+h0);
B=(A*h1)+d1;
C=fx2;
D=B*B-4*A*C;
if(D<0)
{Label3->Caption="posiblemente la funcin solo tenga raicesimaginarias,grafica y prueba nuevos
valores de x1,x2,x3!";}
if(D>=0)
{z=pow(D,0.5);
x3=x2-(2*C)/(B+z);
w=(x3-x2)/x3;
w=(x3-x2)/x3;
if(w<0)
{ER=(-w)*100;}
else
{ER=w*100;}
71
Edit16->Text=AnsiString(ER); }}}
else {Label4->Caption="!EL ERROR YA ES CERO!";}}
{
Label3->Caption="";
Label4->Caption="";
Label5->Caption="";
D=b*b-4*a*c;
if(D<0)
/*--------------R3--------------*/
{x1=(-b)/(2*a);
l=pow(-l*D,0.5)/(2*a);
Edit13->Text=AnsiString(l);}
else if(D>=0)
{r=pow(D,0.5);
x1=(-b+r)/(2*a);
Edit11->Text=AnsiString(x1);}
else{ D=-D;
r=pow(D,0.5);
rx1=(-b)/(2*a);
lxl=D/(2*a);
Edit11->Text=AnsiString(rx1);}}
{
Label3->Caption="";
Label4->Caption="";
Label5->Caption="";
D=b*b-4*a*c;
if(D<0)
{x1=(-b)/(2*a);
l=pow(-l*D,0.5)/(2*a);
Edit14->Text=AnsiString(l);}
/*--------------R4--------------*/
else if(D>=0)
{r=pow(D,0.5);
x1=(-b-r)/(2*a);
Edit12->Text=AnsiString(x1);}
72
else{D=-D;
r=pow(D,0.5);
rx1=(-b)/(2*a);
lxl=D/(2*a);
Edit12->Text=AnsiString(rx1);}}
{
Label3->Caption="";
Label4->Caption="";
Label5->Caption="";
R1=Edit9->Text.ToDouble();
o=a*R1;
p=b+o; /*--------------DEGRADAR CON R1--------------*/
q=p*R1;
r=c+q;
s=r*R1;
u=d+s;
v=u*R1;
w=e+v;
Edit1->Text="0";
Edit2->Text=AnsiString(a);
Edit3->Text=AnsiString(p);
Edit5->Text=AnsiString(u);
}
{
Label3->Caption="";
Label4->Caption="";
Label5->Caption="";
R2=Edit10->Text.ToDouble();
o=a*R2;
p=b+o;
q=p*R2;
r=c+q;
s=r*R2;
u=d+s;
Edit2->Text="0";
/*--------------DEGRADAR CON R2--------------*/
73
}
{
ER=100;
Er=100;
a=b=c=d=e=0;
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
/*--------------RESET--------------*/
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="0";
Edit14->Text="0";
Edit15->Text="";
Edit16->Text="";
Label3->Caption="";
Label4->Caption="";
Edit1->SetFocus();
}
{
Form3->Show();
/*--------------GRAFICAR--------------*/
Close();
}
{
Form1->Show();
/*--------------INICIO-------------*/
Close();
}
//---------------------------------------------------------------------------
Programando Form 3
74
//--------------------------------------------------------------------------#include <vcl.h>
#include <math.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
double a,b,c,d,e,x,y,av,pri,seg;
TForm3 *Form3;
//---------------------------------------------------------------------------
__fastcall TForm3::TForm3(TComponent* Owner)

: TForm(Owner)
{
}
{
Canvas->PenPos=TPoint(160,320);
Canvas->LineTo(800,320);
75
76
Label5->Caption="Y";
Label6->Caption="X";
Label7->Caption="2";
Label12->Caption="-2";
pri=Edit6->Text.ToDouble();
seg=Edit7->Text.ToDouble();
av=(seg-pri)/1000;
x=pri;
y=a*pow(x,4)+b*pow(x,3)+c*pow(x,2)+d*x+e;
Canvas->PenPos=TPoint(480+x*20,320-y*20);
for(pri;pri<=seg;pri=pri+av)
{x=pri;
y=a*pow(x,4)+b*pow(x,3)+c*pow(x,2)+d*x+e;
Canvas->LineTo(480+x*20,320-y*20);}
}
{
Form2->Show();/*--------------REGRESAR-------------*/
Close();
}
{
Form1->Close();/*--------------SALIR-------------*/
Close();
}
{
Edit1->Text="";
77
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";/*--------------RESET-------------*/
Edit5->Text="";
Label5->Caption="";
Label6->Caption="";
Label7->Caption="";
Label8->Caption="";
Label9->Caption="";
Edit1->SetFocus();}
//---------------------------------------------------------------------------
78
5. Solucin de Ecuaciones Lineales por el

mtodo de eliminacin de Gauss.
Un conjunto finito de ecuaciones lineales de las variables X1, X2,. . . . . . . . . Xn,
recibe el nombre de sistema de ecuaciones lineales.
Por ejemplo un, sistema
incgnitas se escribe as:
a11x1
a21x1
a31x1
general de tres ecuaciones lineales en cuatro

+ a12x2 + a13x3 + a14x=b1
+ a22x2 + a23x3 +a24x4=b2
+ a32x2 + a33x3+a34x4=b3
Un sistema de m ecuaciones lineales en n incgnitas se puede abreviar

escribiendo nicamente el arreglo rectangular de nmeros:
a11 a12a1n b1
a21 a22 a2 b2
.
am1 am2 amnbm

Esto se conoce como matriz aumentada del sistema. (El trmino matriz se
emplea en matemticas para denotar un arreglo rectangular de nmeros. Las
matrices aparecen en varios contextos).
Como ejemplo la matriz aumentada del siguiente sistema de ecuaciones es:
El mtodo bsico para resolver un sistema de ecuaciones lineales consiste en

reemplazar el sistema dado por un nuevo sistema que tenga el mismo conjunto
solucin, pero que sea ms fcil de resolver. Por lo general, este nuevo
sistema se obtiene en una serie de etapas, aplicando los siguientes tres tipos
de operaciones.
1. Multiplicar una ecuacin (o rengln) por una constante diferente de cero.
2. Intercambiar dos ecuaciones (renglones).
79
3. Sumar un mltiplo de una ecuacin (rengln) a otra. Dado que los

renglones (lneas horizontales) de una matriz aumentada corresponden
a las ecuaciones del sistema asociado, estas tres operaciones equivalen
a las operaciones con renglones de la matriz aumentada.
80
SOLUCIN DE SISTEMA DE ECUACIONES LINEALES POR EL MTODO

DE ELIMINACION DE GAUSS
81
INTERFAZ DEL PROGRAMA
Compuesto de: 8-Label 2-Button 3-Picture

Buttons:
1) Empezar: Abre una nueva ventana.
2) Salir: Cierra la ventada de la interfaz y/o todas las ventanas.
PROGRAMACIN
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
82

TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
Form2->Show();
}
{
Close();
}
//---------------------------------------------------------------------------
83
MEN DE SELECCIN DE NMERO DE INCOGNITAS DEL SISTEMA DE

ECUACIONES
Compuesto de: 1-Label 5-Button 1-Picture

Buttons:
1) 2 Incgnitas: Abre una nueva ventana para resolver sistemas de 2
incgnitas en especfico.
5) Salir: Cierra la ventana del Men de seleccin.
PROGRAMACIN
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
#include "Unit3.h"
#include "Unit4.h"
#include "Unit5.h"
#include "Unit6.h"
84

TForm2 *Form2;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
Close();
}
{
Form3->Show();
}
//---------------------------------------------------------------------------

{
Form4->Show();
}
//---------------------------------------------------------------------------

{
85
Form5->Show();
}
//---------------------------------------------------------------------------

{
Form6->Show();
}
//---------------------------------------------------------------------------
INTERFAZ DE 2 INCGNITAS
Se compone de: 36-Label 3-Button 6-Edit 1-Picture
Buttons:
1) Solucin: Inicia el proceso de solucin del sistema de ecuaciones
lineales.
2) Borrar todo: Borra el proceso de triangulacin y la solucin del sistema
as como la informacin en los Edit.
3) Salir: Cierra la Interfaz de 2 Incgnitas.
PROGRAMACIN
//---------------------------------------------------------------------------
86
#include <vcl.h>
#pragma hdrstop
#include "Unit3.h"
double x1, y1, z1, x2, y2, z2, y3, z3;
TForm3 *Form3;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
{
x1= Edit1->Text.ToDouble();
y1= Edit2->Text.ToDouble();
z1= Edit3->Text.ToDouble();
87
z1= z1/x1;
y1= y1/x1;
x1= x1/x1;
Label7->Caption=FormatFloat("0.###",x1);
Label8->Caption=FormatFloat("0.###",y1);
Label9->Caption=FormatFloat("0.###",z1);
z2= z2/x2;
y2= y2/x2;
x2= x2/x2;
x2=x1-x2;
y2=y1-y2;
z2=z1-z2;
if(y2<0)
{
y2=-y2;
z2=-z2;
}
z2=z2/y2;
y2=y2/y2;
88
y3=y1*y2;
z3=y1*z2;
y1=y1-y3;
z1=z1-z3;
Label25->Caption="[";
Label26->Caption="]";
89
Label31->Caption="x1 -->";
Label32->Caption="x2 -->";
Label33->Caption="RESULTADO:";
}
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit1->SetFocus();
Label7->Caption="";
Label8->Caption="";
Label9->Caption="";
90
}
91
{
Close();
}
//--------------------------------------------------------------------------INTERFAZ DE 3 INCGNITAS
Se compone de: 63-Label 3-Button 12-Edit 1-Picture

Buttons:
lineales.
PROGRAMACIN
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit4.h"
//--------------------------------------------------------------------------92
double x1, y1, z1, a, x2, y2, z2, b, x3, y3, z3, c, w;
TForm4 *Form4;
: TForm(Owner)
{
}
{
a= Edit4->Text.ToDouble();
b= Edit8->Text.ToDouble();
c= Edit12->Text.ToDouble();
93
a=a/x1;
z1=z1/x1;
y1=y1/x1;
x1=x1/x1;
if(x2==0)
{
b=b/y2;
z2=z2/y2;
y2=y2/y2;
}
else
{
b=b/x2;
z2=z2/x2;
y2=y2/x2;
x2=x2/x2;
if(x3==0)
{
c=c/y3;
z3=z3/y3;
y3=y3/y3;
}
else
94
{
c=c/x3;
z3=z3/x3;
y3=y3/x3;
x3=x3/x3;
}
Label16->Caption=FormatFloat("0.###",a);
Label20->Caption=FormatFloat("0.###",b);
Label24->Caption=FormatFloat("0.###",c);
if(x2==0)
{
y2=y2;
z2=z2;
b=b;
}
95
else
{
x2=x1-x2;
y2=y1-y2;
z2=z1-z2;
b=a-b;
}
if(y2==0)
{
b=b/z2;
z2=z2/z2;
}
else
{
b=b/y2;
z2=z2/y2;
y2=y2/y2;
}
if(x3==0)
{
y3=y3;
z3=z3;
c=c;
}
96
else
{
x3=x1-x3;
y3=y1-y3;
z3=z1-z3;
c=a-c;
}
if(y3==0)
{
c=c/z3;
z3=z3/z3;
}
else
{
c=c/y3;
z3=z3/y3;
y3=y3/y3;
97
y3=y2-y3;
z3=z2-z3;
c=b-c;
c=c/z3;
z3=z3/z3;
98
b=b-(z2*c);
a=a-(y1*b)-(z1*c);
Label54->Caption="x1 ->";
}
//---------------------------------------------------------------------------

{
Close();
}
//--------------------------------------------------------------------------99

{
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();
100
101
}
//--------------------------------------------------------------------------INTERFAZ DE 4 INCGNITAS
Compuesto de: 117-Label 3-Button 20-Edit 1-Picture

Buttons:
102

lineales.
PROGRAMACIN
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit5.h"
double a, b, c, d, x1, y1, z1, w1, x2, y2, z2, w2, x3, y3, z3, w3, x4, y4, z4, w4;
TForm5 *Form5;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
103
w1= Edit4->Text.ToDouble();
d= Edit20->Text.ToDouble();
a=a/x1;
w1=w1/x1;
z1=z1/x1;
y1=y1/x1;
x1=x1/x1;
if(x2==0)
104
{
b=b/y2;
w2=w2/y2;
z2=z2/y2;
y2=y2/y2;
}
else
{
b=b/x2;
w2=w2/x2;
z2=z2/x2;
y2=y2/x2;
x2=x2/x2;
}
if(x3==0)
{
if(y3==0)
{
c=c/z3;
w3=w3/z3;
z3=z3/z3;
}
else
{
c=c/y3;
w3=w3/y3;
z3=z3/y3;
105
y3=y3/y3;
}
}
else
{
c=c/x3;
w3=w3/x3;
z3=z3/x3;
y3=y3/x3;
x3=x3/x3;
}
if(x4==0)
{
if(y4==0)
{
if(z4==0)
{
d=d/w4;
w4=w4/w4;
}
else
{
d=d/z4;
w4=w4/z4;
z4=z4/z4;
}
}
else
106
{
d=d/y4;
w4=w4/y4;
z4=z4/y4;
y4=y4/y4;
}
}
else
{
d=d/x4;
w4=w4/x4;
z4=z4/x4;
y4=y4/x4;
x4=x4/x4;
}
Label21->Caption=FormatFloat("0.###",w1);
107
Label37->Caption=FormatFloat("0.###",d);
if(x2==0)
{
x2=x2;
y2=y2;
z2=z2;
w2=w2;
b=b;
}
else
{
x2=x1-x2;
y2=y1-y2;
z2=z1-z2;
w2=w1-w2;
b=a-b;
108
b=b/y2;
w2=w2/y2;
z2=z2/y2;
y2=y2/y2;
}
if(x3==0)
{
x3=x3;
y3=y3;
z3=z3;
w3=w3;
c=c;
}
else
{
x3=x1-x3;
y3=y1-y3;
z3=z1-z3;
w3=w1-w3;
c=a-c;
if(y3==0)
{
c=c/z3;
w3=w3/z3;
z3=z3/z3;
109
}
else
{
c=c/y3;
w3=w3/y3;
z3=z3/y3;
y3=y3/y3;
}
}
if(x4==0)
{
x4=x4;
y4=y4;
z4=z4;
w4=w4;
d=d;
}
else
{
x4=x1-x4;
y4=y1-y4;
z4=z1-z4;
w4=w1-w4;
d=a-d;
if(y4==0)
{
110
d=d/z4;
w4=w4/z4;
z4=z4/z4;
}
else
{
d=d/y4;
w4=w4/y4;
z4=z4/y4;
y4=y4/y4;
}
}
111
if(y3==0)
{
x3=x3;
y3=y3;
z3=z3;
w3=w3;
c=c;
}
else
{
x3=x3;
y3=y2-y3;
z3=z2-z3;
w3=w2-w3;
c=b-c;
c=c/z3;
w3=w3/z3;
z3=z3/z3;
112
}
if(y4==0)
{
x4=x4;
y4=y4;
z4=z4;
w4=w4;
d=d;
}
else
{
x4=x4;
y4=y2-y4;
z4=z2-z4;
w4=w2-w4;
d=b-d;
d=d/z4;
w4=w4/z4;
z4=z4/z4;
}
113
if(z4==0)
{
x4=x4;
y4=y4;
z4=z4;
w4=w4;
d=d;
}
else
{
114
x4=x4;
y4=y3;
z4=z3-z4;
w4=w3-w4;
d=c-d;
d=d/w4;
w4=w4/w4;
}
115
w4=d;
z3=c-(d*w3);
y2=b-(d*w2)-(z3*z2);
x1=a-(d*w1)-(z3*z1)-(y2*y1);
Label101->Caption="x1-->";
Label102->Caption="y1-->";
Label103->Caption="z1-->";
Label104->Caption="w1-->";
116
}
{
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="";
117
Edit20->Text="";
Edit1->SetFocus();
118
119
120
}
//---------------------------------------------------------------------------

{
Close();
}
//---------------------------------------------------------------------------
INTERFAZ DE 5 INCGNITAS
121
Compuesto de: 198-Label 3-Button 30-Edit 1-Picture

Buttons:
lineales.
PROGRAMACIN
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit6.h"
double a, b, c, d, e, x1, y1, z1, w1, u1, x2, y2, z2, w2, u2, x3, y3, z3, w3, u3, x4,
y4, z4, w4, u4, x5, y5, z5, w5, u5;
122
TForm6 *Form6;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
u1= Edit5->Text.ToDouble();
123
d= Edit24->Text.ToDouble();
e= Edit30->Text.ToDouble();
a=a/x1;
u1=u1/x1;
w1=w1/x1;
z1=z1/x1;
y1=y1/x1;
x1=x1/x1;
if(x2==0)
{
b=b/y2;
124
u2=u2/y2;
w2=w2/y2;
z2=z2/y2;
y2=y2/y2;
}
else
{
b=b/x1;
u2=u2/x2;
w2=w2/x2;
z2=z2/x2;
y2=y2/x2;
x2=x2/x2;
}
if(x3==0)
{
if(y3==0)
{
c=c/z3;
u3=u3/z3;
w3=w3/z3;
z3=z3/z3;
}
else
{
c=c/y3;
u3=u3/y3;
w3=w3/y3;
125
z3=z3/y3;
y3=y3/y3;
}
}
else
{
c=c/x3;
u3=u3/x3;
w3=w3/x3;
z3=z3/x3;
y3=y3/x3;
x3=x3/x3;
}
if(x4==0)
{
if(y4==0)
{
if(z4==0)
{
d=d/w4;
u4=u4/w4;
w4=w4/w4;
}
else
{
d=d/z4;
u4=u4/z4;
w4=w4/z4;
126
z4=z4/z4;
}
}
else
{
d=d/y4;
u4=u4/y4;
w4=w4/y4;
z4=z4/y4;
y4=y4/y4;
}
}
else
{
d=d/x4;
u4=u4/x4;
w4=w4/x4;
z4=z4/x4;
y4=y4/x4;
x4=x4/x4;
}
if(x5==0)
{
if(y5==0)
{
if(z5==0)
{
if(w5==0)
127
{
e=e/u5;
u5=u5/u5;
}
else
{
e=e/w5;
u5=u5/w5;
w5=w5/w5;
}
}
else
{
e=e/z5;
u5=u5/z5;
w5=w5/z5;
z5=z5/z5;
}
}
else
{
e=e/y5;
u5=u5/y5;
w5=w5/y5;
z5=z5/y5;
y5=y5/y5;
}
}
128
else
{
e=e/x5;
u5=u5/x5;
w5=w5/x5;
z5=z5/x5;
y5=y5/x5;
x5=x5/x5;
}
Label32->Caption=FormatFloat("0.###",u1);
129
Label57->Caption=FormatFloat("0.###",e);
if(x2==0)
{
x2=x2;
y2=y2;
z2=z2;
w2=w2;
u2=u2;
b=b;
}
else
{
x2=x1-x2;
130
y2=y1-y2;
z2=z1-z2;
w2=w1-w2;
u2=u1-u2;
b=a-b;
b=b/y2;
u2=u2/y2;
w2=w2/y2;
z2=z2/y2;
y2=y2/y2;
}
if(x3==0)
{
x3=x3;
y3=y3;
z3=z3;
w3=w3;
u3=u3;
c=c;
}
else
{
x3=x1-x3;
y3=y1-y3;
z3=z1-z3;
w3=w1-w3;
131
u3=u1-u3;
c=a-c;
if(y3==0)
{
c=c/z3;
u3=u3/z3;
w3=w3/z3;
z3=z3/z3;
}
else
{
c=c/y3;
u3=u3/y3;
w3=w3/y3;
z3=z3/y3;
y3=y3/y3;
}
}
if(x4==0)
{
x4=x4;
y4=y4;
z4=z4;
w4=w4;
u4=u4;
d=d;
}
132
else
{
x4=x1-x4;
y4=y1-y4;
z4=z1-z4;
w4=w1-w4;
u4=u1-u4;
d=a-d;
if(y4==0)
{
if(z4==0)
{
d=d/w4;
u4=u4/w4;
w4=w4/w4;
}
else
{
d=d/z4;
u4=u4/z4;
w4=w4/z4;
z4=z4/z4;
}
}
else
{
d=d/y4;
133
u4=u4/y4;
w4=w4/y4;
z4=z4/y4;
y4=y4/y4;
}
}
if(x5==0)
{
x5=x5;
y5=y5;
z5=z5;
w5=w5;
u5=u5;
e=e;
}
else
{
x5=x1-x5;
y5=y1-y5;
z5=z1-z5;
w5=w1-w5;
u5=u1-u5;
e=a-e;
if(y5==0)
{
if(z5==0)
{
134
if(w5==0)
{
e=e/w5;
u5=u5/u5;
}
else
{
e=e/w5;
u5=u5/w5;
w5=w5/w5;
}
}
else
{
e=e/z5;
u5=u5/z5;
w5=w5/z5;
z5=z5/z5;
}
}
else
{
e=e/y5;
u5=u5/y5;
w5=w5/y5;
z5=z5/y5;
y5=y5/y5;
}
135
136
if(y3==0)
{
x3=x3;
y3=y3;
z3=z3;
w3=w3;
u3=u3;
c=c;
}
else
{
x3=x3;
y3=y2-y3;
z3=z2-z3;
w3=w2-w3;
u3=u2-u3;
c=b-c;
c=c/z3;
137
u3=u3/z3;
w3=w3/z3;
z3=z3/z3;
}
if(y4==0)
{
x4=x4;
y4=y4;
z4=z4;
w4=w4;
u4=u4;
d=d;
}
else
{
x4=x4;
y4=y2-y4;
z4=z2-z4;
w4=w2-w4;
u4=u2-u4;
d=b-d;
if(z4==0)
{
d=d/w4;
u4=u4/w4;
w4=w4/w4;
}
138
else
{
d=d/z4;
u4=u4/z4;
w4=w4/z4;
z4=z4/z4;
}
}
if(y5==0)
{
x5=x5;
y5=y5;
z5=z5;
w5=w5;
u5=u5;
d=d;
}
else
{
x5=x5;
y5=y2-y5;
z5=z2-z5;
w5=w2-w5;
u5=u2-u5;
e=b-e;
if(z5==0)
{
139
if(w5==0)
{
e=e/u5;
u5=u5/u5;
}
else
{
e=e/w5;
u5=u5/w5;
w5=w5/w5;
}
}
else
{
e=e/z5;
u5=u5/z5;
w5=w5/z5;
z5=z5/z5;
}
140
141
if(z4==0)
{
x4=x4;
y4=y4;
z4=z4;
w4=w4;
u4=u4;
d=d;
}
else
{
x4=x4;
y4=y4;
z4=z3-z4;
w4=w3-w4;
u4=u3-u4;
d=c-d;
d=d/w4;
u4=u4/w4;
w4=w4/w4;
}
if(z5==0)
{
x5=x5;
y5=y5;
z5=z5;
w5=w5;
142
u5=u5;
e=e;
}
else
{
x5=x5;
y5=y5;
z5=z3-z5;
w5=w3-w5;
u5=u3-u5;
e=c-e;
e=e/w5;
u5=u5/w5;
w5=w5/w5;
}
143
if(w5==0)
{
x5=x5;
y5=y5;
144
z5=z5;
w5=w5;
e=e/u5;
u5=u5/u5;
}
else
{
x5=x5;
y5=y5;
z5=z5;
w5=w4-w5;
u5=u4-u5;
e=d-e;
e=e/u5;
u5=u5/u5;
}
145
u5=e;
w4=d-(e*u4);
z3=c-(e*u3)-(w4*w3);
146
y2=b-(e*u2)-(w4*w2)-(z3*z2);
x1=a-(e*u1)-(w4*w1)-(z3*z1)-(y2*y1);
147
}
{
Close();
}
{
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="";
148
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="";
Edit1->SetFocus();
149
150
151
152
153
154
}
//---------------------------------------------------------------------------
155
6. Inversin de Matrices por el mtodo de

descomposicin de L. U.
Su nombre se deriva de las palabras inglesas "Lower" y "Upper", que
en espaol se traducen como "Inferior" y "Superior". Estudiando el proceso que
se sigue en la descomposicin LU es posible comprender el por qu de este
nombre, analizando cmo una matriz original se descompone en dos matrices
triangulares, una superior y otra inferior.
La descomposicin LU involucra solo operaciones sobre los coeficientes de la
matriz [A], proporcionando un medio eficiente para calcular la matriz inversa o
resolver sistemas de lgebra lineal.
Primeramente se debe obtener la matriz [L] y la matriz [U].
[L] es una matriz diagonal inferior con nmeros 1 sobre la diagonal.
[U] es una matriz diagonal superior en la que sobre la diagonal no
necesariamente tiene que haber nmeros 1.
El primer paso es descomponer o transformar [A] en [L] y [U], es decir obtener

la matriz triangular inferior [L] y la matriz triangular superior [U].
MATRIZ [A]
MATRIZ [L]
MATRIZ
[U]
PASOS PARA ENCONTRAR LA MATRIZ TRIANGULAR INFERIOR (MATRIZ [L])
Para encontrar la matriz triangular inferior se busca hacer ceros los valores de
arriba de cada pivote, as como tambin convertir en 1 cada pivote. Se utiliza el
mismo concepto de "factor" explicado anteriormente y se ubican todos los
"factores" debajo de la diagonal segn corresponda en cada uno.
Debido a que [A] = [L][U], al encontrar [L] y [U] a partir de [A] no se altera en
nada la ecuacin. Por lo tanto, si Ax = b, entonces LUx = b, de manera que Ax
= LUx = b.
Esquemticamente se busca lo siguiente:
156
MTODO PARA CALCULAR LA MATRIZ INVERSA.
Est basado en la eliminacin gaussiana y que permite calcular matrices

inversas. La idea de este mtodo es aplicar eliminacin gaussiana para hacer
ceros tanto por debajo como por encima de la diagonal y, adems, conseguir
que todos los elementos de la diagonal sean igual a uno. Para que de sta
manera nos permite calcular matrices inversas.
En el siguiente ejemplo se aplica ste mtodo:
Consideremos la matriz para describir dicho mtodo. Adems, para ser ms
prcticos, las operaciones que se vayan realizando sobre A tambin se aplican
a la matriz identidad I. Para simplificar el proceso, se yuxtaponen la matriz A y
la matriz identidad de la siguiente forma:
Empezamos haciendo ceros en A por debajo de la diagonal. Para ello, primero

restamos -1/2 F1 a F2 y 3/2 F1 a F3, operando sobre las filas de A e I
conjuntamente, y tenemos:
157
A continuacin, restamos 11/3 F2 a F3 para obtener la matriz.
Y de sta manera se obtiene la matriz inversa.
PASOS
PARA
RESOLVER
UN SISTEMA DE ECUACIONES POR
EL MTODO DE DESCOMPOSICIN LU
1.
2.
3.
4.
5.
Obtener la matriz triangular inferior L y la matriz triangular superior U.

Resolver Ly = b (para encontrar y).
El resultado del paso anterior se guarda en una matriz nueva de nombre "y".
Realizar Ux = y (para encontrar x).
El resultado del paso anterior se almacena en una matriz nueva llamada "x",
la cual brinda los valores correspondientes a las incgnitas de la ecuacin.
EJEMPLO:
PROBLEMA: Encontrar los valores de x1, x2 y x3 para el siguiente sistema de

ecuaciones:
NOTA: Recurdese que si la matriz es 2x2 se har 1 iteracin; si es 3x3, 2

iteraciones; si es 4x4, 3 iteraciones; y as sucesivamente.
158
SOLUCIN:
-2 -1
[A] = 5
-1
-4
9
[B] = 7
12
ITERACIN 1
factor 1 = (a21 / a11) = 5 / 4 = 1.25
factor 2 = (a31 / a11) = 1 / 4 = 0.25
Encontrando [U]
fila 2 = - (factor 1) * (fila 1) + (fila 2)
a11 = a11
a12 = a12
a13 = a13
a21 = - (1.25) * (4) + (5) = 0
a22 = - (1.25) * (- 2) + (1) = 3.5

a23 = - (1.25) + (- 1) + (- 1) = 0.25
a31 = - (0.25) * (4) + (1) = 0
a32 = - (0.25) * (- 2) + (2) = 2.5
a33 = - (0.25) * (- 1) + (- 1) = - 0.75
[U] =
-2
-1
3.5
0.25
159
2.5
- 0.75
Encontrando [L]
[L] = 1.25 0
0.25 0
ITERACIN 2
factor 3 = (u32 / u22) = 2.5 / 3.5 = 0.7142857143
Encontrando [U]

a31 = - (2.5 / 3.5) * (0) + (0) = 0
a32 = - (2.5 / 3.5) * (3.5) + (2.5) = 0
a33 = - (2.5 / 3.5) * (0.25) + (- 0.75) = - 0.9285714286
[U] =
-2
-1
3.5
0.25
- 0.9285714286
Encontrando [L]
0
160
[L] =
1.25 1
0.25 0.7142857143 1
Ahora ya se tiene la matriz [U] y la matriz [L]. El siguiente paso es resolver

Ly = b para encontrar la matriz y. En pocas palabras es como que se pidiera
resolver el siguiente sistema de ecuaciones, encontrando los valores de y1, y2
y y3:
Al resolver el sistema anterior, se obtienen los siguientes valores para y1, y2 y

y3:
El ltimo paso es resolver Ux = y para encontrar la matriz x. En otras palabras

es como que se pidiera resolver el siguiente sistema de ecuaciones,
encontrando los valores de x1, x2 y x3:
La solucin del sistema es:
161
Este es finalmente el valor de x1, x2 y x3; es decir, la respuesta del ejercicio

utilizando la descomposicin LU.
PROGRAMACIN DEL MTODO.
Form1.
ACCIONES POR BOTN.
Botn ENTRAR.
Tiene la funcin de abrir la interfaz del Form2 e iniciar con el programa.
Botn Cerrar programa.
Cierra por completo el programa.
162
Form2.
ACCIONES POR BOTN.

Botn: Capturar [A]
Permite ir capturando los datos de la matriz a resolver, al insertar un valor es
necesario oprimir el botn CAPTURAR [A] para que el programa guarde el
valor asignado.
Botn: Determinante de [A]
Este botn nos arroja el valor de la determinante de la matriz [A]; abriendo el
Form3.
Botn: U
Tiene la funcin de de obtener el resultado para encontrar a U haciendo ceros
la matriz superior triangular.
Botn: L
Tiene la funcin de obtener el resultado para encontrar a L haciendo ceros la
matriz inferior triangular.
Botn: LU
Este botn arroja el resultado de la multiplicacin de las matrices L y U. La
matriz que arroja es igual a la matriz original [A], ya que, las matrices L y U son
una descomposicin de la matriz [A]; por tal motivo que el producto de las dos
matrices debe resultar la matriz original.
163
Botn: Capturar [B]

Permite ir capturando los datos de la matriz [B], al insertar un valor es
necesario oprimir el botn CAPTURAR [B] para que el programa guarde el
valor asignado. Los valores de la matriz [B] es fundamental, ya que, estos
valores permitir obtener los valores de las variables.
Botn: LD=I
Tiene la funcin de encontrar los tres coeficientes de la primera columna para
conseguir la matriz inversa.
Botn: LD=j
Tiene la funcin de encontrar dos coeficientes de la segunda columna y la
primera y tercera fila para conseguir la matriz inversa
Botn: LD=K
Tiene la funcin de encontrar un coeficientes de la tercera columna y tercera
fila para conseguir la matriz inversa.
Botn: Ux=D
Tiene la funcin de encontrar los coeficientes de la primera columna y la

primera fila.
Botn: Uy=D
Tiene la funcin de encontrar los coeficientes de la segunda columna y la
primera y segunda fila.
Botn: Uz=D
Tiene la funcin de encontrar los coeficientes de la tercera columna y la
primera, segunda y tercera fila.
Botn: Matriz Inversa de [A]
Tiene la funcin de obtener la matriz inversa de la matriz original [A].
Botn: Solucin
Tiene la funcin de encontrar la solucin de las ecuaciones lineales, iniciales y
as poder encontrar las races de las incgnitas.
Botn: RESET
Tiene la funcin de limpiar la informacin de la matriz anterior y asi poder
agregar otra matriz nueva.
Botn: SALIR
164
Tiene la funcin de salir del form1 y regresar la portada del formulario principal.
Form3: (ste Form3 se abre al oprimir el botn Determinante de [A] del

Form2.)
Botn Regresar: Cierra el Form3 y regresa al Form2.
CDIGO DE PROGRAMACIN DE CADA FORMULARIO.

Form1.
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
165
TForm1 *Form1;
TForm1 *Form2;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
Form2->Show();
}
//---------------------------------------------------------------------------

{
Close();
}
//---------------------------------------------------------------------------
Form2.
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
166
TForm2 *Form2;
TForm2 *Form3;
double A[3][3],U[3][3],L[3][3],LU[3][3],I[3][3],Z[3][3],X[3][3],V[3][3],T[3][3], a, b, det;
int i=1, j=1, C[3][3], r=1, s=1;
double B[3][3], p, n, l;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
A[i][j]= Edit1->Text.ToDouble();
Edit1->Text="";
Edit1->SetFocus();
if(i==1){
if(j==1)Edit2->Text=A[1][1];
}
if(i==2){
}
if(i==3){
167
}
j++;
if(j==4){
i++;
j=1;
}
if(A[1][1]==0){
Label3->Caption="No puedo resolver tu matriz";
}
if(i==4){
{Label7->Caption="Introduce Valores de B presiona U";}
a= (A[1][1]*A[2][2]*A[3][3])+(A[2][1]*A[3][2]*A[1][3])+(A[3][1]*A[1][2]*A[2][3]);
b= (A[1][3]*A[2][2]*A[3][1])+(A[2][3]*A[3][2]*A[1][1])+(A[3][3]*A[1][2]*A[2][1]);
det= a-b;
if(det==0){
Label3->Caption="La Matriz no tiene Inversa";
}
}
}
{
T[1][1]=A[1][1];
T[1][2]=A[1][2];
T[1][3]=A[1][3];
for(int i=2; i<=3; i++){
for(int j=1; j<=3; j++){
T[2][j]=A[2][j]-((A[2][1]/A[1][1]*(A[1][j])));
}
}
for(int i=3; i<=3; i++){
168
for(int j=1; j<=3; j++){

T[3][j]=A[3][j]-((A[3][1]/A[1][1]*(A[1][j])));
}
}
for(int i=3; i<=3; i++){
for(int j=1; j<=3; j++){
U[3][j]=T[3][j]-((T[3][2]/T[2][2]*(T[2][j])));
}
}
U[1][1]=T[1][1];
U[1][2]=T[1][2];
U[1][3]=T[1][3];
U[2][1]=T[2][1];
U[2][2]=T[2][2];
U[2][3]=T[2][3];
Edit11->Text=AnsiString(U[1][1]);
Edit1->SetFocus();
Label7->Caption=" Oprima el Boton L";
}
//---------------------------------------------------------------------------

{
169
L[1][1]=1;
L[1][2]=0;
L[1][2]=0;
L[2][1]=A[2][1]/A[1][1];
L[2][2]=1;
L[2][3]=0;
L[3][1]=A[3][1]/A[1][1];
L[3][2]=T[3][2]/T[2][2];
L[3][3]=1;
Edit20->Text=AnsiString(L[1][1]);
Label7->Caption="Oprima LU";
}
{
LU[1][1]=A[1][1];
LU[1][2]=A[1][2];
LU[1][3]=A[1][3];
LU[2][1]=A[2][1];
LU[2][2]=A[2][2];
LU[2][3]=A[2][3];
LU[3][1]=A[3][1];
LU[3][2]=A[3][2];
170
LU[3][3]=A[3][3];
Edit29->Text=AnsiString(LU[1][1]);
Label7->Caption="Oprima LD=i";
}
{
Z[1][1]=1;
Z[2][1]=(-1*L[2][1]*L[1][1]+L[2][3]);
Z[3][1]=(-1*L[3][2]*Z[2][1]+(-1*L[3][1]));
Edit38->Text=AnsiString(Z[1][1]);
Label7->Caption="Oprima LD=j";
}
{
Z[1][2]=0;
Z[2][2]=1;
Z[3][2]=1*(-L[3][2]);
171
Label7->Caption="Oprima LD=k";
}
{
Z[1][3]=0;
Z[2][3]=0;
Z[3][3]=1*L[3][3];
Label7->Caption="Sigue.. Ux=D";
}
{
X[3][1]=Z[3][1]/U[3][3];
X[2][1]=((Z[2][1])-((U[2][3])*(X[3][1])))/(U[2][2]);
X[1][1]=((Z[1][1])-(U[1][3])*(X[3][1])-(U[1][2])*(X[2][1]))/(U[1][1]);
Label7->Caption="Sigue.. Uy=D";
}
{
X[3][2]=Z[3][2]/U[3][3];
X[2][2]=((Z[2][2])-((U[2][3])*(X[3][2])))/(U[2][2]);
X[1][2]=((Z[1][2])-(U[1][3])*(X[3][2])-(U[1][2])*(X[2][2]))/(U[1][1]);
172
Label7->Caption="Sigue.. Uz=D";
}
{
X[3][3]=Z[3][3]/U[3][3];
X[2][3]=((Z[2][3])-((U[2][3])*(X[3][3])))/(U[2][2]);
X[1][3]=((Z[1][3])-(U[1][3])*(X[3][3])-(U[1][2])*(X[2][3]))/(U[1][1]);
Label7->Caption="Da Click En Matriz Inversa";
}
{
Edit56->Text=AnsiString(X[1][1]);
Label3->Caption="Encontrastes la [A]-1";
}
//--------------------------------------------------------------------------173

{
V[1][1]=((A[1][1]*X[1][1])+(A[1][2]*X[2][1])+(A[1][3]*X[3][1]));
V[1][2]=((A[1][1]*X[1][2])+(A[1][2]*X[2][2])+(A[1][3]*X[3][2]));
V[1][3]=((A[1][1]*X[1][3])+(A[1][2]*X[2][3])+(A[1][3]*X[3][3]));
V[2][1]=((A[2][1]*X[1][1])+(A[2][2]*X[2][1])+(A[2][3]*X[3][1]));
V[2][2]=((A[2][1]*X[1][2])+(A[2][2]*X[2][2])+(A[2][3]*X[3][2]));
V[2][3]=((A[2][1]*X[1][3])+(A[2][2]*X[2][3])+(A[2][3]*X[3][3]));
V[3][1]=((A[3][1]*X[1][1])+(A[3][2]*X[2][1])+(A[3][3]*X[3][1]));
V[3][2]=((A[3][1]*X[1][2])+(A[3][2]*X[2][2])+(A[3][3]*X[3][2]));
V[3][3]=((A[3][1]*X[1][3])+(A[3][2]*X[2][3])+(A[3][3]*X[3][3]));
Label7->Caption="Oprime Solucion y Veras!!";
}
{
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="";
174
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="";
Edit38->Text="";
Edit39->Text="";
Edit40->Text="";
Edit41->Text="";
Edit42->Text="";
Edit43->Text="";
Edit44->Text="";
Edit45->Text="";
Edit46->Text="";
175
Edit47->Text="";
Edit48->Text="";
Edit49->Text="";
Edit50->Text="";
Edit51->Text="";
Edit52->Text="";
Edit53->Text="";
Edit54->Text="";
Edit55->Text="";
Edit56->Text="";
Edit57->Text="";
Edit58->Text="";
Edit59->Text="";
Edit60->Text="";
Edit61->Text="";
Edit62->Text="";
Edit63->Text="";
Edit64->Text="";
Label3->Caption="";
Label7->Caption="";
i=1;
j=1;
r=1;
s=1;
}
{
Close();
}
//--------------------------------------------------------------------------176

{
C[1][1]=V[1][1];
C[1][2]=V[1][2];
C[1][3]=V[1][3];
C[2][1]=V[2][1];
C[2][2]=V[2][2];
C[2][3]=V[2][3];
C[3][1]=V[3][1];
C[3][2]=V[3][2];
C[3][3]=V[3][3];
}
{
Form3->Label1->Caption=AnsiString(det);
Form3->Show();
}
//---------------------------------------------------------------------------

{
p=(X[1][1]*B[1][1]+X[1][2]*B[2][1]+X[1][3]*B[3][1]);
l=(X[2][1]*B[1][1]+X[2][2]*B[2][1]+X[2][3]*B[3][1]);
n=(X[3][1]*B[1][1]+X[3][2]*B[2][1]+X[3][3]*B[3][1]);
Edit68->Text=AnsiString(l);
Edit69->Text=AnsiString(n);
Label7->Caption="Haz encontrado la solucion";
}
177

{
B[r][s]=Edit70->Text.ToDouble();
Edit70->SetFocus();
Edit70->Text="";
if(r==1){
if(s==1)Edit83->Text=B[1][1];
}
if(r==2){
}
if(r==3){
}
s++;
if(s==2){
r++;
s=1;
}
}
//--------------------------------------------------------------------------void __fastcall TForm2::FormCreate(TObject *Sender)
{
Label7->Caption="Introduzca los Valores de la Matriz[A]";
}
//---------------------------------------------------------------------------
Form3.
//---------------------------------------------------------------------------
#include <vcl.h>
178
#pragma hdrstop
#include "Unit3.h"
TForm3 *Form3;
TForm3 *Form2;

: TForm(Owner)
{
}
{
Close();
}
//---------------------------------------------------------------------------
De sta forma es como se programa la inversin de matrices por el mtodo de

descomposicin LU en lenguaje C++.
179
7. Interpolacin polinomial por el mtodo de

Newton de diferencias divididas
Un polinomio es una expresin matemtica constituida por un conjunto finito de
variables (no determinadas o desconocidas) y constantes (numero fijos
llamados coeficientes). Utilizando nicamente las operaciones aritmticas de
suma, resta y multiplicacin, as como tambin de exponentes enteros positivos.
En trminos ms precisos, es una combinacin lineal de productos de
potencias enteras de una o de varias variables indeterminadas.
Sabemos que la formula general para un polinomio de N-esimo grado
(potencial) es:
P(x)= a+aX+aX+anX
a= Coeficientes
x= literal que se va a evaluar para encontrar el valor de y
n= exponente
A diferencia de la interpolacin lineal se necesitan dos puntos de una lnea
recta, pero en polinomio no necesariamente tiene que ser una funcin de la
forma Y= mx+n, si no que abarca las funciones cuadrticas, cubicas,
logartmicas, exponenciales y muchas veces no conoceremos la funcin, si no
solo la imagen de la funcin (rango) con su contra dominio (valores de y), en
algunas otras conoceremos la frmula y los valores del rango que tomara para
encontrar los valores de y, as como los puntos a evaluar (x) para obtener el
valor de Y en ese punto. Es decir a partir de puntos obtenidos por muestra a
partir de la funcin.
En la interpolacin polinomial de n potencia, ser encontrar un polinomio nico

que satisface (n+1) para obtener los valores intermedio, que pase por todos los
puntos.
DE QUE DEPENDE EL GRADO DE NUESTRO POLINOMIO A
ENCONTRAR?
Depender de los puntos que nos proporcione y por medio de esta
condicin (n+1= puntos) si tengo la cantidad de dos puntos el despeje
ser el siguiente (puntos-1)=n, ejemplo: si nos dan dos puntos nuestro
polinomio a encontrar ser 2-1=n=1 sera un polinomio de grado 1.
a.- De primer grado (lineal) que une a dos puntos.

b.- De segundo grado (cuadrtica o parbola) que une tres puntos.
180
c.- De tercer grado (cubica) que une a cuatro puntos.
COMO ENCONTRAREMOS A NUESTRO POLINOMIO?

La formula de pendiente ser la relacin para encontrar los coeficientes
de nuestro polinomio.
F(x)=b+b(x-x)+b(x-x)(x-x).+bn(x-x)(x-xn)
Donde;
b= coeficiente que encontraremos por el mtodo de diferencias divididas

x,xn,xn= a los valores del rango
x= valor a evaluar
Paso 1
De los puntos dados de mi funcin (recordemos que muchas veces solo nos
proporcionan el dominio y contradominio) (x,y) depender el polinomio que
debemos encontrar (vase en la parte superior de la pgina).
Paso 2
Cada pareja ordenada (x, y) le daremos un valor desde (X,Y),

(X,Y)..(Xn,Yn) y formamos con los datos dados, una tabla.
Paso 3
La parte central del mtodo de diferencias divididas, es la frmula de pendiente
aqu veremos la relacin: hasta un polinomio de grado 3
F(x)=
x
F(x,x)
F(x)=
F(x)=
F(x)=
F(x,x)
F(x,x,x)
F(x,x,x)
F(x,x,x,x)
F(x,x)
F(x,x), (x,x),(x,x) es igual a la pendiente de las respectivas distancia. Con

los coeficientes dados, formaran la siguiente parte la cual es:
F(x,x,x),(x,x,x) es igual a los coeficientes encontrados de las pendientes
anteriores, se dividirn entre la diferencia del mayor al menor de cada intervalo.
181
La ultima parte F(x,x,x,x) es igual a la relacin de los 4 puntos dados, los

coeficientes encontrados en el paso anterior se dividen entre la diferencia del
mayor al menor del intervalo.
Por ltimo los valores que nos queda en la diagonal roja, formaran los
coeficientes de nuestro polinomio, si se preguntan por qu calculamos los
dems, era porque eran necesarios para encontrar todos los valores.
Procedemos a formar nuestros polinomios con los coeficientes encontrados:
F(x)= b+b(x-x)+b(x-x)(x-x)+bn(x-x)(x-xn)
En este caso, nuestro polinomio ser de grado 3.

EJEMPLO:
Encontrar el valor aproximado de x=1.5 de la funcin e, con los siguientes
puntos dados.
X
Y
0
2.71828
7.38906
20.08654
Pendiente (0 a 1), (1,2), (2,3)

(2.71828-1)/1=2.711828, (7.38906-2.71828)/1=4.67078, (20.086547.38906)/=12.6869
Pendientes de (0, 1,2), (1, 2,3)
(4.67078-1.71828)/2=1.47625, (12.6989-4.67078)/2=4.01406
Pendiente de (0, 1, 2,3)

(4.01406-1.47625)/3=.8459
Formo mi polinomio recordemos la formula y sustituimos
F(x)=b+b(x-x)+b(x-x)(x-x)..+bn(x-x)(x-xn)
F(x)= 1+1.71828(x-1)+1.47625(x-1)(x-2)+0.84553(x-1)(x-2)(x-3)
182
F(x)= 1+1.71828(1.5)+1.47625(1.5)(1.5-1)+0.84553(1.5)(1.5-1)(1.5-2)
F(x)= 4.3675
El clculo exacto si lo situamos en la frmula es 4.48 por lo cual el margen de
error es muy pequeo
El polinomio obtenido satisface a los puntos de esa funcin.
GRAFICA:
Cdigo de programacin
183
Interfaz grfica:
Su programacin:
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package (smart_init)

TForm1 *Form1;
: TForm(Owner)
{
}
//--------------------------------------------------------------------------184

{
Close();
}
//---------------------------------------------------------------------------

{
Form2->Show();
Form2->Edit11->SetFocus();
}
//---------------------------------------------------------------------------
Interfaz grfica:
Su programacin:
//---------------------------------------------------------------------------
185
#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
#include "Unit3.h"
//---------------------------------------------------------------------------
#include <math.h>
double
a,a1,a2,b0,b1,b2,b3,x0,x1,x2,x3,x,y,y0,y1,y2,y3,Inicio,Fin,k,f,g,h,i,j,p,q,r,s,t,Fx1,Fx2,Fx3,Fx4,Fx5;
TForm2 *Form2;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
y0=Edit5->Text.ToDouble();
b0=y0;
b1=(y1-y0)/(x1-x0);
186
Label3->Caption=(b0);
}
//---------------------------------------------------------------------------

{
b0=y0;
b1=(y1-y0)/(x1-x0);
a=(y2-y1)/(x2-x1);
b2=(a-b1)/(x2-x0);
}
//---------------------------------------------------------------------------

{
187
b0=y0;
b1=(y1-y0)/(x1-x0);
a=(y2-y1)/(x2-x1);
b2=(a-b1)/(x2-x0);
a1=(y3-y2)/(x3-x2);
a2=(a1-a)/(x3-x1);
b3=(a2-b2)/(x3-x0);
}
//---------------------------------------------------------------------------

{
x=Edit9->Text.ToDouble();
y=b0+b1*(x-x0)+b2*(x-x0)*(x-x1)+b3*(x-x0)*(x-x1)*(x-x2);
Edit10->Text=AnsiString(y);
188
}
//---------------------------------------------------------------------------

{
Form3->Show();
Form3->Canvas->Pen->Color=clTeal;
Form3->Canvas->Pen->Color=0x009747EF;
Inicio=-10;
Fin=10;
x=Inicio;
Form3->Canvas->PenPos=TPoint(600+14*Inicio,200-5*y);
for(x=Inicio;x<Fin;x++)
189
{
Form3->Canvas->LineTo(600+15*x,200-5*y);
}
Inicio=-10;
Fin=10;
x=Inicio;
{
Canvas->PenPos=TPoint(600+15*x,200-5*y);
}
190
Inicio=-10;
Fin=10;
x=Inicio;
{
Form3->Canvas->LineTo(600+15*x,200-5*y);
}
}
//---------------------------------------------------------------------------

{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
191
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="";
Label3->Caption="";
Label4->Caption="";
Label5->Caption="";
Label6->Caption="";
Edit11->SetFocus();
}
//---------------------------------------------------------------------------

{
Close ();
}
//---------------------------------------------------------------------------
192

{
f=Edit11->Text.ToDouble ();
g=Edit12->Text.ToDouble ();
h=Edit13->Text.ToDouble ();
i=Edit14->Text.ToDouble ();
j=Edit15->Text.ToDouble ();
p=Edit1->Text.ToDouble ();
q=Edit2->Text.ToDouble ();
r=Edit3->Text.ToDouble ();
s=Edit4->Text.ToDouble ();
t=Edit16->Text.ToDouble ();
Fx1=f*(pow(p,4))+g*(pow(p,3))+h*(pow(p,2))+i*p+j;
Edit5->Text=AnsiString (Fx1);
Fx2=f*(pow(q,4))+g*(pow(q,3))+h*(pow(q,2))+i*q+j;
Fx3=f*(pow(r,4))+ g*(pow(r,3))+h*(pow(r,2))+i*r+j;
Fx4=f*(pow(s,4))+g*(pow(s,3))+h*(pow(s,2))+i*s+j;
Fx5=f*(pow(t,4))+g*(pow(t,3))+h*(pow(t,2))+i*t+j;
}
//--------------------------------------------------------------------------Interfaz grfica:
193
Su cdigo de programacin:
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
#include <math.h>
double a,a1,a2,b0,b1,b2,b3,x0,x1,x2,x3,x,y,y0,y1,y2,y3,Inicio,Fin,k;
TForm3 *Form3;
: TForm(Owner)
{
}
//--------------------------------------------------------------------------194

{
Close();
Form1->Visible=true;
}
//---------------------------------------------------------------------------
195
8. Primer Derivada por Mtodos Numricos
Derivacin
Cuando escuchamos la palabra derivada, siempre lo relacionamos con el
cambio de pendiente que sufre una funcin.
La derivada de una funcin es una medida de la rapidez con la que cambia el

valor de dicha funcin matemtica, segn cambie el valor de su variable
independiente. La derivada de una funcin es un concepto local, es decir, se
calcula como el lmite de la rapidez de cambio media de la funcin en un cierto
intervalo, cuando el intervalo considerado para la variable independiente se
torna cada vez ms pequeo. Por ello se habla del valor de la derivada de una
cierta funcin en un punto dado.
Tipos de derivacin
La derivacin clsica se opera sobre funciones
Funciones
3 2
4 3
Funciones
La derivacin cuando se conoce la funcin

= 3 2 + 7
1
Datos
= 6 + 7
13
Datos
19
25
196
Derivacin numrica
Datos
X0
Y0
X1
Y1
Datos
Este mtodo es empleado cuando carecemos la funcin y deseamos conocer

sus razones de cambio.
Se partir de una seria de datos, tabulados y ordenados, donde el rango tendr
razones de cambio iguales, a esto se le llamara salto. Cabe sealar que el salto
debe ser igual para todos los pares de datos, de manera contraria no podr
realizarse la derivacin o no con una seguridad que sea el resultado correcto.
Mtodo basado por el polinomio interpolador de newton (mtodo anterior) y la

seria de Taylor. Las derivadas se dan por orden, depende de la cantidad del
conjunto de datos a utilizar. Es decir ser de orden 1 cuando se utilizan 2 pares
de datos, de orden 2 si se usan 3, etc. el orden est regido por n 1 donde n
solo los nmeros de pares a utilizar.
Las frmulas para derivar no son iguales, depende del orden (pares de datos a
utilizar), la funcin estar dada por
Los pasos a seguir para la obtencin de la derivada sern los siguientes:

1) Conjunto de pares de datos (, ), identificar el orden de la derivada.
2) Polinomio interpolador de orden n.
3) Derivar el polinomio interpolador y evaluarlo en cada uno de sus puntos.
4) Frmula de orden n para el clculo de la primera derivada
197
Siguiendo los pasos anteriores tenemos que:
Derivacin numrica de orden 1.

*Se utilizara 2 pares ordenados.
1. Se desarrolla el polinomio interpolador.
2. Se derivada con respecto a la variable x.
Derivacin numrica de orden 2:

*Si = 2, entonces tenemos tres pares de puntos
0 1 2
0 1 2
198
() = () + ( 0 )( 1 )( 2 )
()
3!
Polinomio interpolador
1 0
1 0
2 1
2 1
() = 0 +
() =
2 1 1 0
2 1 1 0
2 0
1 0
2 21 + 0
( 0 ) +
( 0 )( 1 )
22
1 0 2 21 + 0
( 0 ) + ( 1 )
+
22
Evaluando en 0 , 1 , 2 :
(Por la derecha):
(0 ) =
1 0 2 21 + 0
(0 0 ) + (0 1 )
+
22
(0 ) =
1 0 2 21 + 0 2 + 41 30
2
2
(Central):
(1 ) =
1 0 2 21 + 0
(1 0 ) + (1 1 )
+
22
(1 ) =
1 0 2 21 + 0
2 0
+
=
2
2
(Por la izquierda):
(2 ) =
(2 ) =
1 0 2 21 + 0
(2 0 ) + (2 1 )
+
22
1 0 3(2 21 + 0 ) 21 20 + 32 61 + 30
+
=
2
2
32 41 + 0
=
2
199
Derivando el factor de error:
()
( 0 )( 1 )( 2 )
3!
= ( 0 )( 1 ) + ( 0 )( 2 ) + ( 1 )( 2 )
()
3!
Evaluando:
(0 ) =
2
3
(1 ) =
(2 )
()
En esta existe menor

error, ya que su
denominador es mayor.
2
()
6
2
= ()
3
El procedimiento anterior nos servir para formar la siguiente tabla para la

primer derivada de orden = 1,2 3.
( ) =

+ ()
Derecha
(1 ) =
1 0
()
Izquierda
2 + 41 30 2
+ ()
2
3
Derecha
Orden 1
=
Orden 2
(0 ) =
200
() =
()
(0 ) =
Izquierda
Derecha
3 + 62 31 20 3
+ ()
6
12
Central
0 61 + 32 + 23 3
()
6
12
Central
=
(2 ) =
(3 )
32 41 + 0 2
=
+ ()
2
3
Central
23 92 + 181 110 3
()
6
8
(1 ) =
Orden 3
2 0 2
()
2
6
113 182 + 91 20 3
=
+ ()
6
4
Izquierda
Tomaremos los coeficientes de las formulas anteriores para obtener las

frmulas para la primera derivada evaluando en cada punto.
201
Interfaz grafica:
Funciones de cada botn:

Botn Capturar Y[i]: Captura los valores para 0 , 1 , , y los guarda en
un arreglo lineal. Muestra el nmero de datos ingresados.
Botn Mostrar datos +: Muestra los valores de 0 , 1 , , , ubicando el
primer dato debajo de la etiqueta 0 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 0 , 1 , , , ubicando el
primer dato debajo de la etiqueta 0 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.
Boton Primera: calcula la primera derivada apoyndose de las formulas
obtenidas anteriormente.
Cdigo de programacin
//---------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
202
//---------------------------------------------------------------#pragma package(smart_init)
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]
{
Y[i]=Edit1->Text.ToDouble();
Label2->Caption="n= "+AnsiString(i-1);
Edit1->Text="";
Edit1->SetFocus();
a=i-4;
i++;
b=1;
}
//---------------------------------------------------------------//botn mostrar datos +
{
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]);
203
b=0;
}
//---------------------------------------------------------------//botn primera
{
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);
}
//----------------------------------------------------------------
//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;
}
//----------------------------------------------------------------
204
9. Segunda Derivada Numrica
La derivada de una funcin es una medida de la rapidez con la que cambia el

valor de dicha funcin matemtica, segn cambie el valor de su variable
independiente. La derivada de una funcin es un concepto local, es decir, se
calcula como el lmite de la rapidez de cambio media de la funcin en un cierto
intervalo, cuando el intervalo considerado para la variable independiente se
torna cada vez ms pequeo. Por ello se habla del valor de la derivada de una
cierta funcin en un punto dado.
El concepto de derivada es uno de los dos conceptos centrales del clculo
infinitesimal. El otro concepto es la antiderivada o integral; ambos estn
relacionados por el teorema fundamental del clculo. A su vez, los dos
conceptos centrales del clculo estn basados en el concepto de lmite, el cual
separa las matemticas previas, como el lgebra, la Trigonometra o la
Geometra Analtica, del Clculo. Quiz la derivada es el concepto ms
importante del Clculo Infinitesimal.
La derivada es un concepto que tiene variadas aplicaciones. Se aplica en

aquellos casos donde es necesario medir la rapidez con que se produce el
cambio de una magnitud o situacin. Es una herramienta de clculo
fundamental en los estudios de Fsica, Qumica y Biologa, o en ciencias
sociales como la Economa y la Sociologa. Por ejemplo, cuando se refiere a la
grfica de dos dimensiones de f, se considera la derivada como la pendiente de
la recta tangente del grfico en el punto x. Se puede aproximar la pendiente de
esta tangente como el lmite cuando la distancia entre los dos puntos que
determinan una recta secante tiende a cero, es decir, se transforma la recta
secante en una recta tangente. Con esta interpretacin, pueden determinarse
muchas propiedades geomtricas de los grficos de funciones, tales como
concavidad o convexidad
Prcticamente todas las formas que conocemos surgen a partir de ecuaciones
diferenciales, y de condiciones; por ejemplo en anlisis de seales ya que una
seal tiene un amplitud y una frecuencia, actan como funciones de senos y
cosenos, y para analizarlas te tienes que meter en una ecuacin diferencial.
205
En ingeniera se ocupan para analizar cuestiones tcnicas de cada rama, por

ejemplo, en electrnica con la ley de Ohm, en qumica con la leyes de los
gases ideales, en ingeniera civil se ocupan las derivadas para relacionar las
ecuaciones de cargas estticas con las ecuaciones de momentos flexionantes,
en mecnica se ocupan para calcular para calcular inercias, velocidades,
aceleraciones, y por lo tanto fuerzas internas y externas que actan en un
mecanismo.
INTERPRETACIN DE LA DERIVADA
INTERPRETACIN GEOMTRICA DE LA DERIVADA
Cuando h tiende a 0, el punto Q tiende a confundirse

con el P. Entonces la recta secante tiende a ser la recta
tangente a la funcin f(x) en P, y por tanto el ngulo
tiende a ser .
206
La pendiente de la tangente a la curva en un punto es igual a

la derivada de la funcin en ese punto.
m t = f'(a)
INTERPRETACIN FSICA DE LA DERIVADA

VELOCIDAD MEDIA
La velocidad media es el cociente entre el espacio recorrido
(e) y el tiempo transcurrido (t).
207
LA DERIVACIN NUMRICA
Es una de las tcnicas de anlisis numrico para poder calcular una
aproximacin a la derivada de una funcin en un punto utilizando valores y
propiedades.
La derivada es de uso comn en las matemticas y la ingeniera, ya que es la
prctica de muchas funciones con las que se trabaja. Es necesario proceder a
calcular el valor de algunas derivadas de algunas funciones en un punto
concreto. En este tipo de situaciones no se puede utilizar el concepto riguroso
de derivada por desconocimiento de la expresin de una funcin.
De esta manera surge la necesidad de disear mtodos numricos que
permitan aproximar el valor de las derivadas de una funcin en algn punto.
Los mtodos de derivacin numrica se desarrollaron con el fin de aproximar
algn valor buscado. La diferencia numrica es muy til en casos en los cuales
se tienen una funcin cuya derivada es difcil o complicada de hallar, o en
caso en los cuales no se tienen una funcin explicita sino una serie de datos
experimentales.
El problema de la derivacin numrica consiste en la evaluacin de la
derivada de la funcin de un punto, cuando nicamente conocemos los valores
de la funcin en una coleccin de puntos X0, X1...Xn.
La derivada es una propiedad esencialmente local, por lo cual deberemos
aproximar la funcin lo ms fielmente posible en el entorno inmediato del
punto en el que la queremos evaluar. La frmula de la derivacin numrica
aparece en el desarrollo de algoritmos para la solucin de problemas de
contorno en ecuaciones diferenciales ordinarias.
208
Frmulas de Diferencias Centradas

Son frmulas de aproximacin a f(x) que requieren que la Funcin se pueda
evaluar en abscisas situadas simtricamente a ambos lados del punto x0
(donde se desea hallar la derivada).
Formulas progresivas, regresivas y centrales

En el caso en que los puntos equidistan:
Xj = x0 + jh,
j=0, , n,
Se puede hablar tambin de las siguientes frmulas:

PROGRESIVAS:
209
REGRESIVAS:
Entonce
s, para
x= xj, se tiene la frmula:
CENTRALES:
210
A partir de las frmulas progresivas, regresivas o centrales para la

aproximacin de las derivadas primeras y teniendo en cuenta que la derivada
de orden v de f es la derivada primera de la derivada de orden (v-1) de f, se
pueden obtener frmulas para las derivadas de orden superior.
As por ejemplo, si consideramos las frmulas progresivas para la primera

derivada se tiene la siguiente frmula progresiva de la derivada segunda:
Razonando de la misma manera se pueden obtener otras frmulas para la

derivada segunda, partiendo de las regresivas o de las centrales, o incluso
combinando los distintos tipos.
211
Por ejemplo, considerando las frmulas centrales se tiene:
Combinando las frmulas centrales, las progresivas y las regresivas se tiene:
Mediante este mismo procso se pueden obtener frmulas para las derivadas de
orden tercero, cuarto, etc.
212
INTERFAZ GRFICA
213
PROGRAMACIN
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
#include "Unit4.h"
TForm1 *Form1;
214
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
Label4->Visible=True;
Button3->Visible=True;
Label4->Caption="Barrientos Alfaro Carlos";

Label5->Caption="Monterrosa Gmez Mario";
Label6->Caption="Velazquez Tapia Cristhian";
}
//---------------------------------------------------------------------------
215

{
Form2->Show();
}
{
Close();
}
//---------------------------------------------------------------------------
FORM 2
double x0, x1, x2, x3, x4, D, h, x, xi, xii, Fx, Fxi, Fxii, F1, F2, F3;
double Fxx, Fxx1, Fxx2, xi2, x2ii, Fxi2, Fx2ii, D1;
TForm3 *Form3;
//--------------------------------------------------------------------------216

: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm3::RadioButton1Click(TObject *Sender)

{
D=1;
}
//---------------------------------------------------------------------------

{
D=2;
}
//--------------------------------------------------------------------------void __fastcall TForm3::RadioButton3Click(TObject *Sender)
{
D=3;
}
//--------------------------------------------------------------------------217

{
Image1->Visible=True;
Image2->Visible=False;
x=Edit6->Text.ToDouble();
xi= x+h;
xii= x-h;
Fx= (x4* pow(x,4))+(x3*pow(x,3))+ (x2*pow(x,2))+(x1*x)+(x0);
Fxi= (x4* pow(xi,4))+(x3*pow(xi,3))+ (x2*pow(xi,2))+(x1*xi)+(x0);
Fxii= (x4* pow(xii,4))+(x3*pow(xii,3))+ (x2*pow(xii,2))+(x1*xii)+(x0);
if (D==1)
218
F1= (Fxi - Fx) /h;
Edit8->Text=AnsiString(F1);
Edit15->Text=AnsiString(x);
Edit16->Text=AnsiString(xi);
}
if (D==3)
{
F3= (Fx - Fxii) /h;
Edit15->Text=AnsiString(x);
}
if (D==2)
{
F2= (Fxi - Fxii) /(2*h);
219
Edit14->Text=AnsiString(xii);
Edit16->Text=AnsiString(xi);
}
{
Close();
}
{
D1=1;
}
//--------------------------------------------------------------------------220

{
D1=2;
}
//---------------------------------------------------------------------------

{
D1=3;
}
//---------------------------------------------------------------------------

{
Image1->Visible=False;
221
xi2= x+(2*h);
x2ii= x- (2*h);
Fxi2= (x4* pow(2,4))+ (x2*pow(i2,2))+(x1*x2)+(x0);
Fx2ii= (x4* pow(xii,4))+(x3*pow(x2ii,3))+

(x2*pow(xii,2))+(x1*x2ii)+(x0);
if (D1==1)
{
F= (Fxi2- (2*Fxi)+ Fx)/ (h*h) ;
Edit11->Text=AnsiString(Fx);
}
if (D1==3)
{
Fxx1= (Fxi2- Fxi-Fx+Fx2ii)/ (h*h*2) ;
Edit13->Text=AnsiString(Fxx1);
222
if (D1==2)
{
Fxx2= (Fxi2-(2*Fx)+Fx2ii)/ (h*h*4) ;
Edit12->Text=AnsiString(Fxx2);
}
//---------------------------------------------------------------------------

{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
223
Edit12->Text="";
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit1->SetFocus();
FORM 3
#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
#include "Unit4.h"
224
double g, y0, y1, y2, y3, Fy0, Fy1, Fy2, Fy3, a0, a1,a2, p1, p2,p3, yi, pol,
p2i;
double w, w2,poli, polii,H, ai1, ai2, ai3, v;
TForm4 *Form4;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
Fy0=Edit1->Text.ToDouble();
225
H=Edit10->Text.ToDouble();
a0= Fy0/ ((y0-y1)*(y0-y2*100));

v3= Fy1/ ((y1-y0)+(y1-y2));
g= Fy2/ ((y2-y0)-y2-y1));
df=Edit9->Text.ToDouble();
ai1=(a0*(yi-y1)+(yy2));
ai3=(a2)*(yi-1));
pol= ai1+ai2+ai3;
poli= pol+H;
pol= pol-H;
Edit12->Text=AnsiString(pol);
Edit11->Text=AnsiString(polii);
Edit13->Text=AnsiString(poli);
226
Edit14->Text=AnsiString(Fxx);
Edit15->Text=AnsiString(g3) ;
Edit16->Text=AnsiString(gg2) ;
}
{
v=1;
}
{
v=2;
}
{
v=3;
}
//--------------------------------------------------------------------------227
10.
Integracin numrica por el mtodo de

Simpson tres octavos
En anlisis numrico la integracin numrica constituye una amplia gama de

algoritmos para calcular el valor numrico de una integral definida y, por
extensin, el trmino se usa a veces para describir algoritmos numricos para
resolver ecuaciones diferenciales. El trmino cuadratura numrica (a menudo
abreviado a cuadratura) es ms o menos sinnimo de integracin numrica,
especialmente si se aplica a integrales de una dimensin a pesar de que para
el caso de dos o ms dimensiones (integral mltiple) tambin se utilizan.
El problema bsico considerado por la integracin numrica es calcular una

solucin aproximada a la integral definida:
Este problema tambin puede ser enunciado como un problema de valor inicial
para una ecuacin diferencial ordinaria, como sigue:
Encontrar y(b) es equivalente a calcular la integral. Los mtodos desarrollados

para ecuaciones diferenciales ordinarias, como el mtodo de Runga-Kutta
pueden ser aplicados al problema reformulado. En este artculo se discuten
mtodos desarrollados especficamente para el problema formulado como una
integral definida.
La frmula fue utilizada por primera vez por Evangelista Torricelli, pero debe su
nombre al matemtico Ingls Thomas Simpson. Corresponde a la regla del
tonel que Johannes Kepler ya haba formulado en 1615.
Sobre la historia de su surgimiento, Kepler la describe en la dedicatoria de su
publicacin posterior. Despus de que la primera esposa de Kepler haba
muerto en Praga en 1611, Kepler se cas nuevamente -en Linz, donde ahora
228
trabajaba- en 1613. Para la boda compr algunos toneles de vino. Puesto ya el

vino en la bodega, el vendedor concurri con una vara de medir y determin el
contenido para todos los barriles sin calcular, utilizando un mismo mtodo,
consistente en introducir la punta de metal de la vara de medir a travs de la
piquera, en diagonal hacia los bordes de ambos fondos, la marca en la piquera
arrojaba la medida del volumen del contenido. Kepler se sorprendi con aquello
de que una diagonal a travs del medio del barril pudiera dar una medida sobre
el volumen contenido y puso en duda la exactitud de este mtodo, debido a que,
por ejemplo, un barril muy bajo que tuviera una base algo ms ancha y por eso
un volumen contenido mucho menor podra tener el mismo radio a la vista.
A raz de esto, Kepler formul en 1615 el escrito Nova Stereometria doliorum
vinariorum ('Nuevo clculo del contenido de barriles de vino'), en el que
buscaba mtodos verificables para el clculo del contenido de los toneles de
vino. Uno de estos mtodos consisti en aproximar la curvatura del barril por
una parbola, dado que los clculos con ayuda de parbolas ya se podan
realizar muy exactamente desde Arqumedes.4
Entre otras cosas, Kepler describi en ese texto una frmula para el clculo de
la capacidad (ms precisamente, del volumen) de barriles de vino con formas
irregulares. Esta frmula arroja valores exactos para el tronco de la pirmide
(incluida la pirmide), la esfera, el paraboloide elptico, el hiperboloide de una
hoja y todas las dems superficies de un cuerpo que pueden ser generadas por
secciones planas perpendiculares al eje del cuerpo.
Razones para la integracin numrica

Hay varias razones para llevar a cabo la integracin numrica. La principal
puede ser la imposibilidad de realizar la integracin de forma analtica. Es decir,
integrales que requeriran de un gran conocimiento y manejo de matemtica
avanzada pueden ser resueltas de una manera ms sencilla mediante mtodos
numricos.
Incluso existen funciones integrables pero cuya primitiva no puede ser
calculada, siendo la integracin numrica de vital importancia. La solucin
analtica de una integral nos arrojara una solucin exacta, mientras que la
solucin numrica nos dara una solucin aproximada. El error de la
229
aproximacin, que depende del mtodo que se utilice y de qu tan fino sea,
puede llegar a ser tan pequeo que es posible obtener un resultado idntico a
la solucin analtica en las primeras cifras decimales.
Formula de newton-cotes
En anlisis numrico las frmulas de Newton-Cotes (nombradas as por Isaac
Newton y Roger Cotes) son un grupo de frmulas de integracin numrica de
tipo interpolatorio, en las cuales se evala la funcin en puntos equidistantes,
para as hallar un valor aproximado de la integral. Cuantos ms intervalos se
divida la funcin ms preciso ser el resultado.
Este mtodo es eficiente si se conocen los valores de la funcin en puntos
igualmente separados. Si se pueden cambiar los puntos en los cuales la
funcin es evaluada otros mtodos como la cuadratura de Gauss son
probablemente ms eficientes.
Estas a su vez se dividen en:
Formulas cerradas de newton-cotes
Regla del trapecio

Reglas de Simpson
Regla de Boole
Regla de quinto orden
Regla de Sexto orden
formulas abiertas de newton-cotes

Regla del punto medio
Regla del trapecio compuesta
Reglas de Simpson
En anlisis numrico, la regla o mtodo de Simpson, nombrada as en honor a
Thomas Simpson (y a veces llamada regla de Kepler), es un mtodo de
integracin numrica para obtener el valor aproximado de integrales definidas.
Se dividen en dos:
Regla de Simpson 1/3
Regla de simpson3/8
Regla de simpson3/8
230
Los ingenieros encuentran con frecuencia el problema de integrar funciones

que estn definidas en forma tabular o en forma grfica y no como funciones
explcitas, se pueden utilizar mtodos grficos, pero los mtodos numricos
son mucho mas precisos.
A continuacin se describe la regla de integracin de Simpson 3/8 para la
integracin cerrada es decir, para cuando los valores de la funcin en los
extremos de los lmites de integracin son conocidos.
El mtodo de Integracin Simpson 3/8 consiste en tomar el rea bajo una
ecuacin cbica que conecta cuatro puntos, como se muestra en la siguiente
grfica:
Dada una funcin tabular con espaciamientos constantes, de la forma:
La frmula de integracin de Simpson 3/8 es la siguiente:
231
Esta programa est basado en la regla de Simpson 3/8, est programado para
integrar funciones de quinto grado y obtener su cuarta derivada, el uso del
programa de es fcil a continuacin una serie de pasos de cmo utilizar el
programa:
1) Introducimos los lmites de la funcin que sera de a a b y capturamos
a,b.
232
2) Introducimos la funcin de quinto grado si la funcin a introducir no es de

quinto grado se coloca el cero en donde le corresponda por ejemplo la
siguiente funcin: x^3+8; entonces en el programa se escribira as:
3) Damos click en calcular h,X1,X2, y nos brindara los valores

correspondiente adems por definicin de la formula le damos click
sobre la formula y nos ofrecer el resultado de la sustitucin de cada
punto a,b,X1,X2; y el valor aproximado de la integral definida.
4) Para calcular el Error Aproximado de la formula terica calculamos su

cuarta deriva de la funcin antes introducida y introducimos una valor
que se encuentre entre los lmites de la integral entre a, b y programa lo
sustituir en la formula y calculara el error aproximado que es terico no
necesariamente es real.
5) A continuacin la programacin;
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
TForm1 *Form1;
TForm1 *Form2;
233

: TForm(Owner)
{
}
{
Form2->Show();
}
{
Close();
}
//-------------------------------------------------------------------------Form2.
#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
#include <math.h>
double a,b,h,hf,h1,Xm,Xn,c,d,e,f,g,fXm,fXn,fa,inte,fb,a1,a2,a3,a4,a5,b1,b2,b3,b4,
b5,Xm5,Xm4,Xm3,Xm2,Xm1,Xn5,Xn4,Xn3,Xn2,Xn1,fsus,m1,m2,O,k,A5,A4,A3,A2,A1,B4,B3,
B2,B1,C3,C2,C1,D2,D1,E1,Fsus,E,h2,Ea,Ea1;
TForm2 *Form2;
: TForm(Owner)
234
{
}
{
c =Edit6->Text.ToDouble();
d =Edit7->Text.ToDouble();
e =Edit8->Text.ToDouble();
f =Edit9->Text.ToDouble();
g =Edit10->Text.ToDouble();
h1 =Edit11->Text.ToDouble();
}
{
}
{
h=b-a;
hf=h/3;
Xm=a+hf;
Xn=Xm+hf;
Edit3->Text=AnsiString(hf);
Edit4->Text=AnsiString(Xm);
Edit5->Text=AnsiString(Xn);
a2=pow(a,2);
a3=pow(a,3);
a4=pow(a,4);
235
a5=pow(a,5);
a1=a;
b2=pow(b,2);
b3=pow(b,3);
b4=pow(b,4);
b5=pow(b,5);
b1=b;
Xm2=pow(Xm,2);
Xm3=pow(Xm,3);
Xm4=pow(Xm,4);
Xm5=pow(Xm,5);
Xm1=Xm;
Xn2=pow(Xn,2);
Xn3=pow(Xn,3);
Xn4=pow(Xn,4);
Xn5=pow(Xn,5);
Xn1=Xn;
}
//--------------------------------------------------------------------------void __fastcall TForm2::Image5Click(TObject *Sender)
{
Close();
}
{
fa=(c*a5)+(d*a4)+(e*a3)+(f*a2)+(g*a1)+h1;
fXm=(c*Xm5)+(d*Xm4)+(e*Xm3)+(f*Xm2)+(g*Xm1)+h1;
fXn=(c*Xn5)+(d*Xn4)+(e*Xn3)+(f*Xn2)+(g*Xn1)+h1;
fb=(c*b5)+(d*b4)+(e*b3)+(f*b2)+(g*b1)+h1;
Edit13->Text=AnsiString(fa);
236
Edit14->Text=AnsiString(fXm);
Edit15->Text=AnsiString(fXn);
Edit16->Text=AnsiString(fb);
fsus=fa+(3*fXm)+(3*fXn)+fb;
k=(.125)*h;
inte= k*fsus ;
Edit12->Text=AnsiString(inte);
}
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
h=0;
fXm=0;
fXn=0;
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
237
Edit20->Text="";
}
{
A5=c*5;
B4=d*4;
C3=e*3;
D2=f*2;
E1=g;
A4=A5*4;
B3=B4*3;
C2=C3*2;
D1=D2;
A3=A4*3;
B2=B3*2;
C1=C2;
A2=A3*2;
Edit17->Text=AnsiString(A2);
B1=B2;
Edit18->Text=AnsiString(B1);
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Image7Click(TObject *Sender)

{
E= Edit19->Text.ToDouble();
Fsus=(A2*E)+B1;
h2=pow(h,5);
Ea=-(h2/6480);
Ea1=Ea*Fsus;
Edit20->Text=AnsiString(Ea1);
}
//--------------------------------------------------------------------------238
11.
Solucin de ecuaciones diferenciales por el

mtodo de Taylor.
Introduccin
En el siguiente trabajo se hablara de las ecuaciones diferenciales ordinarias de
primer orden y como poder resolverla usando el mtodo de series de Taylor,
daremos una explicacin amplia de que es una ecuacin diferencial y sus
clasificaciones, en que consiste el mtodo de series de Taylor y por supuesto
diremos quin es Taylor.
Despus combinaremos la informacin de ecuaciones diferenciales y la serie
de Taylor, para poder resolver dichas ecuaciones e idearemos un programa
que nos ayude en el proceso de resolucin de las ecuaciones diferenciales
ordinarias de primer orden.
239
Fundamento terico
Una ecuacin diferencial es una ecuacin que relaciona de manera no trivial a
una funcin desconocida y una o ms derivadas de esta funcin desconocida
con respecto a una o ms variables independientes. Si la funcin desconocida
depende de una sola variable la ecuacin diferencial se llama ordinaria, y si
depende de ms de una variable, se llama parcial.
La frase de manera no trivial que hemos usado en la definicin anterior
tiene como propsito descartar ecuaciones diferenciales que satisfacen la
definicin, pero son realmente identidades, es decir, son siempre verdaderas
sin importar quin sea la funcin desconocida.
(, , , , , ) =

, , , , , =
= (, , , , , )
Llamamos integrar la ecuacin diferencial al proceso por el que se encuentra, a

partir de la ecuacin diferencial dada, la relacin directa entre e .
Clasificacin de las ecuaciones diferenciales.

Las ecuaciones diferenciales se clasifican segn su tipo, orden y linealidad.
Clasificacin segn su tipo.
Si una ecuacin contiene una o ms derivadas de variables dependientes con
respecto a una sola variable independiente se dice que es una ecuacin
diferencial ordinaria.
Por ejemplo:
+ = ,
+ = y
+ = +
Una ecuacin con una o ms derivadas de variables dependientes de dos o

ms variables independientes se llama ecuacin diferencial parcial (EDP).
Por ejemplo:

+ = ,
240
Clasificacin segn su orden.

El orden de una ecuacin diferencial es igual al de la derivada de ms alto
orden que aparece de manera no trivial en la ecuacin. La frase de manera no
trivial tiene el fin de evitar situaciones como la siguiente cuyo orden es uno y no
tres, como podra pensarse.

+ =
Clasificacin segn la Linealidad.

Se dice que una ecuacin diferencial ordinaria de orden n es lineal si es lineal
en , , , , . La variable dependiente "" y todas sus derivadas
, , , son de primer grado. Y los coeficientes 0 , 1 , dependen solo
de la variable x.
Una ecuacin diferencial no lineal es aquella que NO es lineal, no cumple con
las condiciones de las ecuaciones lineales. Ejemplos de ecuaciones
diferenciales lineales.
) + =
) + + =
) ( ) + =
Ejemplos de ecuaciones no lineales.
a) (1 ) 2 = , es una ecuacin diferencial no lineal porque el
coeficiente de la variable dependiente y'' tambin depende de y.
b) + = 0, es una ecuacin diferencial no lineal porque la funcin
seno es funcin de y.
c) + 2 = 0, es una ecuacin diferencial no lineal porque la potencia de la
variable y es 2, y no 1 para que sea lineal.
d) ()3 + 3 = 0, es una ecuacin diferencial no lineal porque la
potencia de la variable y''' es 3 y para ser lineal debe ser 1.
Soluciones para las ecuaciones diferenciales.
241
Se llama solucin (o integral) de la ecuacin diferencial a cualquier funcin

= () que introducida en la ecuacin diferencial la transforma en igualdad y
verifica la ecuacin.
Tipos de soluciones
Explicitas: La variable dependiente y se expresa tan solo en trminos de la
variable independiente "" y constantes.
Implcitas: Se trata de una relacin (, ) = 0 en la que no se puede
despejar y mediante funciones elementales. Son soluciones todas las () que
cumplen (, ) = 0.
Una ecuacin diferencial puede tener una cantidad infinita de soluciones que
corresponden a las posibles elecciones de valores para los parmetros.
Solucin general: Es aquella solucin de la ecuacin que est en la forma
estndar; la cual, est definida en un intervalo y llegando a ser de esta manera
miembro de la familia de soluciones. La solucin general est conformada por
las constantes paramtricas, dependiendo del orden de la ecuacin y el
nmero de stas.
Solucin particular: Es una funcin cuya tangente a su grfica en un punto

cualquier punto (0 , 0 ) coincide con la tangente de otra solucin, pero ya no
coincide con esta ltima tangente en ninguna vecindad del punto (0 , 0 ), por
pequea que esta sea. Estas soluciones no se obtienen a partir de la solucin
general. Un mtodo para encontrar dichas soluciones es derivar la ecuacin
diferencial dada con respecto a .
242
Edmonton
Biografa de Brook Taylor.
Ciudad de Canad
Brook Taylor
(18/08/1685 - 29/12/1731)
Matemtico britnico
Naci el 18 de agosto de 1685 en Edmonton.

Curs estudios en la Universidad de St. John de Cambridge en la que entr en
1701. Se termin la licenciatura en derecho 1709, y se doctor en 1714.
Estudi matemticas con John Machin y John Keill.
En 1708 Taylor produjo una solucin al problema del centro de oscilacin, la
cual, desde que fuera difundida hasta 1724, resultaba ser la disputa prioritaria
con Johann Bernoulli. En "Los mtodos de incrementacin directa e inversa" de
Taylor (1715) agregaba a las matemticas una nueva rama llamada ahora "El
clculo de las diferencias finitas", e invent la integracin por partes y descubri
la clebre frmula conocida como la Serie de Taylor, la importancia de esta
frmula no fue reconocida hasta 1772, cuando LaGrange proclam los
243
principios bsicos del Clculo Diferencial. Taylor tambin desarroll los

principios fundamentales de la perspectiva en "Perspectivas Lineales" (1715).
En su Methodus Incrementorum Directa et Inversa (Londres, 1715) desarroll
una nueva parte dentro de la investigacin matemtica, que hoy se llama
clculo de las diferencias finitas. Junto con "Los nuevos principios de la
perspectiva lineal". Taylor da cuenta de un experimento para descubrir las
leyes de la atraccin magntica (1715) y un mtodo no probado para aproximar
las races de una ecuacin dando un mtodo nuevo para logaritmos
computacionales (1717).
Fue admitido como socio de la Real Sociedad en 1712 y nombrado en ese ao
para integrar un comit para la adjudicacin de las demandas de Isaac
Newton y de Leibnitz de haber inventado el Clculo.
Su matrimonio en 1721 con una dama de Wellington, Surrey, le enemist con
su padre, que acabaron en 1723 tras la muerte de su mujer durante el parto, en
el que tambin muri el nio. Los dos aos siguientes los pas con su familia
en Bifrons; en 1725 se cas, esta vez con la aprobacin de su padre, con
Sabetta Sawbridge de Olantigh, Kent, que tambin muri de parto en 1730; en
esta ocasin, sin embargo, su hija sobrevivi. Su frgil salud hizo que su
estado degenerara con rapidez;
Brook Taylor muri en Somerset House el 29 de diciembre de 1731.
Mtodo de serie de Taylor.

En matemticas, una serie de Taylor es una representacin de
una funcin como una infinita suma de trminos.
Estos trminos se calculan a partir de las derivadas de la funcin para un
determinado valor de la variable (respecto de la cual se deriva), lo que
involucra un punto especfico sobre la funcin. Si esta serie est centrada
sobre el punto cero, se le denomina serie de McLaurin.
Esta representacin tiene tres ventajas importantes:
La derivacin e integracin de una de estas series se puede realizar

trmino a trmino, que resultan operaciones triviales.
Se puede utilizar para calcular valores aproximados de la funcin.
Es posible demostrar que, si es viable la transformacin de una funcin a

una serie de Taylor, es la ptima aproximacin posible.
Algunas funciones no se pueden escribir como serie de Taylor porque tienen

alguna singularidad. En estos casos normalmente se puede conseguir un
desarrollo en serie utilizando potencias negativas de x (Serie de Laurent. Por
ejemplo f(x) = (1/x) se puede desarrollar como serie de Laurent).
244
Definicin de mtodo.
La serie de Taylor es una herramienta matemtica que si se usa
aproximadamente facilita muchos los clculos de aproximacin de funciones.
La idea fundamental detrs de la serie de Taylor es la de poder aproximar los
valores de una funcin () para cualquier punto "", a partir de tener un punto
de referencia "" situado a una distancia "" del primero y todo esto a partir de
la creacin de un polinomio basado en una serie de potencias infinita para la
cual sea posible de manera sistemtica calcular sus coeficientes.
()
()
() ()
(
(
( ) +
() = () +
) +
) +
!
!
!
()
( )
+
!
Que puede ser escrito

siguiente sumatoria.
de
una
manera
ms
compacta
como
la
( )
( )
!
Donde ! es el factorial de y () () denota la n-sima derivada de para el

valor a de la variable respecto de la cual se deriva. La derivada de orden cero
de f es definida como la propia y tanto ( )0 como 0! como 1 (0! = 1). En
caso de ser = 0, como ya se mencionara, la serie se denomina tambin de
Maclaurin.
Cabe destacar que en una serie de Taylor de potencias centrada en de la

forma:
( ) Siempre se puede hacer el cambio de variable = (con lo
que = + en la funcin a desarrollar original) para expresarla como
centrada en 0.
Luego hay que deshacer el cambio de variable. Por ejemplo, si se quiere
desarrollar la funcin () = alrededor de = 1se puede tomar = 1,
de manera que se desarrollara ( + 1) = ( + 1)( + 1) centrada en 0.
Historia de las series de Taylor.

El filsofo eleata Zenn de Elea consider el problema de sumar una serie
infinita para lograr un resultado finito, pero lo descart por considerarlo
245
imposible:
el
resultado
fueron
las paradojas
de
Zenn.
Posteriormente, Aristteles propuso una resolucin filosfica a la paradoja,
pero el contenido matemtico de esta no qued resuelto hasta que lo
retomaron Demcrito y despus Arqumedes.
Fue a travs del mtodo exhaustivo de Arqumedes que un nmero infinito de
subdivisiones geomtricas progresivas podan alcanzar un resultado
trigonomtrico finito. Independientemente, Liu Hui utiliz un mtodo similar
cientos de aos despus.
En el siglo XIV, los primeros ejemplos del uso de series de Taylor y mtodos
similares fueron dados por Madhava de Sangamagrama. A pesar de que hoy
en da ningn registro de su trabajo ha sobrevivido a los aos, escritos de
matemticos hindes posteriores sugieren que l encontr un nmero de casos
especiales de la serie de Taylor, incluidos aquellos para las funciones
trigonomtricas del seno, coseno, tangente y arco-tangente.
En el siglo XVII, James Gregory tambin trabaj en esta rea y public varias
series de Maclaurin. Pero en 1715 se present una forma general para
construir estas series para todas las funciones para las que existe y fue
presentado por Brook Taylor, de quin recibe su nombre. Las series de
Maclaurin fueron nombradas as por Colin Maclaurin, un profesor de Edimburgo,
quin public el caso especial de las series de Taylor en el siglo XVIII.
Solucin de ecuaciones diferenciales ordinarias de primer orden por el

mtodo de series de Taylor.
Como ya tenemos la conceptualizacin y generalidades de que es una
ecuacin diferencial y en que consisten las series de Taylor. Ahora si podemos
solucionar ecuaciones diferenciales ordinarias de primer orden por el mtodo
de series de Taylor;
Como ya vimos anteriormente el desarrollo en serie de Taylor, en torno a un
punto = :
()
()
()
( ) +
( ) +
( ) +
() = () +
!
!
!
()
( )
+
!
( )
( )
( )
()
()
() = () +
+
+
+
!
!
!
( )
+ ()
!
()
246
Ahora:
1.- La funcin () debe pertenecer al ser infinito esto quiere decir que tenga
infinitas derivadas.
2.- Que la serie converge (que por ms que crezca la serie o la alarguemos
hacia el infinito, la suma de todos sus elementos tiende a un lmite n).
Si en particular hacemos = y = + entonces la ecuacin cambiaria:
= , = , =
"" ""
( + ) = ( ) + ( )
()
()
()
()
+ ( )
+ ( )
+ + ( )
!
!
!
!
3.- Contando con una condicin inicial, Usaremos los primeros trminos de la
sucesin en serie para aproximar los valores de "" o ().
4.- Derivaremos la funcin, claro que no se puede derivar infinitas veces, pero
entre ms veces se derive ms aproximado ser el resultado
(), (), (), , ()

5.- Obteniendo las derivadas en funcin a la variable independiente, se
sustituirn los valores de la condicin inicial, en cada una de las derivadas.
6.- Teniendo los valores de las derivadas se sustituirn en la serie de Taylor
para obtener el polgono que se aproxima a la funcin original, dependiendo las
condiciones iniciales es la serie de Taylor que se usara.
()
()
()
( ) +
( ) +
( ) +
!
!
!
()
( )
+
!
() = () +
()
() = () +
()
()
()
()
()
()
()
+
+
+ +
!
!
!
!
Ejemplos:
Usar las series de Taylor para hallar la solucin en serie de
= 2 . Donde
la condicin inicial es = 1 en = 0. Usaremos los primeros trminos de esta

solucin en serie para aproximar los valores de .
Solucin: como = 0 entonces,

247
= () + () +
() ()
+
+
!
!
(0) = 1 e = 2 , derivando se tiene lo siguiente:

() =
=
() =
() = =
= + ( )
() = + =
= +
() = + =
= + + ( )
() = + + =
Por tanto la aproximacin:

= () + () +
() () () ()
+
+
+

!
!
!
!
Reemplazando los valores encontrados tenemos:

= + + + +
+

Ahora ya se puede aproximar la solucin de y para diferentes intervalos de t. es

decir dar valores dentro de un intervalo en la anterior serie.
Usar las series de Taylor para hallar la solucin en serie de 0 = 1, 0 = 1,

= 0.1, aplicando la regla obtendremos:
Solucin:
= +
=1
248
= = ()() =
= + = ()() + =
Por lo que la ecuacin particular es:

() = ( ) + ( )() + ( )
()
.
= + (. ) +
= .
!
Cdigo del programa y explicacin
PASOS A SEGUIR PARA GUARDAR EL PROYECTO:
1. Cargar B:
Al cargarlo se crea automticamente un proyecto visual.
2. Guardar el proyecto visual:

File Save Project As
3. Entra a la carpeta creada para guardar los proyectos.
4. Crear folder nuevo.
5. Nombrar al folder proyecto Individual.
249
6. Entrar al folder creado.
7. Oprimir el botn Guardar.
8. Dar el siguiente nombre al proyecto Proyecto en Equipo.
9. Oprimir el botn Guardar.
INTERFAZ GRAFICA:
Presentacin del programa, con dos botones uno para entrar a la ventana
principal y el otro para salir del programa.
1. Poner en el formulario 8 componentes tipo Label.

1.1 Seleccionar cada componente y en la propiedad Caption cambiar el
nombre de los componentes tal y como apare en la imagen de la
interfaz grfica.
2. Poner en el formulario 2 componentes tipo Button.
interfaz grfica.
2.2 Seleccionar individualmente cada componente tipo Button y escribir
la programacin asignada para cada componente.
250
2.3 Para poder acceder a escribir la programacin se deber seleccionar

el componente y darle doble click.
Programacin de Form1 (Presentacin):

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
TForm1 *Form1;
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

{
251
Close();
}
//---------------------------------------------------------------------------

{
Form2->Show();
}
//---------------------------------------------------------------------------
Ventana principal.
Esta ventana consta de 27 componentes Edit de los cuales 17 estn ocultos para aparecer
cuando se cumplan ciertas condiciones del programa, con 7 botones, 3 de ellos para
calcular, 2 para leer datos y guardarlos, uno para regresar a la presentacin y uno para
borrar todos los datos.
Auxilindonos de los componentes RadioButton los cuales se corresponde una ecuacin
diferente dependiendo que se quiere calcular, si lo que se quiere calcular es la solucin
general de la ecuacin diferencial, la cual es otra ecuacin debemos dar las condiciones
iniciales y se marcara el RadioButton1 o bien si lo que se desea es saber la posicin de un
punto a una distancia de un punto conocido (0 , 0 ) en las condiciones iniciales
daremos el valor de .
252
Interfaz grfica para calcular la funcin aproximada a la deseada.
253
Calcular un punto a una distancia h de a respecto a x.
1. Poner en el formulario 14 componentes tipo Label.

interfaz grfica.
2. Poner en el formulario 27 componentes tipo Edit.
254
2.1 Seleccionar los componentes tipo Edit y en la propiedad Text borrar

la palabra Edit.
3. Poner en el formulario 2 componentes tipo Radio Button.

interfaz grfica.
4. Poner en el formulario 7 componentes tipo Button.

interfaz grfica.
4.2 Seleccionar individualmente cada componente tipo Button y escribir
la programacin asignada para cada componente.
4.3 Para poder acceder a escribir la programacin se deber seleccionar
el componente y darle doble click.
Programacin del Form2 (Ventana principal):
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
#include "Unit3.h"
#include <math.h>
double a, b, c, d, e, f, g, h, i, m, n;
255
TForm2 *Form2;
: TForm(Owner)
{
}
{
Close();
}
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit10->Text="";
Edit11->Text="";
RadioButton1->Checked=false;
256
Edit9->Visible=false;
Image5->Visible=false;
}
{
if(Edit1->Text==""){
Edit1->Text="Sin dato";
}
if(Edit1->Text!="Sin dato"){
}
257
}
}
}
}
if(Edit1->Text=="Sin dato" || Edit2->Text=="Sin dato"){
}
if(Edit1->Text!="Sin dato" && Edit2->Text!="Sin dato" && Edit3->Text!="Sin

dato"){
RadioButton2->Checked=true;
}
if(Edit1->Text!="Sin dato" && Edit2->Text!="Sin dato"&& Edit3->Text=="Sin
dato"){
RadioButton1->Checked=true;
}
}
258
{
if(RadioButton2->Checked==true){
m=b+(d*c)+(e*c*c/2)+(f*c*c*c/6)+(g*c*c*c*c/24);
Edit11->Text=AnsiString(m);
}
}
//---------------------------------------------------------------------------

{
if(Edit4->Text=="" || Edit4->Text=="Falta derivada"){
Edit4->Text="Falta derivada";
}
if(Edit4->Text!="Falta derivada"){
}
}
}
}
f=Edit6->Text.ToDouble();
}
259
}
g=Edit7->Text.ToDouble();
}
}
}
}
{
if(RadioButton1->Checked==true) {
Edit10->Text="Falta la variable h";
}
if(RadioButton2->Checked==true && Edit8->Text!="" && Edit8->Text!="Falta
derivada") {
n=h*c*c*c*c*c/120;
Edit10->Text=AnsiString(n);
}
if(RadioButton2->Checked==false || Edit8->Text=="" || Edit8->Text=="Falta
derivada"){
Edit10->Text="Falta algun dato";
}
260
}
{
if(RadioButton1->Checked==true && Edit1->Text!="0"){
Edit9->Visible=true;
Edit9->Text=AnsiString(b);
Edit12->Text=AnsiString(d);
Edit14->Text=AnsiString(e);
Edit16->Text=AnsiString(f);
Edit18->Text=AnsiString(g);
Edit20->Text=AnsiString(h);
}
261
if(RadioButton1->Checked==true && Edit1->Text=="0"){

262
Image5->Visible=true;
}
263
12.
Lgica difusa
Lotfi Asker Zadeh. Matemtico, ingeniero elctrico, informtico y profesor

azerbaiyano de la Universidad de Berkeley. Es famoso por introducir en 1965 la
teora de conjuntos difusos o lgica difusa. Se le considera asimismo el padre
de la teora de la posibilidad.
Es una forma matemtica en el que la verdad puede tomar un valor de un

rango continuo de valores entre 0 y 1.Es una extensin de lgica de dos
valores de tal manera que un enunciado no necesariamente es verdadero o
falso, pero puede tener un grado de verdad entre 0 y 1.Tales sistemas pueden
ser extremadamente tiles en el diseo de lgica de control para sistemas del
mundo real.
EJEMPLO COTIDIANO
Un vaso medio lleno, independientemente de que tambin este medio vaco, no

est lleno completamente ni est vaco completamente.
Que tan lleno puede estar es un elemento de una incertidumbre, es decir, de

difucidad, entendida esta ltima como una propiedad de indeterminismo
EN QUE SITUACIONES ES UTIL APLICAR LA LOGICA DIFUSA?
264
Se puede aplicar en procesos demasiados complejos cuando no existe un

modelo de solucin simple o un modelo matemtico preciso
Es til tambin cuando se necesita usar el conocimiento de un experto que
utiliza conceptos ambiguos o imprecisos
Cundo NO ES RECOMENDABLE?
No es recomendable utilizar la lgica difusa cuando algn modelo matemtico
ya soluciona eficientemente el problema, cuando los problemas son lineales o
cuando no tienen solucin
Botn km/hr: Captura la velocidad del carro, e indica con imgenes la

velocidad que lleva el carro. Para hacer esto posible se condicionan las
velocidades.
Botn Metros: captura la distancia de la persona al carro, e indica con una

imagen la distancia respectivamente.
Botn Tiempo en cruzar: Da el tiempo en que tardara en cruzar la persona

con la siguiente formula tie=dis/(vel*1000/3600)
265
Botn Velocidad del Paso: calcula la velocidad con la que la persona debera
de caminar. Se calcula con la siguiente formula: velpaso=Edit3>Text.ToDouble()/tie;
Botn Reset: borra los datos escritos en el formulario y reinicia el programa.
PROGRAMACION PARA LOS BOTONES
Bton metros:
dis=Edit2->Text.ToDouble();
if(dis<=15){
Image2->Picture->LoadFromFile("cerca.bmp");
Label4->Caption="Cercana";
}
if(dis>15&&dis<=50){
Image2->Picture->LoadFromFile("mediocerca.bmp");
Label4->Caption="Medio cerca";
}
Image2->Picture->LoadFromFile("lejos.bmp");
Label4->Caption="Lejana";
}
if(dis>80){
Image2->Picture->LoadFromFile("muylejos.bmp");
Label4->Caption="muy Lejana";
}
l=1;
if(k==1&&l==1){
266
}
Botn Tiempo en Cruzar
tie=dis/(vel*1000/3600);
Label6->Caption=tie;
Label5->Visible=true;
Botn Velocidad del paso

velpaso=Edit3->Text.ToDouble()/tie;
Label9->Caption=velpaso;
if(velpaso<=1){
Label11->Caption="Margarito puede pasar caminando";
}
if(velpaso>1&&velpaso<=2){
Label11->Caption="Margarito puede pasar caminando rapido ";
}
if(velpaso>2&&velpaso<=3.5){
Label11->Caption="Margarito puede pasar trotando ";

}
if(velpaso>3.5&&velpaso<=6){
Label11->Caption="Margarito puede pasar corriendo ";
}
if(velpaso>6){
Label11->Caption="Ni lo intentes Margarito ";
}
267
Timer1->Enabled=true;
Bton Reset
Image3->Left=30;
Image4->Top=10;
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
k=0;
l=0;
Label2->Caption="";
Label4->Caption="";
Label6->Caption="";
Label9->Caption="";
Label5->Visible=false;
Timer1->Tag=0;
DE ESTA FORMA ES COMO SE PROGRAMARIA EN EL LENGUAJE C++.
268
13.
Mtodo de Newton para

ecuaciones no lineales
METODO DE NEWTON PARA ECUACIONES NO LINEALES
Este mtodo nos servir para encontrar la solucin a un sistema no lineal es

decir de exponentes diferentes a 1.
La frmula de recurrencia de este mtodo es la siguiente:
La ecuacin tiene analoga con la ecuacin del mtodo de Newton Raphson

para encontrar races de ecuaciones:
DONDE "J" es el Jacobiano:
Y J^(-1) lo podemos determinar de la siguiente manera:
269
Para encontrar la frmula de recurrencia del sistema propuesto se procede a lo

siguiente:
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 aJ-1
270
271
La programacin quedo de la siguiente manera:

Las variables fueron:
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
double x1, y1, x2, y2, Tol, n, aux=0, c1, c2, dx, dy,i;
TForm2 *Form2;
272
El button de aproximar solucion quedo as:

{
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="";
Edit3->Text="";
273
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();
}
274
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="";
Edit2->SetFocus();
275
}
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();
}
276
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=abs(x2-x1);
dy=abs(y2-y1);
if (dx<Tol && dy<Tol)
{
Label11->Caption="Se encontr un valor menor a la tolerancia.";
aux=1;
}
else
277
{
Label11->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);
}
}
El button paso a paso quedo asi:

{
if (aux<=1)
{
278
Tol=Edit3->Text.ToDouble();
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)
{
ShowMessage("x1 debe ser distinto de cero y la tolerancia mayor que
cero");
Edit1->Text="";
Edit3->Text="";
Edit1->SetFocus();
}
279
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
280
{
x2=(x1/2)+(11/(4*x1));
y2=(y1/2)+(9/(4*y1));
dx=abs(x2-x1);
dy=abs(y2-y1);
if (dx<Tol && dy<Tol)
{
Label11->Caption="Se encontr un valor menor a la tolerancia.";
}
else
{
Label11->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++;
Edit4->Text=AnsiString(i);
}
}
281
El button de reset quedo asi:

{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit1->SetFocus();
aux=0;
282
14.
Resolucin de ecuaciones diferenciales

ordinarias por el Mtodo de Runge-Kutta.
Los mtodos de Runge-Kutta son un conjunto de mtodos genricos iterativos,

explcitos e implcitos, de resolucin numrica de ecuaciones diferenciales.
Este conjunto de mtodos fue inicialmente desarrollado alrededor del ao 1900
por los matemticos C. Runge y M. W. 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
+1 , sino que se evala en la ecuacin de Euler sin mejorar.
( , ) =
( , ) + (+1 , +1 )
2
+1 = + ( , )
( , ) =
( , ) + (+1 , + ( , ) )
2
Euler mejorado
Euler sin
mejorar
Euler modificado
En donde desaparece el trmino +1 , evitando despejar.

1. Poner de la forma:
= (, )
Usar un intervalo equidistante:

= 0 + o bien +1 = +
(, ) = ( , )
2. Aproximar a la pendiente con el promedio y aproximar a la derivada con
su diferencia finita:
+1 ( , ) + (+1 , + ( , ) )
=
2
283
+1 = +
( , ) + (+1 , + ( , ) )
2
Considrese
1 = ( , )
2 = (+1 , + ( , ) ) = (+1 , + 1 )
Podemos simplificar la frmula de recurrencia a

+1 = +
1 + 2
2
Ejemplo:
+ 4 = 2
= 0.1
(0) = 1
Poner en la forma () = (, )
= 2 4
+1 = +
1 + 2
2
1 = ( , )
1 = ( 2 4 )
2 = (+1 , + 1)
2 = ( 2+1 4( + 1))
1 = 0.1 2(0) 4(1) = 0.3

2 = 0.1( 2(0.2) 4(1 0.3))) = 0.21296
1 = 1 +
0.30.21296
2
= 0.74352
284
Programacin
Interfaz grfica propuesta
Descripcin por botn

Botn Calcular:
Lee los valores para , 0 y 0 , dentro de una estructura de repeticin calcula
los valores para 1 , , 10 y 1 , , 10 .
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 1 y 2 . Muestra los
resultados en los Edits correspondientes.
Botn Graficar:
Realiza una grfica de la funcin con los puntos calculados sobre un eje
coordenado.
Botn Reset:
Borra los datos escritos en el formulario y posiciona el puntero en el primer Edit.
285
Cdigo de Programacin
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//----------------------------------------------------------------------------------bariables
#include <math.h>
double Y[100], X[100], h, k1, k2,x=0,y=0,p,q;

int k;
TForm1 *Form1;
: TForm(Owner)
{
}
{
Close();
---------- Button (salir)
}
//--------------------------------------------------------------------------286

{
X[0]=Edit2->Text.ToDouble();
Y[0]=Edit3->Text.ToDouble();
----------- Button( 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);}
Edit4->Text=AnsiString(X[1]);
Edit14->Text=AnsiString(Y[1]);
287
}

{
Canvas->Pen->Color=clBlack;
Canvas->Pen->Width=3;
---------- Button (Graficar)
Canvas->Pen->Color=0x00C08080;
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);
}
}
{
288
x=0;
y=0;
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
------------------Button(reset)
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;
}
//--------------------------------------------------------------------------289
15.
Lgica Difusa
OBJETIVO DEL PROYECTO

Este proyecto se podr identificar las causas e inicio de la lgica difusa, junto
con las diferentes aplicaciones en la vida cotidiana, as mismo para su
compresin se desarrollo un programa relacionado con la aplicacin de la
lgica difusa, con el fin de una mayor compresin y entendimiento del tema.
INTRODUCCIN
Recientemente la cantidad de variables existentes en la vida cotidiana son
muchas por las cuales se prevee la complejidad de la realidad y con ellos surge
desde la incertidumbre y se manifiesta en trminos ambiguos. Por ello se
tratara de exponer algunas cualidad y ventajas que diserne de la lgica clsica
con la lgica difusa donde la prioridad principal no se trat de solo razonar sino
de poder hacer una descripcin completa de cada situacin y disponer de
criterios de una compresin genrica como de clasificacin y de anlisis de
conjuntos de probabilidades de una situacin.
Afortunadamente esta generalidad y ambigedad son suficientes para el
avance de la comprensin humana de sistemas complejos, que con el paso del
tiempo se convierten en el saber. En la medida que el aprendizaje aumenta, la
complejidad decrece y se incrementa la comprensin lo que hace tangible en
conocimiento y la factibilidad de la difusin sobre las situaciones con sus
respectivas posibilidades de soluciones posibles ante un tema.
LGICA DIFUSA EN INGENIERA CIVIL
La lgica difusa fue desarrollada por el profesor de la universidad de california
en Berkeley a principios de los aos 60, surgiendo como una herramienta de
trabajo para el control de sistemas y procesos industriales complejos que se
anteponan para ese entonces como la adversidad que delimitaba el
conocimiento humano.
La lgica difusa es una lgica alternativa de la lgica convencional ya que a
diferencia de esta se pretende la vaguedad e incertidumbre de las cosas en sus
distintas variables posibles, es decir, es la alternativa humana de conocimiento
artificial capaz de imitar el comportamiento humano desde un punto
matemtico como lingstico. Por ejemplo "luego", para el anlisis de
fenmenos rpidos en ingeniera puede ser del orden de nanosegundos, pero
para paleontlogos del orden de miles de aos. Se observa la magnitud del
290
orden que es relativa, por lo tanto si se emplea una unidad difusa, hay que
tener bien claro el contexto donde se est utilizando para as encontrar un
punto de referencia y una unidad de medida. En ocasiones, enunciados difusos
indican unidades relativas y subunidades ms no unidades absolutas.
La aplicacin de la lgica difusa es necesaria para los conjuntos complejos
donde no existe una solucin simple o modelo matemtico a seguir, de igual
manera se podr utilizar aplicar para sistemas que no pueden medir de forma
confiable y que en su paso de ajustar una variable desajusta otra.
Desventajas:
No se aplica para modelos matemticos eficientes de un problema.
Cuando los problemas sean de manera lineal.
Cuando un problema cuenta con un solucin satisfactoria.
Ventajas:
Controla sistemas complejos.
Permite trabajar con informacin no exacta.
Define evaluaciones convencionales.
Permite la utilizacin de conocimientos ambiguos o imprecisos.
Aplicaciones de la lgica difusa en la vida:
Despus del desarrollo de la lgica difusa su aplicacin se expandi a distintos
mbitos de nuestra vida como son los siguientes:
291
Control de sistemas: como el control del trfico de las ciudades, control

de vehculos, control de compuertas en plantas hidroelctricas, en
centrales trmicas, control de lavadoras, control de llegadas de metro,
ascensores, etc.
Prediccin de terremotos y optimizacin de horarios.
Reconocimientos de patrones y visin del ordenador como
reconocimiento de objetos, vibraciones de cmaras, reconocimientos de
manuscritos, etc.
Sistemas de conocimiento o conocimiento como bases de datos entre
otros.
Las lgicas difusas abarcan diferentes tipos de conjuntos de intercambio de
trminos que ayudan al ordenamiento de funciones, como a discernir ideas
para una solucin.
Conjuntos difusos
Los conjuntos difusos se encuentran asociados por un valor lingstico que est
definido por una palabra, adjetivo o tica lingstica. Donde la funcin de
perteneca puede tomar valores del intervalo de 0 y 1, y su transicin de esta
es gradual y no cambia y no cambia de manera instantnea.
{ A = (x, pA(x)) | x P }
Donde pA(x) es la funcin de perteneca de la variable x, y P es el universo en
discurso. Cuando ms cerca este la pertenencia del conjunto A al valor 1,
mayor ser la perteneca de la variable x al conjunto A. por ejemplos:
Controlador Difuso
292
Por otro lado cabe recalcar que la lgica difusa se aplica en sistemas de
control difuso para formular reglas que controlen un sistema, es decir, que
tienen la capacidad de tomar decisiones sobre ciertas acciones que representa
su funcionamiento, para ello se basa de sencillos paso de ordenamiento como
se muestra a continuacin:
Fusificacin
Asigna grados de pertenencia a cada una de las variables de entrada con

relacin de los conjuntos difusos definidos utilizando las funciones de
pertenencia asociadas a los conjuntos difusos.
Base de conocimientos
Contiene el conocimiento asociado con el dominio de la aplicacin y los objetos
de control. Aqu se define las reglas lingsticas que indican como debe actuar
el programa.
Inferencia
Relaciona los conjuntos difusos de entrada y salida que definirn el sistema
para generar reglas mediante el uso de condicionantes.
Defusificacin
Adecua los valores difusos generados en la inferencia que se utilizaran para el
control, en esta parte se utiliza mtodos matemticos muy indispensables como
es; el mtodo del centroide, mtodo del promedio ponderado y mtodo de
membresa del medio del mximo.
CONCLUSIN
293
En relacin con la lgica clsica nos damos cuenta que existen muchas
inferencia entre la lgica difusa que son variables indispensables y de gran
importancia, as mismo denotamos que la lgica difusa son procedimientos
entre ellas no son de intuitivos sino que estn estrechados por variables y
patrones de orden para su funcionamiento. De esta manera se recomienda
hacer uso de este procedimiento cuando tengamos trminos indefinidos de
acciones que den un resultado, o cuando necesitemos condicionantes que
realizar una actividad para el cuidado de otro orden.
NUESTRAS PROGRAMACONES
Como el primer programa que desarrollamos no aplicaba a la ingeniera civil
decidimos hacer otra alternativa, pero debido a la falta de tiempo, esta ya no se
pudo terminar bien sin embargo, es capaz de dar un ejemplo de la aplicacin
de la lgica difusa en ingeniera civil
1. CALCULAR SI UN NADADOR PUEDE PASAR A TIEMPO POR UN RIO

DONDE VIENE NAVEGANDO UN BARCO
1.1. INTERFAZ 1
294
Formulario 1
Paso 1: se insert en el formulario 1, tres componentes image para cambiar
el fondo de la interfaz.
Paso 2: se insertar nueve componentes Label, esto para los datos como el
encabezado, el tema y los integrantes del equipo.

Paso 3: se insert 2 componentes Button.
Se les cambio el nombre a los Button por: Entrar, Salir.
Formulario 2
Paso 4: se cre un nuevo formulario.
Paso 5: se insert en el formulario 2, cinco componentes image
De los cinco componentes image, uno se utiliz para el fondo de la
interfaz, dos para las imgenes del barco y el nadador, y dos para
mostrar los valores de velocidad y distancia del barco.
Las dos imgenes que servirn para los valores de distancia y

velocidad se le cambian la configuracin visible de true a false.
Paso 6: se insert 11 componentes Label y se le asigno un nombre a cada

uno en la propiedad Caption:
295
Label 1: Velocidad del barco
Label 7:
S.
Label 2:
Label 8:
Metros
Label 3: Distancia del barco
Label 9:
Label 4:
Label 10: m/s
Label 5: Ancho del rio
Label 11:
Label 6:
Paso 7: se insertaron 3 componentes Edit, y en la propiedad Text se borr
la palabra Edit
Paso 8: Se insert un componente Shape y se le cambio el color a azul
celeste, este ser nuestro rio por donde navegara nuestro barco.
Paso 9: Se insert 1 componente timer
Paso 10: Se insert 6 componentes Button, y en la propiedad Caption se
les cambio el nombre por:
1) Button 1: Velocidad de paso
2) Button 2: km/h
3) Button 3: metros
4) Button 4: Tiempo en cruzar
5) Button 5: Reiniciar
6) Button 6: Regresar
Paso 11: Escribir las lneas de programacin para cada botn.

Paso 12: Declarar todas las variables que se utilizaron.
Los cdigos de programacin para esta interfaz son los siguientes:
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
296
#include "Unit2.h"
TForm1 *Form1;
//---------------------------------------------------------------------------

: TForm(Owner)
{
}
{
Entrar
Form2->Show();
}
{
Salir
Close();
}
//---------------------------------------------------------------------------
297
Donde las funciones de los Button son nicamente para entrar a la siguiente
interfaz y para cerrar el programa.
1.1. INTERFAZ 2
Acciones por botn para la interfaz 2

Botn km/h
Al ingresar un valor a la velocidad del barco este lo captura y al valor numrico
le da un valor de pertenencia al conjunto al conjunto que se encuentre dicho
valor.
Botn metros
Captura el valor de la velocidad del barco y le da un valor de pertenencia
dentro del conjunto difuso.
Botn tiempo en cruzar
Calcula el tiempo que tarda en llegar el barco al punto donde se encuentra la
persona.
Botn velocidad de paso
Calcula la velocidad con la que de pasar nadando la persona y si le es posible
a este, si le es posible se le asigna un valor lingstico a la velocidad
dependiendo de los valores de pertenencia que tengan los siguientes valores:
despacio, normal y rpido. Para mostrar las animaciones graficas se utiliz un
componente Timer.
298
Cdigo de programacin.
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
double vel,dis, tie, velpaso;
int k, l, y;
TForm2 *Form2;
//---------------------------------------------------------------------------

: TForm(Owner)
{
}
{
vel=Edit1->Text.ToDouble();
if(vel<=30){
Image1->Picture->LoadFromFile("lento.jpg");
Label2->Caption="Lenta";
299
}
if(vel>30&&vel<=60){
Km/h
Image1->Picture->LoadFromFile("medio.jpg");
Label2->Caption="Media";
}
if(vel>60){
Image1->Picture->LoadFromFile("rapido.jpg");
Label2->Caption="Rapida";
}
k=1;
if(k==1&&l==1){
}
}
{
dis=Edit2->Text.ToDouble();
if(dis<=15){
Image2->Picture->LoadFromFile("cerca.jpg");
Label4->Caption="Cercana";
}
300
Image2->Picture->LoadFromFile("medio cerca.jpg");
metros
Label4->Caption="Medio cerca";
}
Image2->Picture->LoadFromFile("lejos.jpg");
Label4->Caption="Lejana";
}
if(dis>80){
Image2->Picture->LoadFromFile("muy lejos.jpg");
Label4->Caption="muy Lejana";
}
l=1;
if(k==1&&l==1){
}
}
{
tie=dis/(vel*1000/3600);
Tiempo en cruzar
301
}
{
velpaso=Edit3->Text.ToDouble()/tie;
Velocidad de paso
Label9->Caption=velpaso;
if(velpaso<=.5){
Label11->Caption="La persona puede pasar nadando muy despacio ";
}
if(velpaso>.5&&velpaso<=1){
Label11->Caption="La persona puede pasar nadando despacio ";
}
if(velpaso>1&&velpaso<=1.5){
Label11->Caption="La persona puede pasar nadando normal ";
}
if(velpaso>1.5&&velpaso<=2){
Label11->Caption="La persona puede pasar rapido ";
}
if(velpaso>2){
Label11->Caption="La persona no puede pasar ";
}
Timer1->Enabled=true;
}
//--------------------------------------------------------------------------302
void __fastcall TForm2::Timer1Timer(TObject *Sender)
{
Timer1->Tag=Timer1->Tag+1;
if(Timer1->Tag>=tie*10)
Componente Timer
{
Timer1->Enabled=false;
}
Image3->Left=50+Timer1->Tag*(770/(10*tie));
if(velpaso>2){
}
else
{
Image4->Top=300+Timer1->Tag*(250/(10*tie));
}
}
{
Image3->Left=50;
Image4->Top=300;
Reiniciar
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
k=0;
303
l=0;
Label2->Caption="";
Label4->Caption="";
Label6->Caption="";
Label9->Caption="";
Timer1->Tag=0;
}
{
Regresar
Close();
}
//---------------------------------------------------------------------------
2. Clculo de corriente del agua en una presa.
304
2.1. INTERFAZ 1
La programacin de esta interfaz est dada por los siguientes Button.

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
TForm1 *Form1;
: TForm(Owner)
{
}
305

{
Entrar
Form2->Show();
}
{
Salir
Close();
}
//---------------------------------------------------------------------------
2.2. Interfaz 2
306
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
#include "Unit3.h"
double vol,anc,pas, tie, cantpaso, alt;
int k, l, y;
TForm2 *Form2;
: TForm(Owner)
{
}
{
307
vol=Edit1->Text.ToDouble();
if(vol<=1000)
{
M3
Label2->Caption="MINIMA";
}
if(vol>1000&&vol<=6000){
Label2->Caption="CONSIDERABLE";
}
if(vol>6000){
Label2->Caption="ABUNDANTE";
}
k=1;
if(k==1&&l==1){
}
}
{
anc=Edit2->Text.ToDouble();
if(anc<=150){
Label4->Caption="PEQUEA";
}
if(anc>150&&anc<=500){
Label4->Caption="MEDIANA";
}
Anchura de la presa.
308
if(anc>500&&anc<=800){
Label4->Caption="GRANDE";
}
if(anc>800){
Label4->Caption="NI EN TUS SUEOS";
}
l=1;
if(k==1&&l==1){
}
}
{
pas=vol/anc*10/3600;
Tiempo de paso
Label6->Caption=AnsiString(pas);
}
{
alt=Edit3->Text.ToDouble();
309
cantpaso=alt/pas;
Label9->Caption=AnsiString(cantpaso);
if(cantpaso<=100){
Label11->Caption="Flujo ptima de paso";
}
Velocidad de paso
if(cantpaso>100&&cantpaso<=200){
Label11->Caption="Flujo controlado ";
}
Label11->Caption=" Flujo moderado ";
}
Label11->Caption="Flujo mximo ";
}
if(cantpaso>600){
Label11->Caption="Flujo excesivo descontrolado ";
}
}
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
k=0;
l=0;
Reset
310
Label2->Caption="";
Label4->Caption="";
Label6->Caption="";
Label9->Caption="";
}
{
Regresar
Close();
}
//----------------------------------------------------------------
311

Manual de Teoria y Codigos de Metodos Numericos C++

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual de Teoria y Codigos de Metodos Numericos C++

Uploaded by

Copyright:

Available Formats

Universidad Autnoma de

Apuntes de Mtodos Numricos

1. Metodo de Biseccion. (Equipo 1).......pag. 2

Integracion numrica por el mtodo de

Solucion de ecuaciones diferenciales por

Logica difusa. (Equipo 13)......pag. 264

Metodo de Newton para ecuaciones

Resolucion de ecuaciones diferenciales

Logica difusa. (Equipo 16)..pag. 290

Si f es una funcin continua sobre el intervalo [a;b] y si f(a).f(b)<0,

Si f(a) y f(c) tienen signos opuestos, entonces hay un cero en

Si f(c) y f(b) tienen signos opuestos, entonces hay un cero en

Si f(c)=0, entonces c es un cero.

[a1;b1] es el intervalo de partida y c1=(a1+b1)/2 es su punto medio.

[a2;b2] es el segundo intervalo y c2=(a2+b2)/2 es su punto medio;

Despus de llegar al intervalo [an;bn], en el que tambin se

Anlisis del error:

la sucesin {an} converge porque es creciente

(b1-a1)/2(n-1) n1. (*)

Si se aplica lmite a esta ltima igualdad se obtiene:

Entonces, resulta que los lmites de ambas sucesiones son iguales:

Tomando el lmite en la desigualdad f(an).f(bn) 0, encontramos que

El error en el paso n es:

habr reducido 2n veces. Por lo anterior, si el intervalo original es de tamao M

No obstante, una de las grandes desventajas que presenta este mtodo

Que para todo n suficientemente grande. Tal K recibe el nombre de factor de

Aproximacin inicial y criterios de convergencia

Es imprescindible establecer un criterio de parada para que el algoritmo

Otro criterio de parada involucra las abscisas. Se trata de determinar si la

A continuacin mostramos la interfaz del programa, para luego la programacin

Presionamos el botn de entrada i directamente nos manda a la siguiente

A continuacin un ejemplo del interfaz del programa con un polinomio

Despus de haber realizado varias iteraciones llegamos a la raz aproximada

Y para estar seguros de que es una raz del polinomio se muestra en la

A continuacin la programacin de la interfaz del mtodo de Biseccin.

//--------------------------------------------------------------------------__fastcall TForm2::TForm2(TComponent* Owner)

void __fastcall TForm2::Button1Click(TObject *Sender)

void __fastcall TForm2::Button2Click(TObject *Sender)

//--------------------------------------------------------------------------void __fastcall TForm2::Button3Click(TObject *Sender)

void __fastcall TForm3::Button1Click(TObject *Sender)

2. Mtodo de Newton - Raphson

Para esto se toma la recta tangente a la funcin en un punto prximo a la

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

Conocida como la frmula de Newton Raphson.

La frmula vuelve a realizar el mismo

Como se observa en la grfica, se va

Cuando son races mltiples, las del polinomio.

Cuando se encuentran un punto crtico o de inflexin, debido a al valor

Si observamos la grfica, se puede

ERROR RELATIVO ENTRE DOS APROXIMACIONES SUCESIVAS.

Cuando un punto de inflexin, (xn) = 0, ocurre en la cercana de una

PROGRAMACIN DEL MTODO.

Acciones por botn.

Permite accesar al programa principal donde se construy el mtodo y a una

Permite salir y cerrar el programa.

Botn CALCULAR RAZ.

Lee los valores de x4, x3,

valor inicial propuesto para

nmero de iteraciones que

funcin (xn) segn

en caso de que no sea as y (xn) 0 el proceso continua y calcula la

Sumando 1 en el contador de iteraciones, dato que se imprime en el Memo 1

ubicado en el Form3. Cuando los datos se vuelven a repetir es seal de que el