Manual de Teoria y Codigos de Metodos Numericos 2° A PDF

Universidad Autónoma de
Chiapas
Facultad de Ingeniería
Ingeniería Civil
Programación
Apuntes de Métodos Numéricos
Por Alumnos de 2° “A”
Por Alumnos de 2° “A”

ÍNDICE
1. Metodo de Biseccion. (Equipo 1)……………………….…......pag. 2
2. Método de Newton – Raphson. (Equipo 2)……………..……pag. 17
3. Metodo de Ferrari: Solucion de ecuaciones

de cuarto grado. (Equipo 3)…………….………………….......pag. 41
4. Metodo de Müller. (Equipo 4)…………….……………….…...pag. 57
5. Solucion de ecuaciones lineales por el método

de eliminación de Gauss. (Equipo 5)……..…………….….…pag. 79
6. Inversion de matrices por el método de

descomposición de L.U. (Equipo 6)……………….……...…..pag. 156
7. Interpolacion polinomial por el método de

diferencias divididas. (Equipo 7)………………………………pag. 180
8. Primer derivada por métodos numéricos. (Equipo 9)...……..pag. 196
9. Segunda derivada numérica. (Equipo 10)…………………....pag. 205
10. Integracion numérica por el método de

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

el método 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 método de
Runge-Kutta. (Equipo15)…………………………….......pag. 283
15. Logica difusa. (Equipo 16)………………………………..pag. 290

1
1. Método de Bisección
Si f es una función 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 función 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 método de bisección explota esta idea ya que los extremos del
intervalo se van a ir acercando sistemáticamente hasta obtener un intervalo de
longitud suficientemente pequeña en el que se localiza un cero. El proceso de
decisión 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
[a;c].
 Si f(c) y f(b) tienen signos opuestos, entonces hay un cero en
[c;b].
 Si f(c)=0, entonces c es un cero.
Si ocurre la primera opción, o bien la segunda, entonces se ha encontrado
un intervalo de mitad de ancho que el original que contiene una raíz. Para
continuar el proceso, se renombra el nuevo intervalo más pequeño como [a;b] y
se repite el proceso hasta que el intervalo sea tan pequeño como se desee.
Puesto que el proceso de bisección genera una sucesión de intervalos
encajados, con sus correspondientes puntos medios, se usará la siguiente
notación 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].

Después de llegar al intervalo [an;bn], en el que también 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 también se localiza un cero, y
que mide la mitad que [an;bn]
Análisis del error:

Con el objeto de analizar el método de la bisección, 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 números:
 a1≤a2≤...≤an≤b1
la sucesión {an} converge porque es creciente
y está acotada superiormente.
 b1≥b2≥...≥bn≥a1 la sucesión {bn} converge porque es
decreciente y está acotada inferiormente.
2
 bn+1-an+1 = (bn-an)/2, n≥1 n-an)= (b1-a1)/2(n-1) n≥1. (*)
Si se aplica límite a esta última igualdad se obtiene:
Entonces, resulta que los límites de ambas sucesiones son iguales:
Tomando el límite 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 raíz se encontrará en ese intervalo. En este paso, la
mejor aproximación será el punto medio del intervalo,
El error en el paso n es:
(1) Dado que r (la raíz 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 método es que siempre converge para

funciones continuas f(x). Además, proporciona el tamaño exacto del intervalo
en cada iteración (en ausencia de errores de redondeo). Para aclarar esto, se
puede observar que en este método después de cada iteración el tamaño del
intervalo se reduce a la mitad; después de n iteraciones, el intervalo original se
3
habrá reducido 2n veces. Por lo anterior, si el intervalo original es de tamaño M
y el criterio de convergencia aplicado al valor absoluto de la diferencia de dos
aproximaciones sucesivas es ε, se puede saber de antemano el número de
iteraciones que se requieren:
No obstante, una de las grandes desventajas que presenta este método

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 método de la bisección es un método lineal
debido a que el error en la iteración siguiente es la mitad del error de la
iteración previa solamente.
Aproximación inicial y criterios de convergencia
El método de la bisección depende de la determinación 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 raíz con la precisión deseada. Por esta razón, se dice que este
método es globalmente convergente.
Sin embargo, si f(x)=0 tiene varias raíces en [a;b], entonces se debe
encontrar un intervalo de partida distinto para hallar cada raíz y no suele ser
fácil hallar estos intervalos más pequeños en los que el signo de f(x) cambia.
En la sección Conceptos básicos se encuentran otros métodos que
requieren, como garantía de su convergencia, que el punto inicial esté cerca de
la raíz buscada, por lo que se dice que son localmente convergentes. Estos
métodos suelen converger más rápidamente que los métodos globales, de
manera que existen algoritmos híbridos que empiezan con un método de
convergencia global y, cuando las aproximaciones obtenidas en las distintas
iteraciones se hallan cerca de la raíz, cambian a un método de convergencia
local.
Comprobación de la convergencia
4
Es imprescindible establecer un criterio de parada para que el algoritmo
detenga las iteraciones cuando haya obtenido una aproximación
suficientemente precisa
Como el objetivo es resolver f(x)=0, el valor xn debería 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

sucesión {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.
5
A continuación mostramos la interfaz del programa, para luego la programación
en builder C++, para poder encontrar lo raíz de una función f(x) cualquiera.
Presionamos el botón de entrada i directamente nos manda a la siguiente

interfaz.
A continuación un ejemplo del interfaz del programa con un polinomio

(x^4+3x^3 – 2 = 0).
6
Después de haber realizado varias iteraciones llegamos a la raíz aproximada
como se muestra en la interfaz.
Y para estar seguros de que es una raíz del polinomio se muestra en la

siguiente grafica que efectivamente existe una aproximación a la raíz obtenida.
7
Esta programación nos ayudara a encontrar una sola raíz 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 después de
unas cuantas iteraciones nos dice la raíz. En caso de que este método no
funcione hay muchos tipos de métodos para encontrar una raíz de un
polinomio.
A continuación la programación de la interfaz del método de Bisección.
Códigos de programación:
8
//---------------------------------------------------------------------------
#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
//---------------------------------------------------------------------------
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,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++){
Form3->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));
//---------------------------------------------------------------------------
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
Còdigo de programaciòn:
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit3.h"
//---------------------------------------------------------------------------
TForm3 *Form3;
//---------------------------------------------------------------------------
: TForm(Owner)
//---------------------------------------------------------------------------
Close();
//---------------------------------------------------------------------------
16
2. Método de Newton - Raphson
El método de Newton (también llamado

Método de Newton- Raphson o de Newton-
Fourier). Es un método gráfico y analítico de
optimización iterativo, el cual permite encontrar las raíces de una función 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 función en un punto próximo a la

solución y se calcula el punto de corte de esa tangente con el eje de las X.
Este método se basa en la interpretación geométrica de la derivada para

obtener la fórmula de la recurrencia, para hacer las iteraciones.
Partiendo de una función ƒ (xn), cuya derivada es ƒ´(xn) y recordando que:
ƒ´ (xn) = m, y m = tan ϴ = Cateto opuesto / Cateto adyacente
Por lo consiguiente, la fórmula de la derivada se expresa de la siguiente forma:
Despejando Xn+1 en la ecuación obtenemos:
17
Conocida como la fórmula de Newton Raphson.
Geométricamente, este método trabaja mediante un valor de arranque, que

evalúa 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 más cerca de la raíz, y
este nuevo nos dará un nuevo valor que está mucho más próximo que el
anterior, y así sucesivamente hasta acercarse a la raíz real de la función ƒ (xn).
La fórmula vuelve a realizar el mismo

proceso, el cual brinda un nuevo valor,
más cercano a la raíz, por eso se llama
de recurrencia o proceso iterativo.
Como se observa en la gráfica, se va

formando como una especie de zigzag,
donde se nota que los nuevos puntos son
más aproximados la raíz de la función.
CASOS ESPECIALES.
o Cuando son raíces múltiples, las del polinomio.
o Cuando la derivada de la función es muy complicada de resolver.
o Cuando existe divergencia en el método.
18
o Cuando se encuentran un punto crítico o de inflexión, debido a al valor
inicial X, donde se tendría una división por cero, o debido a la naturaleza
de la función.
Si observamos la gráfica, se puede

notar los diferentes puntos de
inflexión de la función, lo cual hace
divergir el método.
ERROR RELATIVO ENTRE DOS APROXIMACIONES SUCESIVAS.
Con lo cual se toma el error relativo como si la última aproximación 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 y
velocidad al encontrar la
raíz
 No trabaja en
intervalos, sino en
iteraciones.
 Su indicador de efectividad es la repetición de cifras (convergencia).
DESVENTAJAS.
 Lenta convergencia debida a la naturaleza de una función en particular.
19
 Cuando un punto de inflexión, ƒ (xn) = 0, ocurre en la cercanía de una
raíz.
 No existe un criterio general de convergencia.
 Tener un valor suficientemente cercano a la raíz.
 Apoyarse de herramientas gráficas.
 Conocimiento del problema físico.
 Evaluación de la derivada.
PROGRAMACIÓN DEL MÉTODO.
Interfaz propuesta.
Acciones por botón.
Interfaz 1:
 Botón “ENTRAR”.
Permite accesar al programa principal donde se construyó el método y a una

lista de recomendaciones.
 Botón “SALIR”.
Permite salir y cerrar el programa.
Interfaz 2:
 Botón “CALCULAR RAÍZ”.
20
Lee los valores de x4, x3, x2, x y la constante, el
valor inicial propuesto para nuestra raíz y el
número de iteraciones que realizara el programa.
Calcula la derivada de la función ƒ (xn) según
los valores propuestos en las primeras casillas, dentro de una estructura “for”,
evalúa 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 función diverge (debido a
diversos puntos de inflexión de ƒ (xn)) y no es posible implementar el método,
en caso de que no sea así y ƒ´ (xn) ≠ 0 el proceso continua y calcula la
ecuación 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 señal de que el
método converge, entonces imprime el valor o raíz (dato capturado en el
“Memo2”) que hace o aproxima a cero a ƒ (xn), considerando el porcentaje de
error (tabulado en el “Memo7).
El botón, también cumple la función de activar el botón “MOSTRAR

TABULACIÓN” y al RadioGroup “GRÁFICA”.
 Botón “MOSTRAR TABULACIÓN”.
 Este botón actúa como vinculo al Form3, donde se tabulan los siguientes
datos; número de iteraciones, valor propuesto y los valores obtenidos
por la ecuación, la función origina evaluada, la función derivada
evaluada, el resultado del método evaluado con los 3 datos anteriores a
este, y en el último memo, el porcentaje de error por iteración.
 RadioGroup.
 Radio Button 1 “GRAFICA NORMAL”
 Muestra la gráfica del polinomio, según la función, en modo estándar
 Radio Button 2 “GRAFICA ZOOM”
 Muestra la gráfica de la función en un 200% de acercamiento, respecto a
la grafica normal.
21
 Radio Button 3 “GRAFICA MEGA ZOOM”
Muestra la gráfica en un 300% de acercamiento, respecto a la gráfica normal.

 Botón “REINICIAR”.
 Borra todos los datos y procesos guardados en el programa, y desactiva
los botones “MOSTRAR TABULACIÓN” y al grupo “GRÁFICA”,
elementos que se activaran nuevamente al introducir datos y oprimir el
botón “CALCULAR RAÏZ”.
 Botón “YA TENEMOS 10”
Cierra la interfaz 2, sin guardar ningún dato, para asi poder a ingresar
nuevamente a él, mediante la interfaz 1.
ALGORITMO.
Algoritmo básico, del comportamiento del programa:
1. Introducir la ecuación al resolver f(x).

2. Introducir la derivada de la función a resolver f’(x).
3. Introducir el máximo número de iteraciones Nmax.
4. Introducir el valor máximo del error porcentual a aproximado Tmax.
5. Seleccionar una aproximación inicial cerca de la raíz Xi.
6. Inicializar el contador i=1.
7. Mientras que i<= Nmax continuar los pasos.
8. Calcular la aproximación a la raíz mediante la ecuación predictiva de
Newton – Raphson.
9. Calcular el error porcentual aproximado.
10. Verificar que se cumpla la condición |ep|<=Tmax. Si se cumple,
entonces sea encontrado la aproximación final, si no ir al siguiente paso.
11. Hacer i=i+1.
12. Verificar si se cumple la condición i<=Nmax. Si después de Nmax

iteraciones no se ha cumplido que |ep|<=Tmax, el método ha fracasado.
Terminar la ejecución del logaritmo.
22
13. Imprimir los resultados.
CÓDIGO DE PROGRAMACIÓN.
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)
//Vinculación del interfaz 1 a la 2
Form2->Show();
//---------------------------------------------------------------------------
//Botón 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 matemático
#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;
//---------------------------------------------------------------------------
: TForm(Owner)
//---------------------------------------------------------------------------
//Botón que cierra el interfaz 2
Close();
25
//---------------------------------------------------------------------------
// 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();
//---------------------------------------------------------------------------
26
//Habilitar Graficas y Tabla de Iteraciones
RadioGroup1->Enabled=true;
//Leer los datos
xn=Edit6->Text.ToDouble();
it=Edit7->Text.ToDouble();
//Derivada de la función
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 gráfica y Tabla de Iteraciones.
RadioGroup1->Enabled=true;
//Iniciando el número 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 función 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 impresión de la raíz
if(dfx==0){
Form7->Show();
else{
// Calculando xn
Form3->Memo2->Lines->Add(xn);//Enviando xn al Memo2
//Calculando la división
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;
//---------------------------------------------------------------------------
30
{
//Mostrando tabulación
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++)
20*(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,350-
+d*x/40+e));
for(x=-650;x<=650;x++)
+d*x/40+e));
//---------------------------------------------------------------------------
UNIT 3.
//---------------------------------------------------------------------------
35
#include <vcl.h>
#pragma hdrstop
#include "Unit3.h"
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
: TForm(Owner)
//---------------------------------------------------------------------------
//Botón cerrar
Close();
//--------------------------------------------------------------------------
UNIT 4.
//---------------------------------------------------------------------------
#include <vcl.h>
36
#pragma hdrstop
#include "Unit4.h"
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
: TForm(Owner)
//---------------------------------------------------------------------------
//Botón cerrar
Close();
//---------------------------------------------------------------------------
UNIT 5.
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit5.h"
//---------------------------------------------------------------------------
37
//---------------------------------------------------------------------------
: TForm(Owner)
//---------------------------------------------------------------------------
//Botón cerrar
Close();
//---------------------------------------------------------------------------
UNIT 6.
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit6.h"
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
38
: TForm(Owner)
//---------------------------------------------------------------------------
//Botón 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)
//---------------------------------------------------------------------------
//Botón cerrar
Close();
//---------------------------------------------------------------------------
De esta manera es como se programa el Método de Newton – Raphson en

leguaje C++.
40
3. Método de Ferrari: Solución de
ecuaciones de cuarto grado.
Una ecuación de cuarto grado o ecuación cuartica con una incógnita es una
ecuación algebraica que se puede poner bajo la forma canónica: donde a, b, c,
d y e (siendo) son números que pertenecen a un cuerpo, usualmente a los
reales o los complejos. Sea K un cuerpo, donde se pueden extraer raíces
cuadradas y cúbicas (y por lo tanto también de cuarto orden, pues equivale a
extraer raíces cuadradas dos veces seguidas). En este cuerpo, es posible
factorizar por todo a, y la identidad siguiente es válida:
En un cuerpo algebraicamente cerrado, se sabe que todo polinomio de grado 4

tiene cuatro raíces. Es el caso del cuerpo de los complejos, según el Teorema
Fundamental del Álgebra. El método siguiente permite obtener las cuatro raíces
al mismo tiempo. Este método es llamado "método de Descartes", pues fue
dado por el matemático francés René Descartes (1596-1650) en el año de
1637 en su célebre libro "La Geometría". Aunque existan diferentes métodos
para resolver las ecuaciones cuarticas, algunos son: método de Ferrari, método
de Descartes, método de Euler, método de Lagrange, método de Alcalá,
etcétera.
41
Resolución algebraica de la ecuación general de cuarto grado:
Ax⁴ + Bx³ + Cx² + Dx + E=0
1. SOLUCIÓN ALGEBRAICA
Tenemos una ecuación 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
También podemos escribir la ecuación de esta forma:
x⁴ + ax³ + bx² + cx+d=0
El método de Ferrari nos proporciona una RESOLVENTE.
2. RESOLVENTE DE FERRARI
y³ -by² + (ac-4ad)y +(4bd-a²d-c² )=0
Podemos cambiar la ecuación por la siguiente forma:
x³ +a₁x² +a₂ x+ a₃=0
3. CUBICA DE FERRARI
En donde los valores tomados de a, b, c y d; son de la ecuación de cuarto

grado
x⁴ + ax³ + bx² + cx+d=0
4. Ya obtenida la cúbica...
Para obtener las raíces de la ecuación de cuarto grado. Usaremos el método

de Cardano que consiste en calcular:
42
De la ecuación anterior: x³ +a₁x² +a₂x+a₃=0
5. DONDE:
a₁= (-b)
a₂=(ac-4d)
a₃=4bd-a²d-c²
6. RESOLVER LAS SIGUIENTES OPERACIONES
T=√R-√Q³-R²
Q=3a₂-a₁²/9
R=9a₁a₂-27a₃-2a₁³
S=√R+√Q³-R²
7. Obtenemos una raíz real a partir de esta fórmula de Cardano.
X₁=S+T-(1/3)a₁
Con esta raíz regresamos al método de Ferrari.
8. Ya obtenida una raiz real, partimos de las siguientes fórmulas:
e=√(a²/4)-b+y
• Si e≠0 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 cuadráticas.
x²+(a/2-e)x+(y/2)-f)
x²+(a/2+e)x+(y/2+f)
10. Con estas dos ecuaciones cuadráticas podemos utilizar sencillamente

la fórmula general.
x=-b/2a(-b^2-4ac)^1/2
En donde nos dará dos raíces reales, y dos raíces imaginarias
PROGRAMA:
44
Acciones por Botón
Formulario 1:
 Botón “Entrar”:
El botón te manda a un segundo formulario donde podrás calcular las raíces de

un polinomio de cuarto grado.
 Botón “Salir”:
El botón cierra por completo el programa.
Línea de Programación:
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
: TForm(Owner) { }
//---------------------------------------------------------------------------
Form2->Show();
//---------------------------------------------------------------------------
Close();
45
//---------------------------------------------------------------------------
Acciones por Botón
 Botón “Raíces”:
El botón lee los datos que ingresamos y realiza una serie de pasos para que
nos encuentre las raíces del polinomio que estamos buscando y nos ponga los
resultados en los componentes Edit que programamos anteriormente.
 Botón “Regresar”:
El botón nos regresará al menú principal, usualmente lo utilizaremos para salir

del programa.
46
Línea de Programación:
//---------------------------------------------------------------------------
#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 ecuación cúbica!!";
//---------------------------------------------------------------------------
Close();
//---------------------------------------------------------------------------
56
4. Método de Müller
Este es un método para encontrar las raíces de ecuaciones polinomiales

con raíces múltiples, 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 ecuación de orden n, hay n raíces reales o complejas. Se debe notar
que esas raíces no son necesariamente distintas.
 Si n es impar, hay al menos una raíz real.
 Si las raíces complejas existen, existe un par conjugado.
Un predecesor del método de Meller, es el método de la secante o

método de Newton Raphson, el cual obtiene raíces, estimando una proyección
de una línea recta en el eje x, a través de dos valores de la función (Figura 1).
El método de Müller toma un punto de vista similar, pero requiere de tres
puntos para calcular la parábola, en otras palabras, proyecta una parábola a
través de tres puntos (Figura 2).
El método consiste en obtener los coeficientes de la parábola que pasa

por tres puntos elegidos, dichos coeficientes son sustituidos en la fórmula
cuadrática para obtener el valor o punto donde la parábola intercepta el eje x,
es decir, la raíz estimada. La aproximación se puede facilitar, si se escribe la
ecuación de la parábola en una forma conveniente .En forma conveniente esta
sería:
f 2 ( x)  a( x  x2 ) 2  b( x  x2 )  c Ec.1
 Una de las mayores ventajas de este método, es que al trabajar con la

fórmula cuadrática es posible localizar tanto raíces reales como raíces
complejas.
57
FIG 1 FIG. 2
 ¿QUÉ SON LAS RAICES DE UN POLINOMIO?
La raíz de un polinomio es un número tal que hace que el polinomio

valga cero. Es decir, que cuando resolvamos un polinomio a cero, las
soluciones son las raíces 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 Solución 1
x=3 Solución 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 raíces del polinomio f(x)= x2+ x –
12
58
¡NOTA!
El Teorema fundamental del Álgebra nos dice que: El número de factores en

que se puede descomponer un polinomio es igual al grado del polinomio, es
decir: Todo polinomio de grado n tiene n raíces.
.Por tanto, en nuestra programación, únicamente podremos encontrar

raíces de un polinomio hasta grado 4, esto quiere decir que el número de
raíces encontradas será equivalente al número de grado del polinomio que
estemos evaluando.
 REPRESENTACION GRÁFICA DE LAS RAICES DE UN POLINOMIO
 RAICES REALES
Como las raíces de un polinomio hacen que este valga cero, en unplano
cartesiano esto lo identificamos como las intersecciones de la gráfica del
polinomio con el eje de las X (abscisas). Esto es, los puntos en donde cruza la
gráfica al eje horizontal tienen como abscisa la raíz del polinomio graficado.
A continuación presentamos algunas funciones con sus raíces, factores y

gráficas:
Función Raíces Factorización Gráfica
f(x)= -4y3 f(x) = (x +

x2 + x 4) (x - 3)
- 12
f(x)= - 1, 2 y f(x) = (x +
x3 - 4 3 1) (x - 2) (x
- 3)
x2 + x
+6
59
f(x)= - 2, - 1, f(x) = (x +
x4 - 5 1 y 2 1) (x + 2) (x
- 1) (x - 2)
x2 + 4
f(x)= ¿Cuáles f(x) =

x3 + 4 son?
x2 + 3
x
Consideremos ahora otro caso en particular, expresando una función mediante

el cociente de polinomios
 Ejemplo:
Si la función con la que se trabaja es un cociente de polinomios, estos

deberán ser reducidos a la mínima expresión con el objetivo de simplificar su
manejo. Dicha simplificación se lleva a cabo eliminando factores comunes, y la
tarea de encontrar dichos factores está estrechamente ligada al cálculo de las
raíces de los polinomios que aparecen en el numerador y el denominador.
Consideremos la función:
Esta función tiene una singularidad removible en x=-2. Si eliminamos el factor

(x+2) en el numerador y el denominador, obtenemos la función
60
La cual coincide con f(x) excepto en x=-2. Las raíces involucradas en esta
función son:
 Raíces de p(x) = 0, 3,
 Raíces 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 raíces, organizadas en orden creciente (-
1,0,1,3), indican los intervalos de estudio que deben considerarse para la
función.
Observe la Figura 3.Las raíces de p(x) señalan los puntos en que f intercepta
el eje de las x mientras que las raíces de q(x) indican asíntotas de la función.
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
𝑞(𝑥)
RAÍCES DE LA FUNCIÓN, MIENTRAS QUE LOS VALORES QUE ANULAN A
Q(X) INDICARÁN LAS ASÍNTOTAS DE DICHA FUNCIÓN, MAS NO SUS
RAÍCES TAMBIÉN.
 RAICES IMAGINARIAS
61
y = xxx-4xx+5x y
 y = xxx-4xx+5x y





 Las raíces de la

función son:


X= 0, x=2+i, x=2-i





 x
x
     
     


y = x^(3)+x y


 

  y = x^(3)+x
 

 
 

Las raíces de la 

función son: 


X= 0, x=i, x=-i  x
     



 ¿CÓMO CALCULAR LA PARÁBOLA?
1. Para esto necesitaremos de tres puntos

FORMULAS
a utilizar
𝒙𝟎 , 𝒇(𝒙𝟎 ) , 𝒙𝟏 , 𝒇(𝒙𝟏 ) 𝒚 𝒙𝟐 , 𝒇(𝒙𝟐 ) .
ℎ0 = 𝑥1 −
 𝑥0 𝑥0
 𝑥1 ℎ1 = 𝑥2 −
 𝑥2 𝑥1
𝑑0 =
2. La aproximación la podemos escribir como: 𝑓(𝑥1 )−𝑓(𝑥0 )
f 2 ( x)  a( x  x2 )  b( x  x2 )  c
2
𝑥1 −𝑥0
𝑑1 =
3. Los coeficientes de la ecuación 1, es decir, de la 𝑓(𝑥2 )−𝑓(𝑥1 )
parábola los calculamos resolviendo el siguiente sistema 𝑥2 −𝑥1
de ecuaciones. 𝑑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 ) + 𝑐 Ec. 4

 La ecuación 4 genera que, 𝒇𝟐 (𝒙𝟐 ) = 𝒄
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. Encontrar𝑑0 𝑦 𝑑1 dadas las formulas. Obtendremos:
𝑑0 =?
𝑑1 =?
7. Ahora se encontrará a 𝒂 , 𝒃 𝒚 𝒄(coeficientes de la parábola).
a) Para encontrar a 𝒂se deberá resolver la fórmula correspondiente. Se

tendrá:
𝒂 =?
b) Para encontrar a 𝒃se deberá resolver la fórmula correspondiente. Se

obtendrá:
𝒃 =?
c) Para encontrar a 𝒄 se deberá resolver la evaluación correspondiente, el

cual𝒄esúnicamente𝒇𝟐 (𝒙𝟐 ) = 𝒄.
8. Habiendo encontrado 𝒂 , 𝒃 𝒚 𝒄se resuelve la siguiente fórmula:
63
−2𝑐 −2𝑐
𝑥3 − 𝑥2 = -Despejando- 𝑥3 = 𝑥2 +
𝑏± 𝑏 2 −4𝑎𝑐 𝑏± 𝑏 2 −4𝑎𝑐
 En el denominador se escoge el signo que coincida con el signo de “b”,

esta elección proporciona como resultado el denominador más grande, lo
que dará la raíz estimada más cercana a x3.
Es decir, si 𝑏 + 𝑏 2 − 4𝑎𝑐 > 𝑏 − 𝑏 2 − 4𝑎𝑐
Se escoge 𝑏 + 𝑏 4 − 4𝑎𝑐
Si no, se escoge: 𝑏 − 𝑏 2 − 4𝑎𝑐
9. Se prosigue a calcular el error, este será:
𝑥3 −𝑥2
𝐸𝑎 = . 100 %[Fórmula para calcular el margen de error]
𝑥3
10. Si pretendemos iterar, es decir, una vez que se determinó x3 el proceso se

repetirá, esto con el fin de tener una mayor aproximación a la raíz X3, por lo
cual esto traerá de que un valor es descartado.
 Al ser un método de aproximación, 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 MÜLLER
VENTAJA
 Por medio de este método se encuentran tanto raíces reales como

complejas.
DESVENTAJA
 En el método de Müller se escoge el signo que coincida con el
signo de “b”, esta elección proporciona como resultado el
denominador más grande, lo que dará la raíz estimada más cercana a
x2. Una vez que se determinó x3 el proceso se repite, esto trae de que
un valor es descartado.
 ESTRATEGIAS COMÚNMENTE USADAS
64
 Si sólo se localizan raíces reales, elegimos los dos valores originales
más cercanos a la nueva raíz.
 Si tenemos raíces reales y complejas, se usa un método secuencial.
Ej. X1, X2, X3=X0, X1, X2
 DATO ADICIONAL

 Si además deseamos conocer los puntos en los que f (x) posee máximos y
mínimos locales, el procedimiento consiste en encontrar las raíces de f´(X).
 Si queremos ubicar los puntos de inflexión de la función, es necesario ahora

encontrar las raíces de f´´(x).
EJEMPLOS: Obtén las raíces de los polinomios mediante el método de Müller.
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
𝑑0 = = 𝟔𝟐. 𝟐𝟓
1
48 − 82.875
𝑑1 = = 𝟔𝟗. 𝟕𝟓
−1
2
69.75−62.25
𝑎= 1 = 𝟏𝟓
2
1 Coeficientes de la parábola
𝑏 = 15 − + 69.75 = 𝟔𝟐. 𝟐𝟓
2
𝑐 = 𝟒𝟖
65
 Puesto que b es positivo, entonces, respecto al signo ± ubicado en el
denominador, elegiré + :
−2(48)
∴ 𝑥3 = 5 +
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

raíces, entonces puedo dividir a mi ecuación polinomial 𝑥 3 − 13𝑥 − 12 entre x
= X3, es decir 𝑥 − 4, con el fin de obtener una ecuación de orden dos,
equivalente a mi primer polinomio de orden tres, evidentemente, encontrar las
raíces de un polinomio grado dos es prácticamente sencillo.
Efectuando división sintética
1 0 − 13 − 12 | 𝑀𝑖 𝑝𝑜𝑙𝑖𝑛𝑜𝑚𝑖𝑜 𝑒𝑞𝑢𝑖𝑣𝑎𝑙𝑒𝑛𝑡𝑒 𝑠𝑒𝑟á:

4 16 12 | 4 𝑥 2 + 4𝑥 + 3
________________________|________
1 4 3 0 |
66
Obteniendo raíces de 𝑥 2 + 4𝑥 + 3 :
FORMULA
−4 ± 42 − 4(1)(3)
𝑋1,2 =
2(1) −𝑏 ± 𝑏 2 − 4𝑎𝑐
𝑋1,2 =
𝑋1 = −1, 𝑋2 = −3 𝑅𝑎𝑖𝑐𝑒𝑠 2𝑎
Ilustración 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 función 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 función 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; /*--------------R4--------------*/
if(D<0)
{x1=(-b)/(2*a);
l=pow(-l*D,0.5)/(2*a);
Edit14->Text=AnsiString(l);}
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; /*--------------DEGRADAR CON R2--------------*/
q=p*R2;
r=c+q;
s=r*R2;
u=d+s;
Edit2->Text="0";
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;
//---------------------------------------------------------------------------
: 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. Solución de Ecuaciones Lineales por el
método de eliminación 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 general de tres ecuaciones lineales en cuatro
incógnitas se escribe así:
a11x1 + a12x2 + a13x3 + a14x=b1
a21x1 + a22x2 + a23x3 +a24x4=b2
a31x1 + a32x2 + a33x3+a34x4=b3
Un sistema de m ecuaciones lineales en n incógnitas se puede abreviar

escribiendo únicamente el arreglo rectangular de números:
a11 a12…………a1n b1
a21 a22………… a2 b2
. . . .
. . . .
am1 am2………… amnbm
Esto se conoce como matriz aumentada del sistema. (El término matriz se
emplea en matemáticas para denotar un arreglo rectangular de números. Las
matrices aparecen en varios contextos).
Como ejemplo la matriz aumentada del siguiente sistema de ecuaciones es:
El método básico para resolver un sistema de ecuaciones lineales consiste en

reemplazar el sistema dado por un nuevo sistema que tenga el mismo conjunto
solución, pero que sea más fácil 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 ecuación (o renglón) por una constante diferente de cero.
2. Intercambiar dos ecuaciones (renglones).
79
3. Sumar un múltiplo de una ecuación (renglón) a otra. Dado que los
renglones (líneas 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
SOLUCIÓN DE SISTEMA DE ECUACIONES LINEALES POR EL MÉTODO
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.
PROGRAMACIÓN
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
82
TForm1 *Form1;
//---------------------------------------------------------------------------
: TForm(Owner)
//---------------------------------------------------------------------------
Form2->Show();
//---------------------------------------------------------------------------
Close();
//---------------------------------------------------------------------------
83
MENÚ DE SELECCIÓN DE NÚMERO DE INCOGNITAS DEL SISTEMA DE
ECUACIONES
Compuesto de: 1-Label 5-Button 1-Picture
Buttons:
1) 2 Incógnitas: Abre una nueva ventana para resolver sistemas de 2
incógnitas en específico.
5) Salir: Cierra la ventana del Menú de selección.
PROGRAMACIÓN
//---------------------------------------------------------------------------
#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 INCÓGNITAS
Se compone de: 36-Label 3-Button 6-Edit 1-Picture
Buttons:
1) Solución: Inicia el proceso de solución del sistema de ecuaciones
lineales.
2) Borrar todo: Borra el proceso de triangulación y la solución del sistema
así como la información en los Edit.
3) Salir: Cierra la Interfaz de 2 Incógnitas.
PROGRAMACIÓN
//---------------------------------------------------------------------------
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();
//---------------------------------------------------------------------------
Se compone de: 63-Label 3-Button 12-Edit 1-Picture
Buttons:
lineales.
PROGRAMACIÓN
//---------------------------------------------------------------------------
#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
//---------------------------------------------------------------------------
Compuesto de: 117-Label 3-Button 20-Edit 1-Picture
Buttons:
102
lineales.
PROGRAMACIÓN
//---------------------------------------------------------------------------
#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();
//---------------------------------------------------------------------------
121
Compuesto de: 198-Label 3-Button 30-Edit 1-Picture
Buttons:
lineales.
PROGRAMACIÓN
//---------------------------------------------------------------------------
#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. Inversión de Matrices por el método de
descomposición de L. U.
Su nombre se deriva de las palabras inglesas "Lower" y "Upper", que

en español se traducen como "Inferior" y "Superior". Estudiando el proceso que
se sigue en la descomposición LU es posible comprender el por qué de este
nombre, analizando cómo una matriz original se descompone en dos matrices
triangulares, una superior y otra inferior.
La descomposición 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 números 1 sobre la diagonal.
[U] es una matriz diagonal superior en la que sobre la diagonal no
necesariamente tiene que haber números 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 también convertir en 1 cada pivote. Se utiliza el
mismo concepto de "factor" explicado anteriormente y se ubican todos los
"factores" debajo de la diagonal según 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 ecuación. Por lo tanto, si Ax = b, entonces LUx = b, de manera que Ax
= LUx = b.
Esquemáticamente se busca lo siguiente:
156
MÉTODO PARA CALCULAR LA MATRIZ INVERSA.
Está basado en la eliminación gaussiana y que permite calcular matrices

inversas. La idea de este método es aplicar eliminación gaussiana para hacer
ceros tanto por debajo como por encima de la diagonal y, además, 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 método:
Consideremos la matriz para describir dicho método. Además, para ser más
prácticos, las operaciones que se vayan realizando sobre A también 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 continuación, 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 MÉTODO DE DESCOMPOSICIÓN LU
1. Obtener la matriz triangular inferior L y la matriz triangular superior U.

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

ecuaciones:
NOTA: Recuérdese que si la matriz es 2x2 se hará 1 iteración; si es 3x3, 2

iteraciones; si es 4x4, 3 iteraciones; y así sucesivamente.
158
SOLUCIÓN:
4 -2 -1 9
[A] = 5 1 -1 [B] = 7
1 2 -4 12
ITERACIÓN 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
4 -2 -1
[U] = 0 3.5 0.25
159
0 2.5 - 0.75
Encontrando [L]
1 0 0
[L] = 1.25 0 0
0.25 0 0
ITERACIÓN 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
4 -2 -1
[U] = 0 3.5 0.25
0 0 - 0.9285714286
Encontrando [L]
1 0 0
160
[L] = 1.25 1 0
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 solución del sistema es:
161
Este es finalmente el valor de x1, x2 y x3; es decir, la respuesta del ejercicio
utilizando la descomposición LU.
PROGRAMACIÓN DEL MÉTODO.
Form1.
ACCIONES POR BOTÓN.
Botón ENTRAR.
Tiene la función de abrir la interfaz del Form2 e iniciar con el programa.
Botón Cerrar programa.
Cierra por completo el programa.
162
Form2.
ACCIONES POR BOTÓN.
Botón: Capturar [A]
Permite ir capturando los datos de la matriz a resolver, al insertar un valor es

necesario oprimir el botón “CAPTURAR [A]” para que el programa guarde el
valor asignado.
Botón: Determinante de [A]
Este botón nos arroja el valor de la determinante de la matriz [A]; abriendo el

Form3.
Botón: U
Tiene la función de de obtener el resultado para encontrar a “U” haciendo ceros

la matriz superior triangular.
Botón: L
Tiene la función de obtener el resultado para encontrar a “L” haciendo ceros la

matriz inferior triangular.
Botón: LU
Este botón arroja el resultado de la multiplicación 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 descomposición de la matriz [A]; por tal motivo que el producto de las dos
matrices debe resultar la matriz original.
163
Botón: Capturar [B]
Permite ir capturando los datos de la matriz [B], al insertar un valor es

necesario oprimir el botón “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.
Botón: LD=I
Tiene la función de encontrar los tres coeficientes de la primera columna para

conseguir la matriz inversa.
Botón: LD=j
Tiene la función de encontrar dos coeficientes de la segunda columna y la

primera y tercera fila para conseguir la matriz inversa
Botón: LD=K
Tiene la función de encontrar un coeficientes de la tercera columna y tercera

fila para conseguir la matriz inversa.
Botón: Ux=D
Tiene la función de encontrar los coeficientes de la primera columna y la

primera fila.
Botón: Uy=D
Tiene la función de encontrar los coeficientes de la segunda columna y la

primera y segunda fila.
Botón: Uz=D
Tiene la función de encontrar los coeficientes de la tercera columna y la

primera, segunda y tercera fila.
Botón: Matriz Inversa de [A]
Tiene la función de obtener la matriz inversa de la matriz original [A].
Botón: Solución
Tiene la función de encontrar la solución de las ecuaciones lineales, iniciales y

así poder encontrar las raíces de las incógnitas.
Botón: RESET
Tiene la función de limpiar la información de la matriz anterior y asi poder

agregar otra matriz nueva.
Botón: SALIR
164
Tiene la función de salir del form1 y regresar la portada del formulario principal.
Form3: (Éste Form3 se abre al oprimir el botón “Determinante de [A]” del

Form2.)
Botón Regresar: Cierra el Form3 y regresa al Form2.
CÓDIGO DE PROGRAMACIÓN 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 “inversión de matrices por el método de

descomposición LU” en lenguaje C++.
179
7. Interpolación polinomial por el método de
Newton de diferencias divididas
Un polinomio es una expresión matemática constituida por un conjunto finito de

variables (no determinadas o desconocidas) y constantes (numero fijos
llamados coeficientes). Utilizando únicamente las operaciones aritméticas de
suma, resta y multiplicación, así como también de exponentes enteros positivos.
En términos más precisos, es una combinación 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₀+a₁X+a₂X²+……anXⁿ
 a= Coeficientes
 x= literal que se va a evaluar para encontrar el valor de y
 n= exponente
A diferencia de la interpolación lineal se necesitan dos puntos de una línea

recta, pero en polinomio no necesariamente tiene que ser una función de la
forma Y= mx+n, si no que abarca las funciones cuadráticas, cubicas,
logarítmicas, exponenciales y muchas veces no conoceremos la función, si no
solo la imagen de la función (rango) con su contra dominio (valores de y), en
algunas otras conoceremos la fórmula 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 función.
En la interpolación 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
condición (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 (cuadrática o parábola) 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 relación 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 método de diferencias divididas
x₀,xn,…xn= a los valores del rango
x= valor a evaluar
 Paso 1
De los puntos dados de mi función (recordemos que muchas veces solo nos
proporcionan el dominio y contradominio) (x,y) dependerá el polinomio que
debemos encontrar (véase en la parte superior de la página).
 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 método de diferencias divididas, es la fórmula de pendiente

aquí veremos la relación: hasta un polinomio de grado 3
F(x₀)= x₀
F(x₀,x₁)
F(x₁)= X₁ F(x₀,x₁,x₂,x₃)
{ F(x₁,x₂) { F(x₀,x₁,x₂)
{
F(x₂)= X₂ F(x₁,x₂,x₃)
F(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 dividirán entre la diferencia del mayor al menor de cada intervalo.
181
La ultima parte F(x₀,x₁,x₂,x₃) es igual a la relación 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
demás, 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 función eᵡ, con los siguientes

puntos dados.
X Y
0 1
1 2.71828
2 7.38906
3 20.08654
Pendiente (0 a 1), (1,2), (2,3)
(2.71828-1)/1=2.711828, (7.38906-2.71828)/1=4.67078, (20.08654-

7.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 cálculo exacto si lo situamos en la fórmula es 4.48 por lo cual el margen de

error es muy pequeño
El polinomio obtenido satisface a los puntos de esa función.
GRAFICA:
Código de programación
183
Interfaz gráfica:
Su programación:
//---------------------------------------------------------------------------
#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 gráfica:
Su programación:
//---------------------------------------------------------------------------
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 gráfica:
193
Su código de programación:
//---------------------------------------------------------------------------
#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 Métodos Numéricos
Derivación
Cuando escuchamos la palabra derivada, siempre lo relacionamos con el

cambio de pendiente que sufre una función.
La derivada de una función es una medida de la rapidez con la que cambia el

valor de dicha función matemática, según cambie el valor de su variable
independiente. La derivada de una función es un concepto local, es decir, se
calcula como el límite de la rapidez de cambio media de la función en un cierto
intervalo, cuando el intervalo considerado para la variable independiente se
torna cada vez más pequeño. Por ello se habla del valor de la derivada de una
cierta función en un punto dado.
 Tipos de derivación
 La derivación clásica se opera sobre funciones
Funciones Funciones
𝑥2 2𝑥
𝑥3 3𝑥 2
𝑥4 4𝑥 3
 La derivación cuando se conoce la función
𝑦 = 3𝑥 2 + 7𝑥 𝑦′ = 6𝑥 + 7
1 13
Datos Datos
2 19
3 25
196
 Derivación numérica
X0 Datos
Datos Y0
X1 Y1
Este método es empleado cuando carecemos la función 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 señalar que el salto
debe ser igual para todos los pares de datos, de manera contraria no podrá
realizarse la derivación o no con una seguridad que sea el resultado correcto.
Método basado por el polinomio interpolador de newton (método 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 números de pares a utilizar.
Las fórmulas para derivar no son iguales, depende del orden (pares de datos a
utilizar), la función estará dada por
Los pasos a seguir para la obtención de la derivada serán 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) Fórmula de orden “n” para el cálculo de la primera derivada
197
Siguiendo los pasos anteriores tenemos que:
Derivación numérica de orden 1.
*Se utilizara 2 pares ordenados.
1. Se desarrolla el polinomio interpolador.
2. Se derivada con respecto a la variable x.
Derivación numérica 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
𝒙𝟎 𝑦0 𝑦2 − 𝑦1 𝑦1 − 𝑦0
𝑥1 − 𝑥0
𝑥2 − 𝑥1 − 𝑥1 − 𝑥0
𝑦2 − 𝑦1
𝒙𝟏 𝑦1 𝑥2 − 𝑥0
𝑥2 − 𝑥1
𝒙𝟐 𝑦2
𝑦1 − 𝑦0 𝑦2 − 2𝑦1 + 𝑦0
𝑃(𝑥) = 𝑦0 + (𝑥 − 𝑥0 ) + (𝑥 − 𝑥0 )(𝑥 − 𝑥1 )
ℎ 2ℎ2
𝑦1 − 𝑦0 𝑦2 − 2𝑦1 + 𝑦0
𝑃′(𝑥) = + (𝑥 − 𝑥0 ) + (𝑥 − 𝑥1 )
ℎ 2ℎ2
Evaluando en 𝑥0 , 𝑥1 , 𝑥2 :
𝒙𝟎 (Por la derecha):
𝑦1 − 𝑦0 𝑦2 − 2𝑦1 + 𝑦0
𝑃′(𝑥0 ) = + (𝑥0 − 𝑥0 ) + (𝑥0 − 𝑥1 )
ℎ 2ℎ2
𝑦1 − 𝑦0 𝑦2 − 2𝑦1 + 𝑦0 −𝑦2 + 4𝑦1 − 3𝑦0
𝑃′ (𝑥0 ) = − =
ℎ 2ℎ 2ℎ
𝒙𝟏 (Central):
𝑦1 − 𝑦0 𝑦2 − 2𝑦1 + 𝑦0
𝑃′(𝑥1 ) = + (𝑥1 − 𝑥0 ) + (𝑥1 − 𝑥1 )
ℎ 2ℎ2
𝑦1 − 𝑦0 𝑦2 − 2𝑦1 + 𝑦0 𝑦2 − 𝑦0
𝑃′ (𝑥1 ) = + =
ℎ 2ℎ 2ℎ
𝒙𝟐 (Por la izquierda):
𝑦1 − 𝑦0 𝑦2 − 2𝑦1 + 𝑦0
𝑃′(𝑥2 ) = + (𝑥2 − 𝑥0 ) + (𝑥2 − 𝑥1 )
ℎ 2ℎ2
𝑦1 − 𝑦0 3(𝑦2 − 2𝑦1 + 𝑦0 ) 2𝑦1 − 2𝑦0 + 3𝑦2 − 6𝑦1 + 3𝑦0
𝑃′ (𝑥2 ) = + =
ℎ 2ℎ 2ℎ
3𝑦2 − 4𝑦1 + 𝑦0
=
2ℎ
199
Derivando el factor de error:
𝑑 𝑓 ′′′ (𝑒)
(𝑥 − 𝑥0 )(𝑥 − 𝑥1 )(𝑥 − 𝑥2 )
𝑑𝑥 3!
𝑓 ′′′ (𝑒)
= (𝑥 − 𝑥0 )(𝑥 − 𝑥1 ) + (𝑥 − 𝑥0 )(𝑥 − 𝑥2 ) + (𝑥 − 𝑥1 )(𝑥 − 𝑥2 )
3!
Evaluando:
ℎ2
𝐸 ′ (𝑥0 ) = 𝑓 ′′′ (𝑒) En esta existe menor
3
error, ya que su
ℎ2 ′′′ denominador es mayor.
𝐸 ′ (𝑥1 ) = − 𝑓 (𝑒)
6
ℎ2 ′′′
𝐸 ′ (𝑥2 ) = 𝑓 (𝑒)
3
El procedimiento anterior nos servirá para formar la siguiente tabla para la

primer derivada de orden 𝑛 = 1,2 𝑦 3.
𝒚𝟏 − 𝒚𝟎 𝒉
𝒇’(𝒙𝟎 ) = + 𝒇’’ (𝒆) Derecha
Orden 1 𝒉 𝟐
𝒏=𝟏
𝑦1 − 𝑦0 ℎ
𝑓’(𝑥1 ) = − 𝑓’’ (𝑒) Izquierda
ℎ 2
Orden 2
−𝑦2 + 4𝑦1 − 3𝑦0 ℎ2 ′′′
𝑓 ′ (𝑥0 ) = + 𝑓 (𝑒) Derecha
𝒏=𝟐 2ℎ 3
200
𝑦2 − 𝑦0 ℎ2 ′′′
𝑓 ′ (𝑥) = − 𝑓 (𝑒) Central
2ℎ 6
′ (𝑥)
3𝑦2 − 4𝑦1 + 𝑦0 ℎ2 ′′′
𝑓 = + 𝑓 (𝑒) Izquierda
2ℎ 3
2𝑦3 − 9𝑦2 + 18𝑦1 − 11𝑦0 ℎ3 𝐼𝑉

𝑃′ (𝑥0 ) = − 𝑓 (𝑒) Derecha
6ℎ 8
−𝑦3 + 6𝑦2 − 3𝑦1 − 2𝑦0 ℎ3 𝐼𝑉

𝑃’(𝑥1 ) = + 𝑓 (𝑒) Central
6ℎ 12
Orden 3
𝒏=𝟑
𝑦0 − 6𝑦1 + 3𝑦2 + 2𝑦3 ℎ3 𝐼𝑉
𝑃′ (𝑥2 ) = − 𝑓 (𝑒) Central
6ℎ 12
11𝑦3 − 18𝑦2 + 9𝑦1 − 2𝑦0 ℎ3 𝐼𝑉

𝑃′ (𝑥3 ) = + 𝑓 (𝑒) Izquierda
6ℎ 4
Tomaremos los coeficientes de las formulas anteriores para obtener las

fórmulas para la primera derivada evaluando en cada punto.
201
Interfaz grafica:
Funciones de cada botón:

 Botón “Capturar Y[i]”: Captura los valores para 𝑦0 , 𝑦1 , … , 𝑦𝑛 y los guarda en
un arreglo lineal. Muestra el número de datos ingresados.
 Botón “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.
 Botón “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.
 Botón “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 apoyándose de las formulas

obtenidas anteriormente.
 Código de programación
 //----------------------------------------------------------------

 #include <vcl.h>
 #pragma hdrstop
 #include "Unit1.h"
202
 //----------------------------------------------------------------

 #pragma package(smart_init)
 #pragma resource "*.dfm"

 int i=2,a,b;
 double Y[100],y0,y1,y2,h,der,cen,izq;

 TForm1 *Form1;

 //----------------------------------------------------------------
 __fastcall TForm1::TForm1(TComponent* Owner)
 : TForm(Owner)
 {
 }
 //----------------------------------------------------------------

 void __fastcall TForm1::FormActivate(TObject *Sender)

 {
 Edit1->SetFocus();
 }

 //----------------------------------------------------------------

 //botón capturar Y[i]
 void __fastcall TForm1::Button1Click(TObject *Sender)
 {

 Y[i]=Edit1->Text.ToDouble();
 Label2->Caption="n= "+AnsiString(i-1);
 Edit1->Text="";
 a=i-4;
 i++;
 b=1;

 }

 //----------------------------------------------------------------

 //botón mostrar datos +
 {

 if(b==1){i=-1;}
 if(i<a){i++;}
 Edit3->Text=AnsiString(Y[i]);
 Edit4->Text=AnsiString(Y[i+1]);
 b=0;

 }
 //----------------------------------------------------------------

 //botón mostrar datos -
 {

 if(b==1){i=1;}
 if(i!=0){i--;}
 Edit3->Text=AnsiString(Y[i]);
203
 b=0;

 }
 //----------------------------------------------------------------

 //botón primera
 {

 h=Edit2->Text.ToDouble();
 y0=Edit5->Text.ToDouble();

 der=(-y2+(4*y1)-(3*y0))/(2*h);
 cen=(y2-y0)/(2*h);
 izq=((3*y2)-(4*y1)+y0)/(2*h);

 Edit8->Text=AnsiString(der);
 Edit9->Text=AnsiString(cen);
 Edit10->Text=AnsiString(izq);

 }

 //----------------------------------------------------------------



 //botón reset
 {

 Edit1->Text="";
 Edit2->Text="";
 Edit3->Text="";
 Edit4->Text="";
 Edit5->Text="";
 Edit6->Text="";
 Edit7->Text="";
 Edit8->Text="";
 Edit9->Text="";
 Edit10->Text="";
 Edit11->Text="";
 Label2->Caption="n=";
 a=2;
 }

 //----------------------------------------------------------------
204
9. Segunda Derivada Numérica
La derivada de una función es una medida de la rapidez con la que cambia el

valor de dicha función matemática, según cambie el valor de su variable
independiente. La derivada de una función es un concepto local, es decir, se
calcula como el límite de la rapidez de cambio media de la función en un cierto
intervalo, cuando el intervalo considerado para la variable independiente se
torna cada vez más pequeño. Por ello se habla del valor de la derivada de una
cierta función en un punto dado.
El concepto de derivada es uno de los dos conceptos centrales del cálculo

infinitesimal. El otro concepto es la «antiderivada» o integral; ambos están
relacionados por el teorema fundamental del cálculo. A su vez, los dos
conceptos centrales del cálculo están basados en el concepto de límite, el cual
separa las matemáticas previas, como el Álgebra, la Trigonometría o la
Geometría Analítica, del Cálculo. Quizá la derivada es el concepto más
importante del Cálculo 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 situación. Es una herramienta de cálculo
fundamental en los estudios de Física, Química y Biología, o en ciencias
sociales como la Economía y la Sociología. Por ejemplo, cuando se refiere a la
gráfica de dos dimensiones de f, se considera la derivada como la pendiente de
la recta tangente del gráfico en el punto x. Se puede aproximar la pendiente de
esta tangente como el límite 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 interpretación, pueden determinarse
muchas propiedades geométricas de los gráficos de funciones, tales como
concavidad o convexidad
Prácticamente todas las formas que conocemos surgen a partir de ecuaciones

diferenciales, y de condiciones; por ejemplo en análisis de señales ya que una
señal tiene un amplitud y una frecuencia, actúan como funciones de senos y
cosenos, y para analizarlas te tienes que meter en una ecuación diferencial.
205
En ingeniería se ocupan para analizar cuestiones técnicas de cada rama, por
ejemplo, en electrónica con la ley de Ohm, en química con la leyes de los
gases ideales, en ingeniería civil se ocupan las derivadas para relacionar las
ecuaciones de cargas estáticas con las ecuaciones de momentos flexionantes,
en mecánica se ocupan para calcular para calcular inercias, velocidades,
aceleraciones, y por lo tanto fuerzas internas y externas que actúan en un
mecanismo.
INTERPRETACIÓN DE LA DERIVADA
INTERPRETACIÓN GEOMÉTRICA 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 función 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 función en ese punto.
m t = f'(a)
INTERPRETACIÓN FÍSICA DE LA DERIVADA

VELOCIDAD MEDIA
La velocidad media es el cociente entre el espacio recorrido

(Δe) y el tiempo transcurrido (Δt).
207
LA DERIVACIÓN NUMÉRICA
Es una de las técnicas de análisis numérico para poder calcular una

aproximación a la derivada de una función en un punto utilizando valores y
propiedades.
La derivada es de uso común en las matemáticas y la ingeniera, ya que es la

práctica 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 expresión de una función.
De esta manera surge la necesidad de diseñar métodos numéricos que

permitan aproximar el valor de las derivadas de una función en algún punto.
Los métodos de derivación numérica se desarrollaron con el fin de aproximar

algún valor buscado. La diferencia numérica es muy útil en casos en los cuales
se tienen una función cuya derivada es difícil o complicada de hallar, o en
caso en los cuales no se tienen una función explicita sino una serie de datos
experimentales.
El problema de la derivación numérica consiste en la evaluación de la

derivada de la función de un punto, cuando únicamente conocemos los valores
de la función en una colección de puntos X0, X1...Xn.
La derivada es una propiedad esencialmente local, por lo cual deberemos

aproximar la función lo más fielmente posible en el entorno inmediato del
punto en el que la queremos evaluar. La fórmula de la derivación numérica
aparece en el desarrollo de algoritmos para la solución de problemas de
contorno en ecuaciones diferenciales ordinarias.
208
Fórmulas de Diferencias Centradas
Son fórmulas de aproximación a f’(x) que requieren que la Función se pueda

evaluar en abscisas situadas simétricamente 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 también de las siguientes fórmulas:
PROGRESIVAS:
209
REGRESIVAS:
Entonce
s, para
x= xj, se tiene la fórmula:
CENTRALES:
210
A partir de las fórmulas progresivas, regresivas o centrales para la
aproximación 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 fórmulas para las derivadas de orden superior.
Así por ejemplo, si consideramos las fórmulas progresivas para la primera

derivada se tiene la siguiente fórmula progresiva de la derivada segunda:
Razonando de la misma manera se pueden obtener otras fórmulas para la

derivada segunda, partiendo de las regresivas o de las centrales, o incluso
combinando los distintos tipos.
211
Por ejemplo, considerando las fórmulas centrales se tiene:
Combinando las fórmulas centrales, las progresivas y las regresivas se tiene:
Mediante este mismo procso se pueden obtener fórmulas para las derivadas de
orden tercero, cuarto, etc.
212
INTERFAZ GRÁFICA
213
PROGRAMACIÓN
//---------------------------------------------------------------------------
#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 Gómez 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;
//---------------------------------------------------------------------------
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. Integración numérica por el método de
Simpson tres octavos
En análisis numérico la integración numérica constituye una amplia gama de

algoritmos para calcular el valor numérico de una integral definida y, por
extensión, el término se usa a veces para describir algoritmos numéricos para
resolver ecuaciones diferenciales. El término cuadratura numérica (a menudo
abreviado a cuadratura) es más o menos sinónimo de integración numérica,
especialmente si se aplica a integrales de una dimensión a pesar de que para
el caso de dos o más dimensiones (integral múltiple) también se utilizan.
El problema básico considerado por la integración numérica es calcular una

solución aproximada a la integral definida:
Este problema también puede ser enunciado como un problema de valor inicial
para una ecuación diferencial ordinaria, como sigue:
Encontrar y(b) es equivalente a calcular la integral. Los métodos desarrollados

para ecuaciones diferenciales ordinarias, como el método de Runga-Kutta
pueden ser aplicados al problema reformulado. En este artículo se discuten
métodos desarrollados específicamente para el problema formulado como una
integral definida.
La fórmula fue utilizada por primera vez por Evangelista Torricelli, pero debe su
nombre al matemático Inglés Thomas Simpson. Corresponde a la regla del
tonel que Johannes Kepler ya había formulado en 1615.
Sobre la historia de su surgimiento, Kepler la describe en la dedicatoria de su

publicación posterior. Después de que la primera esposa de Kepler había
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 método,
consistente en introducir la punta de metal de la vara de medir a través 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 través del medio del barril pudiera dar una medida sobre
el volumen contenido y puso en duda la exactitud de este método, debido a que,
por ejemplo, un barril muy bajo que tuviera una base algo más ancha y por eso
un volumen contenido mucho menor podría tener el mismo radio a la vista.
A raíz de esto, Kepler formuló en 1615 el escrito Nova Stereometria doliorum

vinariorum ('Nuevo cálculo del contenido de barriles de vino'), en el que
buscaba métodos verificables para el cálculo del contenido de los toneles de
vino. Uno de estos métodos consistió en aproximar la curvatura del barril por
una parábola, dado que los cálculos con ayuda de parábolas ya se podían
realizar muy exactamente desde Arquímedes.4
Entre otras cosas, Kepler describió en ese texto una fórmula para el cálculo de
la capacidad (más precisamente, del volumen) de barriles de vino con formas
irregulares. Esta fórmula arroja valores exactos para el tronco de la pirámide
(incluida la pirámide), la esfera, el paraboloide elíptico, el hiperboloide de una
hoja y todas las demás superficies de un cuerpo que pueden ser generadas por
secciones planas perpendiculares al eje del cuerpo.
Razones para la integración numérica

Hay varias razones para llevar a cabo la integración numérica. La principal
puede ser la imposibilidad de realizar la integración de forma analítica. Es decir,
integrales que requerirían de un gran conocimiento y manejo de matemática
avanzada pueden ser resueltas de una manera más sencilla mediante métodos
numéricos.
Incluso existen funciones integrables pero cuya primitiva no puede ser

calculada, siendo la integración numérica de vital importancia. La solución
analítica de una integral nos arrojaría una solución exacta, mientras que la
solución numérica nos daría una solución aproximada. El error de la
229
aproximación, que depende del método que se utilice y de qué tan fino sea,
puede llegar a ser tan pequeño que es posible obtener un resultado idéntico a
la solución analítica en las primeras cifras decimales.
Formula de newton-cotes
En análisis numérico las fórmulas de Newton-Cotes (nombradas así por Isaac

Newton y Roger Cotes) son un grupo de fórmulas de integración numérica de
tipo interpolatorio, en las cuales se evalúa la función en puntos equidistantes,
para así hallar un valor aproximado de la integral. Cuantos más intervalos se
divida la función más preciso será el resultado.
Este método es eficiente si se conocen los valores de la función en puntos

igualmente separados. Si se pueden cambiar los puntos en los cuales la
función es evaluada otros métodos como la cuadratura de Gauss son
probablemente más 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 análisis numérico, la regla o método de Simpson, nombrada así en honor a

Thomas Simpson (y a veces llamada regla de Kepler), es un método de
integración numérica 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 están definidas en forma tabular o en forma gráfica y no como funciones
explícitas, se pueden utilizar métodos gráficos, pero los métodos numéricos
son mucho mas precisos.
A continuación se describe la regla de integración de Simpson 3/8 para la

“integración cerrada” es decir, para cuando los valores de la función en los
extremos de los límites de integración son conocidos.
El método de Integración Simpson 3/8 consiste en tomar el área bajo una

ecuación cúbica que conecta cuatro puntos, como se muestra en la siguiente
gráfica:
Dada una función tabular con espaciamientos constantes, de la forma:
La fórmula de integración 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 fácil a continuación una serie de pasos de cómo utilizar el
programa:
1) Introducimos los límites de la función que sería de “a” a “b” y capturamos
a,b.
232
2) Introducimos la función de quinto grado si la función a introducir no es de
quinto grado se coloca el cero en donde le corresponda por ejemplo la
siguiente función: x^3+8; entonces en el programa se escribiría así:
3) Damos click en calcular h,X1,X2, y nos brindara los valores

correspondiente además por definición de la formula le damos click
sobre la formula y nos ofrecerá el resultado de la sustitución de cada
punto a,b,X1,X2; y el valor aproximado de la integral definida.
4) Para calcular el Error Aproximado de la formula teórica calculamos su

cuarta deriva de la función antes introducida y introducimos una valor
que se encuentre entre los límites de la integral entre a, b y programa lo
sustituirá en la formula y calculara el error aproximado que es teórico no
necesariamente es real.
5) A continuación la programación;
#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);
//---------------------------------------------------------------------------
E= Edit19->Text.ToDouble();
Fsus=(A2*E)+B1;
h2=pow(h,5);
Ea=-(h2/6480);
Ea1=Ea*Fsus;
Edit20->Text=AnsiString(Ea1);
//---------------------------------------------------------------------------
238
11. Solución de ecuaciones diferenciales por el
método de Taylor.
Introducción
En el siguiente trabajo se hablara de las ecuaciones diferenciales ordinarias de

primer orden y como poder resolverla usando el método de series de Taylor,
daremos una explicación amplia de que es una ecuación diferencial y sus
clasificaciones, en que consiste el método de series de Taylor y por supuesto
diremos quién es Taylor.
Después combinaremos la información de ecuaciones diferenciales y la serie

de Taylor, para poder resolver dichas ecuaciones e idearemos un programa
que nos ayude en el proceso de resolución de las ecuaciones diferenciales
ordinarias de primer orden.
239
Fundamento teórico
Una ecuación diferencial es una ecuación que relaciona de manera no trivial a

una función desconocida y una o más derivadas de esta función desconocida
con respecto a una o más variables independientes. Si la función desconocida
depende de una sola variable la ecuación diferencial se llama ordinaria, y si
depende de más de una variable, se llama parcial.
La frase de manera no trivial que hemos usado en la definición anterior

tiene como propósito descartar ecuaciones diferenciales que satisfacen la
definición, pero son realmente identidades, es decir, son siempre verdaderas
sin importar quién sea la función desconocida.
 𝑭(𝒙, 𝒚, 𝒚′ , 𝒚′′ , … , 𝒚𝒏 ) = 𝟎
𝒅𝒚 𝒅𝟐 𝒚 𝒅𝒏 𝒚
 𝑭 𝒙, 𝒚, 𝒅𝒙 , 𝒅𝟐 𝒙 , … , 𝒅𝒏 𝒙 = 𝟎
 𝒚𝒏 = 𝒇(𝒙, 𝒚, 𝒚′ , 𝒚′′ , … , 𝒚𝒏−𝟏 )
Llamamos integrar la ecuación diferencial al proceso por el que se encuentra, a

partir de la ecuación diferencial dada, la relación directa entre 𝑥 e 𝑦.
Clasificación de las ecuaciones diferenciales.
Las ecuaciones diferenciales se clasifican según su tipo, orden y linealidad.
Clasificación según su tipo.
Si una ecuación contiene una o más derivadas de variables dependientes con

respecto a una sola variable independiente se dice que es una ecuación
diferencial ordinaria.
Por ejemplo:
𝒅𝒚 𝒅𝟐 𝒚 𝒅𝒚 𝒅𝒚 𝒅𝒙
+ 𝟓𝒚 = 𝒆𝒙 , − 𝒅𝒙 + 𝟔𝒚 = 𝟎 y + 𝒅𝒕 = 𝟐𝒙 + 𝒚
𝒅𝒙 𝒅𝒙𝟐 𝒅𝒕
Una ecuación con una o más derivadas de variables dependientes de dos o

más variables independientes se llama ecuación diferencial parcial (EDP).
Por ejemplo:
𝒅𝟐 𝒖 𝒅𝟐 𝒖 𝒅𝟐 𝒖 𝒅𝟐 𝒖 𝒅𝒖 𝒅𝒖 𝒅𝒗
+ 𝒅𝒚𝟐 = 𝟎, = − 𝟐 𝒅𝒕 y = − 𝒅𝒙
𝒅𝒙𝟐 𝒅𝒙𝟐 𝒅𝒕𝟐 𝒅𝒚
240
Clasificación según su orden.
El orden de una ecuación diferencial es igual al de la derivada de más alto

orden que aparece de manera no trivial en la ecuación. La frase de manera no
trivial tiene el fin de evitar situaciones como la siguiente cuyo orden es uno y no
tres, como podría pensarse.
𝟏
𝒅𝟑 𝒚 𝟑
+ 𝒚 = 𝒆𝒙
𝒅𝒕𝟑
Clasificación según la Linealidad.
Se dice que una ecuación 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 ecuación 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 ecuación diferencial no lineal porque el

coeficiente de la variable dependiente y'' también depende de y.
b) 𝑦′′ + 𝑠𝑒𝑛 𝑦 = 0, es una ecuación diferencial no lineal porque la función

seno es función de y.
c) 𝑦′′ + 𝑦 2 = 0, es una ecuación 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 ecuación 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 solución (o integral) de la ecuación diferencial a cualquier función
𝑦 = 𝑦(𝑥) que introducida en la ecuación diferencial la transforma en igualdad y
verifica la ecuación.
 Tipos de soluciones
Explicitas: La variable dependiente y se expresa tan solo en términos de la

variable independiente "𝑥" y constantes.
Implícitas: Se trata de una relación 𝐺(𝑥, 𝑦) = 0 en la que no se puede

despejar y mediante funciones elementales. Son soluciones todas las 𝑦(𝑥) que
cumplen 𝐺(𝑥, 𝑦) = 0.
Una ecuación diferencial puede tener una cantidad infinita de soluciones que
corresponden a las posibles elecciones de valores para los parámetros.
Solución general: Es aquella solución de la ecuación que está en la forma

estándar; la cual, está definida en un intervalo y llegando a ser de esta manera
miembro de la familia de soluciones. La solución general está conformada por
las constantes paramétricas, dependiendo del orden de la ecuación y el
número de éstas.
Solución particular: Es una función cuya tangente a su gráfica en un punto

cualquier punto (𝑥0 , 𝑦0 ) coincide con la tangente de otra solución, pero ya no
coincide con esta última tangente en ninguna vecindad del punto (𝑥0 , 𝑦0 ), por
pequeña que esta sea. Estas soluciones no se obtienen a partir de la solución
general. Un método para encontrar dichas soluciones es derivar la ecuación
diferencial dada con respecto a 𝑦´.
242
Edmonton
Biografía de Brook Taylor.
Ciudad de Canadá
Brook Taylor
(18/08/1685 - 29/12/1731)
Matemático británico
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ó matemáticas con John Machin y John Keill.
En 1708 Taylor produjo una solución al problema del centro de oscilación, la

cual, desde que fuera difundida hasta 1724, resultaba ser la disputa prioritaria
con Johann Bernoulli. En "Los métodos de incrementación directa e inversa" de
Taylor (1715) agregaba a las matemáticas una nueva rama llamada ahora "El
cálculo de las diferencias finitas", e inventó la integración por partes y descubrió
la célebre fórmula conocida como la Serie de Taylor, la importancia de esta
fórmula no fue reconocida hasta 1772, cuando LaGrange proclamó los
243
principios básicos del Cálculo Diferencial. Taylor también 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 investigación matemática, que hoy se llama
cálculo 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 atracción magnética (1715) y un método no probado para aproximar
las raíces de una ecuación dando un método nuevo para logaritmos
computacionales (1717).
Fue admitido como socio de la Real Sociedad en 1712 y nombrado en ese año
para integrar un comité para la adjudicación de las demandas de Isaac
Newton y de Leibnitz de haber inventado el Cálculo.
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 también murió el niño. Los dos años siguientes los pasó con su familia
en Bifrons; en 1725 se casó, esta vez con la aprobación de su padre, con
Sabetta Sawbridge de Olantigh, Kent, que también murió de parto en 1730; en
esta ocasión, sin embargo, su hija sobrevivió. Su frágil salud hizo que su
estado degenerara con rapidez;
Brook Taylor murió en Somerset House el 29 de diciembre de 1731.
Método de serie de Taylor.
En matemáticas, una serie de Taylor es una representación de

una función como una infinita suma de términos.
Estos términos se calculan a partir de las derivadas de la función para un
determinado valor de la variable (respecto de la cual se deriva), lo que
involucra un punto específico sobre la función. Si esta serie está centrada
sobre el punto cero, se le denomina serie de McLaurin.
Esta representación tiene tres ventajas importantes:
 La derivación e integración de una de estas series se puede realizar

término a término, que resultan operaciones triviales.
 Se puede utilizar para calcular valores aproximados de la función.
 Es posible demostrar que, si es viable la transformación de una función a
una serie de Taylor, es la óptima aproximación 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
Definición de método.
La serie de Taylor es una herramienta matemática que si se usa

aproximadamente facilita muchos los cálculos de aproximación de funciones.
La idea fundamental detrás de la serie de Taylor es la de poder aproximar los

valores de una función 𝑓(𝑥) para cualquier punto "𝑥", a partir de tener un punto
de referencia "𝑎" situado a una distancia "ℎ" del primero y todo esto a partir de
la creación de un polinomio basado en una serie de potencias infinita para la
cual sea posible de manera sistemática calcular sus coeficientes.
𝒇′ (𝒂) 𝒇′′ (𝒂) 𝟐

𝒇(𝟑) (𝒂)
𝒇(𝒙) = 𝒇(𝒂) + (𝒙 − 𝒂) + (𝒙 − 𝒂) + (𝒙 − 𝒂)𝟑 + ⋯
𝟏! 𝟐! 𝟑!
𝒇𝒏 (𝒂) 𝒏
+ (𝒙 − 𝒂)
𝒏!
Que puede ser escrito de una manera más compacta como la

siguiente sumatoria.
∞
𝒇𝒏 (𝒙𝟎 )
(𝒙 − 𝒙𝟎 )𝒏
𝒏!
𝒏=𝟎
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 también 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 función a desarrollar original) para expresarla como
𝑎𝑛 𝑧 𝑛 centrada en 0.
Luego hay que deshacer el cambio de variable. Por ejemplo, si se quiere
desarrollar la función 𝑓(𝑥) = 𝑥𝐼𝑛𝑥 alrededor de 𝑎 = 1se puede tomar 𝑧 = 𝑥 − 1,
de manera que se desarrollaría 𝑓(𝑧 + 1) = (𝑧 + 1)𝐼𝑛(𝑧 + 1) centrada en 0.
Historia de las series de Taylor.
El filósofo eleata Zenón 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 Zenón.
Posteriormente, Aristóteles propuso una resolución filosófica a la paradoja,
pero el contenido matemático de esta no quedó resuelto hasta que lo
retomaron Demócrito y después Arquímedes.
Fue a través del método exhaustivo de Arquímedes que un número infinito de

subdivisiones geométricas progresivas podían alcanzar un resultado
trigonométrico finito. Independientemente, Liu Hui utilizó un método similar
cientos de años después.
En el siglo XIV, los primeros ejemplos del uso de series de Taylor y métodos
similares fueron dados por Madhava de Sangamagrama. A pesar de que hoy
en día ningún registro de su trabajo ha sobrevivido a los años, escritos de
matemáticos hindúes posteriores sugieren que él encontró un número de casos
especiales de la serie de Taylor, incluidos aquellos para las funciones
trigonométricas del seno, coseno, tangente y arco-tangente.
En el siglo XVII, James Gregory también 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 quién recibe su nombre. Las series de
Maclaurin fueron nombradas así por Colin Maclaurin, un profesor de Edimburgo,
quién publicó el caso especial de las series de Taylor en el siglo XVIII.
Solución de ecuaciones diferenciales ordinarias de primer orden por el

método de series de Taylor.
Como ya tenemos la conceptualización y generalidades de que es una

ecuación diferencial y en que consisten las series de Taylor. Ahora si podemos
solucionar ecuaciones diferenciales ordinarias de primer orden por el método
de series de Taylor;
Como ya vimos anteriormente el desarrollo en serie de Taylor, en torno a un

punto 𝑥 = 𝑎:
𝒇′ (𝒂) 𝒇′′ (𝒂) 𝟐

𝒇′′′ (𝒂)
𝒇(𝒙) = 𝒇(𝒂) + (𝒙 − 𝒂) + (𝒙 − 𝒂) + (𝒙 − 𝒂)𝟑 + ⋯
𝟏! 𝟐! 𝟑!
𝒇𝒏 (𝒂)
+ (𝒙 − 𝒂)𝒏
𝒏!
(𝒙 − 𝒂)
′ (𝒂) ′′ (𝒂)
(𝒙 − 𝒂)𝟐 ′′′ (𝒂)
(𝒙 − 𝒂)𝟑
𝒚(𝒙) = 𝒚(𝒂) + 𝒚 +𝒚 +𝒚 +⋯
𝟏! 𝟐! 𝟑!
(𝒙 − 𝒂)𝒏
+ 𝒚𝒏 (𝒂)
𝒏!
246
Ahora:
1.- La función 𝑓(𝑥) debe pertenecer al ser infinito esto quiere decir que tenga
infinitas derivadas.
2.- Que la serie converge (que por más que crezca la serie o la alarguemos
hacia el infinito, la suma de todos sus elementos tiende a un límite “n”).
Si en particular hacemos 𝑎 = 𝑥𝑛 y 𝑥 = 𝑥𝑛 + ℎ entonces la ecuación cambiaria:
𝒂 = 𝒖𝒏 𝒑𝒖𝒏𝒕𝒐 𝒅𝒆 𝒓𝒆𝒇𝒆𝒓𝒆𝒏𝒄𝒊𝒂, 𝒙𝒏 = 𝒄𝒖𝒂𝒍𝒒𝒖𝒊𝒆𝒓 𝒏𝒖𝒎𝒆𝒓𝒐 𝒓𝒆𝒂𝒍, 𝒉 =

𝒅𝒊𝒔𝒕𝒂𝒏𝒄𝒊𝒂 𝒆𝒏𝒕𝒓𝒆 "𝒙" 𝒚 "𝒂"
(𝒉) (𝒉)𝟐 (𝒉)𝟑 (𝒉)𝒏

𝒇(𝒙𝒏 + 𝒉) = 𝒇(𝒙𝒏 ) + 𝒇′ (𝒙𝒏 ) + 𝒇′′ (𝒙𝒏 ) + 𝒇′′′ (𝒙𝒏 ) + ⋯ + 𝒇𝒏 (𝒙𝒏 )
𝟏! 𝟐! 𝟑! 𝒏!
3.- Contando con una condición inicial, Usaremos los primeros términos de la
sucesión en serie para aproximar los valores de "𝑦" o 𝑓(𝑥).
4.- Derivaremos la función, claro que no se puede derivar infinitas veces, pero
entre más veces se derive más aproximado será el resultado
𝒇′ (𝒂), 𝒇′′ (𝒂), 𝒇′′′ (𝒂), … , 𝒇𝒏 (𝒂)
5.- Obteniendo las derivadas en función a la variable independiente, se

sustituirán los valores de la condición inicial, en cada una de las derivadas.
6.- Teniendo los valores de las derivadas se sustituirán en la serie de Taylor

para obtener el polígono que se aproxima a la función original, dependiendo las
condiciones iniciales es la serie de Taylor que se usara.
𝒇′ (𝒂) 𝒇′′ (𝒂) 𝒇′′′ (𝒂)

𝒇(𝒙) = 𝒇(𝒂) + (𝒙 − 𝒂) + (𝒙 − 𝒂)𝟐 + (𝒙 − 𝒂)𝟑 + ⋯
𝟏! 𝟐! 𝟑!
𝒇𝒏 (𝒂)
+ (𝒙 − 𝒂)𝒏
𝒏!
′ (𝒂)
(𝒉) ′′ (𝒂)
(𝒉)𝟐 ′′′ (𝒂)
(𝒉)𝟑 𝒏 (𝒂)
(𝒉)𝒏
𝒇(𝒙) = 𝒇(𝒂) + 𝒇 +𝒇 +𝒇 + ⋯+ 𝒇
𝟏! 𝟐! 𝟑! 𝒏!
Ejemplos:
𝑑𝑦
Usar las series de Taylor para hallar la solución en serie de = 𝑦 2 − 𝑡. Donde
𝑑𝑡
la condición inicial es 𝑦 = 1 en 𝑡 = 0. Usaremos los primeros términos de esta
solución en serie para aproximar los valores de 𝑦.
Solución: como ℎ = 0 entonces,
247
𝒚′′(𝟎) 𝟐 𝒚′′′(𝟎) 𝟑
𝒚 = 𝒚(𝟎) + 𝒚′ (𝟎)𝒕 + 𝒕 + 𝒕 +⋯
𝟐! 𝟑!
𝐶𝑜𝑚𝑜 𝑦(0) = 1 e 𝑦’ = 𝑦 2 − 𝑡, derivando se tiene lo siguiente:
𝒚(𝟎) = 𝟏
𝒚′ = 𝒚𝟐 − 𝒕 𝒚′ (𝟎) = 𝟏
𝒚′′ = 𝟐𝒚𝒚′ − 𝟏 𝒚′′ (𝟎) = 𝟐 − 𝟏 = 𝟏
𝒚′′′ = 𝟐𝒚𝒚′′ + 𝟐(𝒚′ )𝟐 𝒚′′′ (𝟎) = 𝟐 + 𝟐 = 𝟒
𝒚𝑰𝑽 = 𝟐𝒚𝒚′′′ + 𝟔𝒚′𝒚′′ 𝒚𝑰𝑽 (𝟎) = 𝟖 + 𝟔 = 𝟏𝟒

𝟐
𝒚𝑽 = 𝟐𝒚𝒚𝑰𝑽 + 𝟖𝒚′ 𝒚′′′ + 𝟔(𝒚′′ ) 𝒚𝑽 (𝟎) = 𝟐𝟖 + 𝟑𝟐 + 𝟔 = 𝟔𝟔
Por tanto la aproximación:
𝒚′′(𝟎) 𝟐 𝒚′′′(𝟎) 𝟑 𝒚𝟒 (𝟎) 𝟒 𝒚𝟓 (𝟎) 𝟓

𝒚 = 𝒚(𝟎) + 𝒚′ (𝟎)𝒕 + 𝒕 + 𝒕 + 𝒕 + 𝒕 …
𝟐! 𝟑! 𝟒! 𝟓!
Reemplazando los valores encontrados tenemos:
𝟏 𝟒 𝟏𝟒 𝟒 𝟔𝟔 𝟓
𝒚 = 𝟏 + 𝒕 + 𝒕𝟐 + 𝒕𝟑 + 𝒕 + 𝒕 …
𝟐 𝟑 𝟒 𝟓
Ahora ya se puede aproximar la solución 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 solución en serie de 𝑥0 = 1, 𝑦0 = 1,

ℎ = 0.1, aplicando la regla obtendremos:
Solución:
𝒚´´ = 𝟐𝒙𝒚´ + 𝟐𝒚
𝒚𝟎 =1
248
𝒚´𝟎 = 𝟐𝒙𝟎 𝒚𝟎 = 𝟐(𝟏)(𝟏) = 𝟐
𝒚´´𝟎 = 𝟐𝒙𝟎 𝒚´𝟎 + 𝟐𝒚 = 𝟐(𝟏)(𝟐) + 𝟐 = 𝟔
Por lo que la ecuación particular es:
(𝒉)𝟐 𝟎. 𝟏𝟐
𝒇(𝒙) = 𝒇(𝒙𝒏 ) + 𝒇′ (𝒙𝒏 )(𝒉) + 𝒇′′ (𝒙𝒏 ) = 𝟏 + 𝟐(𝟎. 𝟏) + 𝟔 = 𝟏. 𝟐𝟑
𝟐! 𝟐
Código del programa y explicación
PASOS A SEGUIR PARA GUARDAR EL PROYECTO:
1. Cargar B:
Al cargarlo se crea automáticamente 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 botón “Guardar”.
8. Dar el siguiente nombre al proyecto “Proyecto en Equipo”.
9. Oprimir el botón “Guardar”.
INTERFAZ GRAFICA:
Presentación 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 gráfica.
2. Poner en el formulario 2 componentes tipo Button.
interfaz gráfica.
2.2 Seleccionar individualmente cada componente tipo Button y escribir
la programación asignada para cada componente.
250
2.3 Para poder acceder a escribir la programación se deberá seleccionar
el componente y darle doble click.
Programación de Form1 (Presentación):
//---------------------------------------------------------------------------
#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 están 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 presentación y uno para
borrar todos los datos.
Auxiliándonos de los componentes RadioButton los cuales se corresponde una ecuación

diferente dependiendo que se quiere calcular, si lo que se quiere calcular es la solución
general de la ecuación diferencial, la cual es otra ecuación debemos dar las condiciones
iniciales y se marcara el RadioButton1 o bien si lo que se desea es saber la posición de un
punto 𝑥 a una distancia ℎ de un punto conocido (𝑥0 , 𝑦0 ) en las condiciones iniciales
daremos el valor de ℎ.
252
Interfaz gráfica para calcular la función 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 gráfica.
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 gráfica.
4. Poner en el formulario 7 componentes tipo Button.

interfaz gráfica.
4.2 Seleccionar individualmente cada componente tipo Button y escribir
la programación asignada para cada componente.
4.3 Para poder acceder a escribir la programación se deberá seleccionar
el componente y darle doble click.
Programación 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. Lógica difusa
Lotfi Asker Zadeh. Matemático, ingeniero eléctrico, informático y profesor

azerbaiyano de la Universidad de Berkeley. Es famoso por introducir en 1965 la
teoría de conjuntos difusos o lógica difusa. Se le considera asimismo el padre
de la teoría de la posibilidad.
Es una forma matemática en el que la verdad puede tomar un valor de un

rango continuo de valores entre 0 y 1.Es una extensión de lógica 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 diseño de lógica de control para sistemas del
mundo real.
EJEMPLO COTIDIANO
Un vaso medio lleno, independientemente de que también este medio vacío, no

está lleno completamente ni está vacío 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 solución simple o un modelo matemático preciso
Es útil también cuando se necesita usar el conocimiento de un experto que

utiliza conceptos ambiguos o imprecisos
¿Cuándo NO ES RECOMENDABLE?
No es recomendable utilizar la lógica difusa cuando algún modelo matemático

ya soluciona eficientemente el problema, cuando los problemas son lineales o
cuando no tienen solución
Botón km/hr: Captura la velocidad del carro, e indica con imágenes la

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

imagen la distancia respectivamente.
Botón Tiempo en cruzar: Da el tiempo en que tardaría en cruzar la persona

con la siguiente formula tie=dis/(vel*1000/3600)
265
Botón Velocidad del Paso: calcula la velocidad con la que la persona debería
de caminar. Se calcula con la siguiente formula: velpaso=Edit3-
>Text.ToDouble()/tie;
Botón Reset: borra los datos escritos en el formulario y reinicia el programa.
PROGRAMACION PARA LOS BOTONES
Bóton “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
Botón “Tiempo en Cruzar”
tie=dis/(vel*1000/3600);
Label6->Caption=tie;
Label5->Visible=true;
Botón “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;
Bóton 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. Método de Newton para
ecuaciones no lineales
METODO DE NEWTON PARA ECUACIONES NO LINEALES
Este método nos servirá para encontrar la solución a un sistema no lineal es

decir de exponentes diferentes a 1.
La fórmula de recurrencia de este método es la siguiente:
La ecuación tiene analogía con la ecuación del método de Newton Raphson

para encontrar raíces de ecuaciones:
DONDE "J" es el Jacobiano:
Y J^(-1) lo podemos determinar de la siguiente manera:
269
Para encontrar la fórmula 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 fórmula de la adjunta, si es una matriz de orden mayor se realizan por
métodos ya conocidos.
Posteriormente se precede a conocer aJ-1
270
271
La programación 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 número 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 número 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. Resolución de ecuaciones diferenciales
ordinarias por el Método de Runge-Kutta.
Los métodos de Runge-Kutta son un conjunto de métodos genéricos iterativos,

explícitos e implícitos, de resolución numérica de ecuaciones diferenciales.
Este conjunto de métodos fue inicialmente desarrollado alrededor del año 1900
por los matemáticos C. Runge y M. W. Kutta.
A este método se le conoce también como Euler modificado. Es igual que el

método de Euler mejorado pero en la ecuación de la pendiente no se despeja
𝑦𝑛+1 , sino que se evalúa en la ecuación de Euler sin mejorar.
Euler mejorado
𝑓(𝑥𝑛 , 𝑦𝑛 ) + 𝑓(𝑥𝑛+1 , 𝑦𝑛+1 )
𝑓(𝑥𝑛 , 𝑦𝑛 ) =
2
Euler sin
𝑦𝑛+1 = 𝑦𝑛 + ℎ 𝑓(𝑥𝑛 , 𝑦𝑛 ) mejorar
𝑓(𝑥𝑛 , 𝑦𝑛 ) + 𝑓(𝑥𝑛+1 , 𝑦𝑛 + ℎ 𝑓(𝑥𝑛 , 𝑦𝑛 ) )

𝑓(𝑥𝑛 , 𝑦𝑛 ) = Euler modificado
2
En donde desaparece el término 𝑦𝑛+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
Considérese
𝑘1 = ℎ 𝑓(𝑥𝑛 , 𝑦𝑛 )
𝑘2 = ℎ 𝑓(𝑥𝑛+1 , 𝑦𝑛 + ℎ 𝑓(𝑥𝑛 , 𝑦𝑛 ) ) = ℎ 𝑓(𝑥𝑛+1 , 𝑦𝑛 + 𝑘1 )
Podemos simplificar la fórmula de recurrencia a
𝑘1 + 𝑘2
𝑦𝑛+1 = 𝑦𝑛 +
2
Ejemplo:
𝑦 ′ + 4𝑦 = 𝑒 −2𝑥 ℎ = 0.1 𝑓(0) = 1
Poner en la forma 𝑦 ′ (𝑥) = 𝑓(𝑥, 𝑦)
𝑦 ′ = 𝑒 −2𝑥 − 4𝑦
𝑘1 + 𝑘2
𝑦𝑛+1 = 𝑦𝑛 +
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
−0.3−0.21296
𝑦1 = 1 + = 0.74352
2
284
Programación
Interfaz gráfica propuesta
Descripción por botón
Botón “Calcular”:
Lee los valores para ℎ, 𝑥0 y 𝑦0 , dentro de una estructura de repetición calcula

los valores para 𝑥1 , … , 𝑥10 y 𝑦1 , … , 𝑦10 .
Para 𝑥: suma el valor anterior más el del salto.
Para 𝑦: utiliza la fórmula de recurrencia calculada en el ejemplo antes

mostrado; apoyándose de las variables auxiliares 𝑘1 y 𝑘2 . Muestra los
resultados en los Edits correspondientes.
Botón “Graficar”:
Realiza una gráfica de la función con los puntos calculados sobre un eje
coordenado.
Botón “Reset”:
Borra los datos escritos en el formulario y posiciona el puntero en el primer Edit.

285
Código de Programación
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init) --------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;
Canvas->LineTo(272,392); ---------- 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. Lógica Difusa
OBJETIVO DEL PROYECTO
Este proyecto se podrá identificar las causas e inicio de la lógica difusa, junto
con las diferentes aplicaciones en la vida cotidiana, así mismo para su
compresión se desarrollo un programa relacionado con la aplicación de la
lógica difusa, con el fin de una mayor compresión y entendimiento del tema.
INTRODUCCIÓN
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 términos ambiguos. Por ello se
tratara de exponer algunas cualidad y ventajas que diserne de la lógica clásica
con la lógica difusa donde la prioridad principal no se tratá de solo razonar sino
de poder hacer una descripción completa de cada situación y disponer de
criterios de una compresión genérica como de clasificación y de análisis de
conjuntos de probabilidades de una situación.
Afortunadamente esta generalidad y ambigüedad son suficientes para el

avance de la comprensión 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 comprensión lo que hace tangible en
conocimiento y la factibilidad de la difusión sobre las situaciones con sus
respectivas posibilidades de soluciones posibles ante un tema.
LÓGICA DIFUSA EN INGENIERÍA CIVIL
La lógica difusa fue desarrollada por el profesor de la universidad de california

en Berkeley a principios de los años 60’, surgiendo como una herramienta de
trabajo para el control de sistemas y procesos industriales complejos que se
anteponían para ese entonces como la adversidad que delimitaba el
conocimiento humano.
La lógica difusa es una lógica alternativa de la lógica 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
matemático como lingüístico. Por ejemplo "luego", para el análisis de
fenómenos rápidos en ingeniería puede ser del orden de nanosegundos, pero
para paleontólogos del orden de miles de años. 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 más no unidades absolutas.
La aplicación de la lógica difusa es necesaria para los conjuntos complejos

donde no existe una solución simple o modelo matemático 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 matemáticos eficientes de un problema.
 Cuando los problemas sean de manera lineal.
 Cuando un problema cuenta con un solución satisfactoria.
Ventajas:
 Controla sistemas complejos.
 Permite trabajar con información no exacta.
 Define evaluaciones convencionales.
 Permite la utilización de conocimientos ambiguos o imprecisos.
Aplicaciones de la lógica difusa en la vida:
Después del desarrollo de la lógica difusa su aplicación se expandió a distintos

ámbitos de nuestra vida como son los siguientes:
291
 Control de sistemas: como el control del tráfico de las ciudades, control
de vehículos, control de compuertas en plantas hidroeléctricas, en
centrales térmicas, control de lavadoras, control de llegadas de metro,
ascensores, etc.
 Predicción de terremotos y optimización de horarios.
 Reconocimientos de patrones y visión del ordenador como
reconocimiento de objetos, vibraciones de cámaras, reconocimientos de
manuscritos, etc.
 Sistemas de conocimiento o conocimiento como bases de datos entre
otros.
Las lógicas difusas abarcan diferentes tipos de conjuntos de intercambio de

términos que ayudan al ordenamiento de funciones, como a discernir ideas
para una solución.
Conjuntos difusos
Los conjuntos difusos se encuentran asociados por un valor lingüístico que está
definido por una palabra, adjetivo o ética lingüística. Donde la función de
pertenecía puede tomar valores del intervalo de 0 y 1, y su transición de esta
es gradual y no cambia y no cambia de manera instantánea.
{ A = (x, pA(x)) | x Ε P }
Donde pA(x) es la función de pertenecía de la variable x, y P es el universo en

discurso. Cuando más cerca este la pertenencia del conjunto A al valor 1,
mayor será la pertenecía de la variable x al conjunto A. por ejemplos:
Controlador Difuso
292
Por otro lado cabe recalcar que la lógica 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 continuación:
Fusificación
Asigna grados de pertenencia a cada una de las variables de entrada con

relación 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 aplicación y los objetos

de control. Aquí se define las reglas lingüísticas que indican como debe actuar
el programa.
Inferencia
Relaciona los conjuntos difusos de entrada y salida que definirán el sistema

para generar reglas mediante el uso de condicionantes.
Defusificación
Adecua los valores difusos generados en la inferencia que se utilizaran para el

control, en esta parte se utiliza métodos matemáticos muy indispensables como
es; el método del centroide, método del promedio ponderado y método de
membresía del medio del máximo.
CONCLUSIÓN
293
En relación con la lógica clásica nos damos cuenta que existen muchas
inferencia entre la lógica difusa que son variables indispensables y de gran
importancia, así mismo denotamos que la lógica difusa son procedimientos
entre ellas no son de intuitivos sino que están estrechados por variables y
patrones de orden para su funcionamiento. De esta manera se recomienda
hacer uso de este procedimiento cuando tengamos términos 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 ingeniería 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 aplicación
de la lógica difusa en ingeniería 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 imágenes del barco y el nadador, y dos para
mostrar los valores de velocidad y distancia del barco.
 Las dos imágenes que servirán para los valores de distancia y
velocidad se le cambian la configuración 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 líneas de programación para cada botón.

 Paso 12: Declarar todas las variables que se utilizaron.
Los códigos de programación 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 botón para la interfaz 2
Botón “km/h”
Al ingresar un valor a la velocidad del barco este lo captura y al valor numérico

le da un valor de pertenencia al conjunto al conjunto que se encuentre dicho
valor.
Botón “metros”
Captura el valor de la velocidad del barco y le da un valor de pertenencia

dentro del conjunto difuso.
Botón “tiempo en cruzar”
Calcula el tiempo que tarda en llegar el barco al punto donde se encuentra la

persona.
Botón “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 lingüístico a la velocidad
dependiendo de los valores de pertenencia que tengan los siguientes valores:
despacio, normal y rápido. Para mostrar las animaciones graficas se utilizó un
componente “Timer”.
298
Código de programación.
//---------------------------------------------------------------------------
#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);
Label6->Caption=tie; Tiempo en cruzar
301
//---------------------------------------------------------------------------
Velocidad de paso
velpaso=Edit3->Text.ToDouble()/tie;
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;
Reiniciar
Image4->Top=300;
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. Cálculo de corriente del agua en una presa.
304
2.1. INTERFAZ 1
La programación 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="PEQUEÑA";
}
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 SUEÑOS";
}
l=1;
if(k==1&&l==1){
}
}
//---------------------------------------------------------------------------
{
Tiempo de paso
pas=vol/anc*10/3600;
Label6->Caption=tie;
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 máximo ";
}
if(cantpaso>600){
Label11->Caption="Flujo excesivo descontrolado ";
}
}
//---------------------------------------------------------------------------
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
k=0;
l=0;
Button1->Enabled=false; Reset
310
Label2->Caption="";
Label4->Caption="";
Label6->Caption="";
Label9->Caption="";
}
//---------------------------------------------------------------------------
{
Regresar
Close();
}
//----------------------------------------------------------------
311

Manual de Teoria y Codigos de Metodos Numericos 2° A PDF

Cargado por

Copyright:

Formatos disponibles

Manual de Teoria y Codigos de Metodos Numericos 2° A PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual de Teoria y Codigos de Metodos Numericos 2° A PDF

Cargado por

Copyright:

Formatos disponibles

Universidad Autónoma de

Apuntes de Métodos Numéricos

Por Alumnos de 2° “A”

Por Alumnos de 2° “A”

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

2. Método de Newton – Raphson. (Equipo 2)……………..……pag. 17

3. Metodo de Ferrari: Solucion de ecuaciones

4. Metodo de Müller. (Equipo 4)…………….……………….…...pag. 57

5. Solucion de ecuaciones lineales por el método

6. Inversion de matrices por el método de

7. Interpolacion polinomial por el método de

8. Primer derivada por métodos numéricos. (Equipo 9)...……..pag. 196

9. Segunda derivada numérica. (Equipo 10)…………………....pag. 205

10. Integracion numérica por el método de

11. Solucion de ecuaciones diferenciales por

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

13. Metodo de Newton para ecuaciones

14. Resolucion de ecuaciones diferenciales

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

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

Análisis del error:

Entonces, resulta que los límites de ambas sucesiones son iguales:

Tomando el límite en la desigualdad f(an).f(bn) ≤ 0, encontramos que

Se llamará [an,bn] al intervalo obtenido en el paso n-1. Si en este momento

El error en el paso n es:

Una gran ventaja de este método es que siempre converge para

No obstante, una de las grandes desventajas que presenta este método

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

Aproximación inicial y criterios de convergencia

El método de la bisección depende de la determinación de un intervalo

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

Presionamos el botón de entrada i directamente nos manda a la siguiente

A continuación un ejemplo del interfaz del programa con un polinomio

Y para estar seguros de que es una raíz del polinomio se muestra en la

A continuación la programación de la interfaz del método de Bisección.

#pragma resource "*.dfm"

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,

__fastcall TForm2::TForm2(TComponent* Owner)

void __fastcall TForm2::Button1Click(TObject *Sender)

void __fastcall TForm2::Button2Click(TObject *Sender)

void __fastcall TForm2::Button3Click(TObject *Sender)

Label16->Caption="Eso es todo Margaritos...!!!";

void __fastcall TForm2::Button6Click(TObject *Sender)

void __fastcall TForm2::Button4Click(TObject *Sender)

void __fastcall TForm2::Button5Click(TObject *Sender)

#pragma resource "*.dfm"

__fastcall TForm3::TForm3(TComponent* Owner)

void __fastcall TForm3::Button1Click(TObject *Sender)

El método de Newton (también llamado

“El valor de la derivada en un punto es igual a la pendiente de la recta tangente que

Para esto se toma la recta tangente a la función en un punto próximo a la

Este método se basa en la interpretación geométrica de la derivada para

Partiendo de una función ƒ (xn), cuya derivada es ƒ´(xn) y recordando que:

ƒ´ (xn) = m, y m = tan ϴ = Cateto opuesto / Cateto adyacente

Por lo consiguiente, la fórmula de la derivada se expresa de la siguiente forma:

Despejando Xn+1 en la ecuación obtenemos:

Geométricamente, este método trabaja mediante un valor de arranque, que

La fórmula vuelve a realizar el mismo

#pragma resource ".dfm" TForm1 Form1;

#pragma resource ".dfm" TForm3 Form3;

#pragma resource ".dfm" TForm4 Form4;

#pragma resource ".dfm" TForm5 Form5;

#pragma resource ".dfm" TForm6 Form6;

#pragma resource ".dfm" TForm7 Form7;

#pragma resource ".dfm" TForm8 Form8;