Upload
marco
View
233
Download
0
Embed Size (px)
Citation preview
8/18/2019 Manual de teoria y codigos de metodos numericos C++
1/313
Universidad Autónoma deChiapas
Facultad de Ingeniería
Ingeniería Civil
Programación
Apuntes de Métodos Numéricos
Por Alumnos de 2° “A”
8/18/2019 Manual de teoria y codigos de metodos numericos C++
2/313
1. Metodo de Biseccion. (Equipo 1)……………………….…......pag. 2
2. Método de Newton – Raphson. (Equipo 2)……………..……pag. 17
3. Metodo de Ferrari: Solucion de ecuacionesde cuarto grado. (Equipo 3)…………….………………….......pag. 41
4. Metodo de Müller. (Equipo 4)…………….……………….…...pag. 57
5. Solucion de ecuaciones lineales por el métodode eliminación de Gauss. (Equipo 5)……..…………….….…pag. 79
6. Inversion de matrices por el método dedescomposición de L.U. (Equipo 6)……………….……...…..pag. 156
7. Interpolacion polinomial por el método dediferencias 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 deSimpson tres octavos. (Equipo 11)………………...........pag. 228
11. Solucion de ecuaciones diferenciales porel método de Taylor(Equipo 12)..……………….............pag. 239
12. Logica difusa. (Equipo 13)……….…………………….....pag. 264
13. Metodo de Newton para ecuacionesno lineales. (Equipo14)…..………..…………..................pag. 269
14. Resolucion de ecuaciones diferencialesOrdinarias por el método de
Runge-Kutta. (Equipo15)…………………………….......pag. 283
15 Logica difusa (Equipo 16) pag 290
ÍNDICE
8/18/2019 Manual de teoria y codigos de metodos numericos C++
3/313
Si f es una función continua sobre el intervalo [a;b] y si f(a).f(b)
8/18/2019 Manual de teoria y codigos de metodos numericos C++
4/313
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 momentose 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 delintervalo [an, bn], la distancia del punto medio del intervalo a r debe sermenor 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 parafunciones 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, sepuede observar que en este método después de cada iteración el tamaño delintervalo se reduce a la mitad; después de n iteraciones el intervalo original se
8/18/2019 Manual de teoria y codigos de metodos numericos C++
5/313
habrá reducido 2n veces. Por lo anterior, si el intervalo original es de tamaño My el criterio de convergencia aplicado al valor absoluto de la diferencia de dosaproximaciones sucesivas es ε, se puede saber de antemano el número deiteraciones que se requieren:
No obstante, una de las grandes desventajas que presenta este métodoes su velocidad de convergencia, la cual es bastante baja.
Orden de convergencia
Un algoritmo converge linealmente si existe una constante positiva K
8/18/2019 Manual de teoria y codigos de metodos numericos C++
6/313
Es imprescindible establecer un criterio de parada para que el algoritmodetenga las iteraciones cuando haya obtenido una aproximaciónsuficientemente precisa
Como el objetivo es resolver f(x)=0, el valor xn debería verificar que:
Así, el proceso iterativo producirá puntos P i= (xi; f(xi)) hasta que el últimopunto Pn se encuentre en la banda horizontal comprendida entre las rectas deecuaciones y=ε e y=-ε.
Otro criterio de parada involucra las abscisas. Se trata de determinar si lasucesión {xn} converge y, para ello, se dibujan dos rectas verticales deecuaciones x=P+β y x=P-β a cada lado de x=P. De esta manera, el proceso sedetendrá cuando Pn está entre ambas rectas.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
7/313
A continuación mostramos la interfaz del programa, para luego la programaciónen 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 siguienteinterfaz.
A continuación un ejemplo del interfaz del programa con un polinomio(x^4+3x^3 – 2 = 0).
8/18/2019 Manual de teoria y codigos de metodos numericos C++
8/313
Después de haber realizado varias iteraciones llegamos a la raíz aproximadacomo se muestra en la interfaz.
Y para estar seguros de que es una raíz del polinomio se muestra en lasiguiente grafica que efectivamente existe una aproximación a la raíz obtenida.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
9/313
Esta programación nos ayudara a encontrar una sola raíz real de un polinomioen caso de que exista y para ya no seguir haciendo laboriosos procedimientosen esta interfaz es muy útil porque solo introducimos el polinomio y después deunas cuantas iteraciones nos dice la raíz. En caso de que este método nofuncione hay muchos tipos de métodos para encontrar una raíz de unpolinomio.
A continuación la programación de la interfaz del método de Bisección.
Códigos de programación:
8/18/2019 Manual de teoria y codigos de metodos numericos C++
10/313
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit2.h"
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
#include
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)
8/18/2019 Manual de teoria y codigos de metodos numericos C++
11/313
: 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;
Edit12->Text=AnsiString(Fx2);
Fx3=a*(pow(h,4))+ b*(pow(h,3))+c*(pow(h,2))+d*h+e;
8/18/2019 Manual de teoria y codigos de metodos numericos C++
12/313
Edit13->Text=AnsiString(Fx3);
Fx4=a*(pow(t,4))+b*(pow(t,3))+c*(pow(t,2))+d*t+e;
Edit14->Text=AnsiString(Fx4);
Fx5=a*(pow(j,4))+b*(pow(j,3))+c*(pow(j,2))+d*j+e;
Edit15->Text=AnsiString(Fx5);
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button2Click(TObject *Sender)
{
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++;
}
8/18/2019 Manual de teoria y codigos de metodos numericos C++
13/313
//---------------------------------------------------------------------------
void __fastcall TForm2::Button3Click(TObject *Sender)
{
prod=Fxl*Fr;
Edit19->Text=AnsiString(prod);
por=((m-l)/m)*100;
Edit20->Text=AnsiString(por);
Label16->Caption="Eso es todo Margaritos...!!!";
if(prod >0 ){
Edit16->Text="";
Edit16->Text=AnsiString(r);
}
if(prod Text="";
Edit17->Text=AnsiString(r);
}
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button6Click(TObject *Sender)
{
Form3->Show();
Form3->Canvas->Pen->Color=clGreen;
Form3->Canvas->Pen->Width=2;
Form3->Canvas->PenPos=TPoint(0,350);
Form3->Canvas->LineTo(1300,350);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
14/313
Form3->Canvas->PenPos=TPoint(650,0);
Form3->Canvas->LineTo(650,700);
for(x=-30;xCanvas->PenPos=TPoint(650+x*10,355);
Form3->Canvas->LineTo(650+x*10,345);
for(y=-30;yCanvas->PenPos=TPoint(645,350+y*10);
Form3->Canvas->LineTo(655,350+y*10);
}
Form3->Canvas->Pen->Color=clYellow;
Form3->Canvas->Pen->Width=2;
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;xCanvas->LineTo(650+x,350-
10*(a*pow(x/10,4)+b*pow(x/10,3)+c*pow(x/10,2)+d*x/10+e));
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button4Click(TObject *Sender)
{
a=0;
b=0;
c=0;
8/18/2019 Manual de teoria y codigos de metodos numericos C++
15/313
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="";
8/18/2019 Manual de teoria y codigos de metodos numericos C++
16/313
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";
Label13->Caption="";
Label15->Caption="";
Label16->Caption="";
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button5Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
17/313
Còdigo de programaciòn:
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit3.h"
//---------------------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
TForm3 *Form3;
//---------------------------------------------------------------------------
__fastcall TForm3::TForm3(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm3::Button1Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
18/313
El método de Newton (también llamadoMé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 l a recta tangente que
pasa por ese punto”.
Para esto se toma la recta tangente a la función en un punto próximo a lasolució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:
2. Método de Newton - Raphson
8/18/2019 Manual de teoria y codigos de metodos numericos C++
19/313
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).
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
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.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
20/313
o Cuando se encuentran un punto crítico o de inflexión, debido a al valorinicial X, donde se tendría una división por cero, o debido a la naturaleza
de la función.
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 yvelocidad 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.
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.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
21/313
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”.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
22/313
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 derivadaevaluada, 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 ala grafica normal.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
23/313
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
8/18/2019 Manual de teoria y codigos de metodos numericos C++
24/313
13.Imprimir los resultados.
CÓDIGO DE PROGRAMACIÓN.
UNIT 1.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
//Incluyendo a los “Unit 2 y 8”
#include "Unit1.h"
#include "Unit2.h"
#include "Unit8.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm" TForm1 *Form1;
//---------------------------------------------------------------------------
fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
25/313
void fastcall TForm1::Button1Click(TObject *Sender)
{
//Vinculación del interfaz 1 a la 2
Form2->Show();
}
//---------------------------------------------------------------------------
void fastcall TForm1::Button2Click(TObject *Sender)
{
//Botón que cierra el programa por completo
Close();
}
//---------------------------------------------------------------------------
UNIT 2.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
//Incuyendo los “Unit del 3 al 7”
#include "Unit2.h"
#include "Unit3.h"
#include "Unit4.h"
#include "Unit5.h"
#include "Unit6 h"
8/18/2019 Manual de teoria y codigos de metodos numericos C++
26/313
#include "Unit7.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
//Incluyendo el diccionario matemático
#include
//Declarando variables double
double a, b, c, d, e, xn, it, da, db, dc, dd, de,x,y; double xn1, re, err, n, s,fx, dfx,
y1,y2,y3,y4,y5,y6,y7 ;
TForm2 *Form2;
//---------------------------------------------------------------------------
fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void fastcall TForm2::Button4Click(TObject *Sender)
{
//Botón que cierra el interfaz 2
Close();
}
8/18/2019 Manual de teoria y codigos de metodos numericos C++
27/313
//---------------------------------------------------------------------------
void fastcall TForm2::Button3Click(TObject *Sender)
{
// Programando Reset
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Label10->Caption="";
RadioGroup1->Enabled=false;
Button2->Enabled=false;
RadioGroup1->ItemIndex=-1;
Edit1->SetFocus();
}
//---------------------------------------------------------------------------
void fastcall TForm2::Button1Click(TObject *Sender)
{
8/18/2019 Manual de teoria y codigos de metodos numericos C++
28/313
//Habilitar Graficas y Tabla de Iteraciones
RadioGroup1->Enabled=true;
Button2->Enabled=true;
//Leer los datos
a=Edit1->Text.ToDouble();
b=Edit2->Text.ToDouble();
c=Edit3->Text.ToDouble();
d=Edit4->Text.ToDouble();
e=Edit5->Text.ToDouble();
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();
Form3->Memo2->Clear();
8/18/2019 Manual de teoria y codigos de metodos numericos C++
29/313
Form3->Memo3->Clear();
Form3->Memo4->Clear();
Form3->Memo5->Clear();
Form3->Memo6->Clear();
Form3->Memo7->Clear();
//Habilitar gráfica y Tabla de Iteraciones.
RadioGroup1->Enabled=true;
Button2->Enabled=true;
//Iniciando el número de Iteraciones
for(n=1;nMemo1->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;
8/18/2019 Manual de teoria y codigos de metodos numericos C++
30/313
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;
8/18/2019 Manual de teoria y codigos de metodos numericos C++
31/313
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)
{
//Escribiendo la raiz
Label10->Caption=AnsiString(xn);
}
xn=xn1;
}
}
}
//---------------------------------------------------------------------------
void fastcall TForm2::Button2Click(TObject *Sender)
8/18/2019 Manual de teoria y codigos de metodos numericos C++
32/313
8/18/2019 Manual de teoria y codigos de metodos numericos C++
33/313
Form4->Canvas->PenPos=TPoint(650+x*10,355);
Form4->Canvas->LineTo(650+x*10,345);
}
for(y=-35;yCanvas->PenPos=TPoint(645,350+y*10);
Form4->Canvas->LineTo(655,350+y*10);
}
Form4->Canvas->Pen->Color=clBlue;
Form4->Canvas->Pen->Width=2;
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;xCanvas->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
if(RadioGroup1->ItemIndex==1)
8/18/2019 Manual de teoria y codigos de metodos numericos C++
34/313
Form5->Show();
Form5->Canvas->Pen->Color=clBlack; Form5->Canvas->Pen->Width=1;
Form5->Canvas->PenPos=TPoint(0,350);
Form5->Canvas->LineTo(1300,350);
Form5->Canvas->PenPos=TPoint(650,0);
Form5->Canvas->LineTo(650,700);
for(x=-32;xCanvas->PenPos=TPoint(650+x*20,355);
Form5->Canvas->LineTo(650+x*20,345);
}
for(y=-17;yCanvas->PenPos=TPoint(645,350+y*20);
Form5->Canvas->LineTo(655,350+y*20);
}
Form5->Canvas->Pen->Color=clBlue;
Form5->Canvas->Pen->Width=2;
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));
8/18/2019 Manual de teoria y codigos de metodos numericos C++
35/313
for(x=-650;xCanvas->LineTo(650+x,350-
20*(a*pow(x/20,4)+b*pow(x/20,3)+c*pow(x/20,2)
+d*x/20+e));
}
//Grafica MEGAZOOM
if(RadioGroup1->ItemIndex==2)
{
Form6->Show();
Form6->Canvas->Pen->Color=clBlack;
Form6->Canvas->Pen->Width=1;
Form6->Canvas->PenPos=TPoint(0,350);
Form6->Canvas->LineTo(1300,350);
Form6->Canvas->PenPos=TPoint(650,0);
Form6->Canvas->LineTo(650,700);
}
for(x=-16;xCanvas->PenPos=TPoint(650+x*40,355);
Form6->Canvas->LineTo(650+x*40,345);
}
8/18/2019 Manual de teoria y codigos de metodos numericos C++
36/313
for(y=-8;yCanvas->PenPos=TPoint(645,350+y*40);
Form6->Canvas->LineTo(655,350+y*40);
}
Form6->Canvas->Pen->Color=clBlue;
Form6->Canvas->Pen->Width=2;
x=-650;
Form6->Canvas->PenPos=TPoint(650+x,350-
40*(a*pow(x/40,4)+b*pow(x/40,3)+c*pow(x/40,2)
+d*x/40+e));
for(x=-650;xCanvas->LineTo(650+x,350-
40*(a*pow(x/40,4)+b*pow(x/40,3)+c*pow(x/40,2)
+d*x/40+e));
}
}
//---------------------------------------------------------------------------
UNIT 3.
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
37/313
#include
#pragma hdrstop
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm" TForm3 *Form3;
//---------------------------------------------------------------------------
fastcall TForm3::TForm3(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void fastcall TForm3::Button1Click(TObject *Sender)
{
//Botón cerrar
Close();
}
//--------------------------------------------------------------------------
UNIT 4.
//---------------------------------------------------------------------------
#include
8/18/2019 Manual de teoria y codigos de metodos numericos C++
38/313
#pragma hdrstop
#include "Unit4.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm" TForm4 *Form4;
//---------------------------------------------------------------------------
fastcall TForm4::TForm4(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void fastcall TForm4::Button1Click(TObject *Sender)
{
//Botón cerrar
Close();
}
//---------------------------------------------------------------------------
UNIT 5.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit5.h"
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
39/313
#pragma package(smart_init)
#pragma resource "*.dfm" TForm5 *Form5;
//---------------------------------------------------------------------------
fastcall TForm5::TForm5(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void fastcall TForm5::Button1Click(TObject *Sender)
{
//Botón cerrar
Close();
}
//---------------------------------------------------------------------------
UNIT 6.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit6.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm" TForm6 *Form6;
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
40/313
fastcall TForm6::TForm6(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void fastcall TForm6::Button1Click(TObject *Sender)
{
//Botón cerrar
Close();
}
//------------------------------------------------------------------------
UNIT 7.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit7.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm" TForm7 *Form7;
//---------------------------------------------------------------------------
fastcall TForm7::TForm7(TComponent* Owner)
: TForm(Owner)
{
}
8/18/2019 Manual de teoria y codigos de metodos numericos C++
41/313
//---------------------------------------------------------------------------
UNIT 8.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit8.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm" TForm8 *Form8;
//---------------------------------------------------------------------------
fastcall TForm8::TForm8(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void fastcall TForm8::Button1Click(TObject *Sender)
{
//Botón cerrar
Close();
}
//---------------------------------------------------------------------------
De esta manera es como se programa el Método de Newton – Raphson en
leguaje C++.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
42/313
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 posiblefactorizar 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.
3. Método de Ferrari: Solución deecuaciones de cuarto grado.
http://www.google.com.mx/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&uact=8&ved=0CAcQjRw&url=http://www.juntadeandalucia.es/averroes/iesarroyo/matematicas/materiales/4eso/funciones/teoriafuncioncuadratica/teoriafunciones.htm&ei=X8FgVL2XO8irjALfqICwBQ&bvm=bv.79189006,d.eXY&psig=AFQjCNFtIAh6RmjDwNTiKS7uFT3SViw5Qg&ust=1415713292402067
8/18/2019 Manual de teoria y codigos de metodos numericos C++
43/313
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:
8/18/2019 Manual de teoria y codigos de metodos numericos C++
44/313
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 √( ²/4) d
8/18/2019 Manual de teoria y codigos de metodos numericos C++
45/313
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:
8/18/2019 Manual de teoria y codigos de metodos numericos C++
46/313
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 deun polinomio de cuarto grado.
Botón “Salir”:
El botón cierra por completo el programa.
Línea de Programación:
#include
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm" TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner) { }
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form2->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Close();
}
8/18/2019 Manual de teoria y codigos de metodos numericos C++
47/313
//---------------------------------------------------------------------------
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.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
48/313
Línea de Programación:
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
#include
#include
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;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button1Click(TObject *Sender)
{
A=Edit1->Text.ToDouble();
B=Edit2->Text.ToDouble();
C=Edit3->Text.ToDouble();
D=Edit4->Text.ToDouble();
E=Edit5->Text.ToDouble();
8/18/2019 Manual de teoria y codigos de metodos numericos C++
49/313
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
8/18/2019 Manual de teoria y codigos de metodos numericos C++
50/313
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;
8/18/2019 Manual de teoria y codigos de metodos numericos C++
51/313
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);
Edit8->Text=AnsiString(x2);
Edit9->Text=AnsiString(y2);
}
if(Dis1>0)
{
x1=-u/2*i+sqrt(Dis1)/(2*i);
x2=-u/2*i-sqrt(Dis1)/(2*i);
y1=0;
y2=0;
8/18/2019 Manual de teoria y codigos de metodos numericos C++
52/313
Edit6->Text=AnsiString(x1);
Edit7->Text=AnsiString(y1);
Edit8->Text=AnsiString(x2);
Edit9->Text=AnsiString(y2);
}
if(Dis1>0&&u!=0)
{
x1=-u/2*i;
x2=-u/2*i;
y1=sqrt(-Dis1)/(2*i);
y2=-sqrt(-Dis1)/(2*i);
Edit6->Text=AnsiString(x1);
Edit7->Text=AnsiString(y1);
Edit8->Text=AnsiString(x2);
Edit9->Text=AnsiString(y2);
}
if(Dis1Text=AnsiString(x1);
Edit7->Text=AnsiString(y1);
Edit8->Text=AnsiString(x2);
Edit9->Text=AnsiString(y2);
}
Dis2=(w*w)-(4*i*z);
if(Dis2==0)
{
x3=-w/2*i;
x4=x3;
y3=0;
y4=0;
8/18/2019 Manual de teoria y codigos de metodos numericos C++
53/313
Edit10->Text=AnsiString(x3);
Edit11->Text=AnsiString(y3);
Edit12->Text=AnsiString(x4);
Edit13->Text=AnsiString(y4);
}
if(Dis2>0)
{
x3=-w/2*i+sqrt(Dis2)/(2*i);
x4=-w/2*i-sqrt(Dis2)/(2*i);
y3=0;
y4=0;
Edit10->Text=AnsiString(x3);
Edit11->Text=AnsiString(y3);
Edit12->Text=AnsiString(x4);
Edit13->Text=AnsiString(y4);
}
if(Dis2>0&&w!=0)
{
x3=-w/2*i;
x4=-w/2*i;
y3=sqrt(-Dis2)/(2*i);
y4=-sqrt(-Dis2)/(2*i);
Edit10->Text=AnsiString(x3);
Edit11->Text=AnsiString(y3);
Edit12->Text=AnsiString(x4);
Edit13->Text=AnsiString(y4);
}
if(Dis2Text=AnsiString(x3);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
54/313
Edit11->Text=AnsiString(y3);
Edit12->Text=AnsiString(x4);
Edit13->Text=AnsiString(y4);
}
}
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;
Edit6->Text=AnsiString(x1);
Edit7->Text=AnsiString(y1);
Edit8 >Text=AnsiString(x2);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
55/313
Edit9->Text=AnsiString(y2);
}
if(Dis3>0)
{
x1=-u/2*i+sqrt(Dis3)/(2*i);
x2=-u/2*i-sqrt(Dis3)/(2*i);
y1=0;
y2=0;
Edit6->Text=AnsiString(x1);
Edit7->Text=AnsiString(y1);
Edit8->Text=AnsiString(x2);
Edit9->Text=AnsiString(y2);
}
if(Dis3>0&&u!=0)
{
x1=-u/2*i;
x2=-u/2*i;
y1=sqrt(-Dis3)/(2*i);
y2=-sqrt(-Dis3)/(2*i);
Edit6->Text=AnsiString(x1);
Edit7->Text=AnsiString(y1);
Edit8->Text=AnsiString(x2);
Edit9->Text=AnsiString(y2);
}
if(Dis3Text=AnsiString(x1);
Edit7->Text=AnsiString(y1);
Edit8->Text=AnsiString(x2);
Edit9 >Text=AnsiString(y2);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
56/313
}
Dis4=(w*w)-(4*i*z);
if(Dis4==0)
{
x3=-w/2*i;
x4=x3;
y3=0;
y4=0;
Edit10->Text=AnsiString(x3);
Edit11->Text=AnsiString(y3);
Edit12->Text=AnsiString(x4);
Edit13->Text=AnsiString(y4);
}
if(Dis4>0)
{
x3=-w/2*i+sqrt(Dis4)/(2*i);
x4=-w/2*i-sqrt(Dis4)/(2*i);
y3=0;
y4=0;
Edit10->Text=AnsiString(x3);
Edit11->Text=AnsiString(y3);
Edit12->Text=AnsiString(x4);
Edit13->Text=AnsiString(y4);
}
if(Dis4>0&&w!=0)
{
x3=-w/2*i;
x4=-w/2*i;
y3=sqrt(-Dis4)/(2*i);
y4=-sqrt(-Dis4)/(2*i);
Edit10->Text=AnsiString(x3);
Edit11->Text=AnsiString(y3);
Edit12->Text=AnsiString(x4);
Edit13 >Text=AnsiString(y4);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
57/313
}
if(Dis4Text=AnsiString(x3);
Edit11->Text=AnsiString(y3);
Edit12->Text=AnsiString(x4);
Edit13->Text=AnsiString(y4);
}
}
}
else
{
if(A==0)
{
Label13->Caption="No se puede realizar,es una ecuación cúbica!!";
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button2Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
58/313
Este es un método para encontrar las raíces de ecuaciones polinomialescon raíces múltiples, de la forma general:
n
nn xa xa xaa x f .......)( 2
210
aDonde n es el orden del polinomio y las 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 ométodo de Newton Raphson, el cual obtiene raíces, estimando una proyecciónde 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 trespuntos para calcular la parábola, en otras palabras, proyecta una parábola através de tres puntos (Figura 2).
El método consiste en obtener los coeficientes de la parábola que pasapor tres puntos elegidos, dichos coeficientes son sustituidos en la fórmulacuadrá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 laecuación de la parábola en una forma conveniente .En forma conveniente estasería:
c x xb x xa x f )()()( 22
22 Ec.1
Una de las mayores ventajas de este método, es que al trabajar con lafórmula cuadrática es posible localizar tanto raíces reales como raícescomplejas.
4. Método de Müller
8/18/2019 Manual de teoria y codigos de metodos numericos C++
59/313
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, lassoluciones 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
8/18/2019 Manual de teoria y codigos de metodos numericos C++
60/313
¡NOTA!
El Teorema fundamental del Álgebra nos dice que: El número de factores enque se puede descomponer un polinomio es igual al grado del polinomio, esdecir: Todo polinomio de grado n tiene n raíces.
.Por tanto, en nuestra programación, únicamente podremos encontrarraíces de un polinomio hasta grado 4, esto quiere decir que el número deraíces encontradas será equivalente al número de grado del polinomio queestemos 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 unplanocartesiano esto lo identificamos como las intersecciones de la gráfica delpolinomio con el eje de las X (abscisas). Esto es, los puntos en donde cruza lagráfica al eje horizontal tienen como abscisa la raíz del polinomio graficado.
A continuación presentamos algunas funciones con sus raíces, factores ygráficas:
Función Raíces Factorización Gráfica
f(x)=x2 + x
- 12
- 4 y 3 f(x) = (x +4) (x - 3)
f(x)=x3 - 4
x2 + x+ 6
- 1, 2 y3
f(x) = (x +1) (x - 2) (x
- 3)
http://dinamica1.fciencias.unam.mx/Preparatoria8/polinomi/#fundamentalhttp://dinamica1.fciencias.unam.mx/Preparatoria8/polinomi/#fundamentalhttp://dinamica1.fciencias.unam.mx/Preparatoria8/polinomi/#fundamental
8/18/2019 Manual de teoria y codigos de metodos numericos C++
61/313
f(x)=x4 - 5
x2 + 4
- 2, - 1,1 y 2
f(x) = (x +1) (x + 2) (x- 1) (x - 2)
f(x)=x3 + 4x2 + 3
x
¿Cuálesson?
f(x) =
Consideremos ahora otro caso en particular, expresando una función medianteel cociente de polinomios
Ejemplo:
Si la función con la que se trabaja es un cociente de polinomios, estosdeberán ser reducidos a la mínima expresión con el objetivo de simplificar sumanejo. Dicha simplificación se lleva a cabo eliminando factores comunes, y latarea de encontrar dichos factores está estrechamente ligada al cálculo de lasraí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
8/18/2019 Manual de teoria y codigos de metodos numericos C++
62/313
8/18/2019 Manual de teoria y codigos de metodos numericos C++
63/313
¿CÓMO CALCULAR LA PARÁBOLA?
1. Para esto necesitaremos de tres puntos, (), , () , ().
2. La aproximación la podemos escribir como:
c x xb x xa x f )()()( 22
22
3. Los coeficientes de la ecuación 1, es decir, de laparábola los calculamos resolviendo el siguiente sistemade ecuaciones.
y x
FORMULAS
a utilizar
ℎ
ℎ ()−()
− ()−()
−
−
y = x^(3)+x
x
y
y = xxx-4xx+5x
Las raíces de la
función son:
X= 0, x=i, x=-i
Las raíces de la
función son:
X= 0, x=2+i, x=2-i
8/18/2019 Manual de teoria y codigos de metodos numericos C++
64/313
8/18/2019 Manual de teoria y codigos de metodos numericos C++
65/313
−± − -Despejando- −± −
En el den ominador se escoge el signo que coincida con el signo de “b”,
esta elección prop orcio na com o resultado el denomin ador más gran de , loque dará la raíz estimada más cercana a x3.
Es decir, si 4 > 4
Se escoge 4 Si no, se escoge: 4
9. Se prosigue a calcular el error, este será:
− . 100 %[Fórmula para calcular el margen de error]
10. Si pretendemos iterar, es decir, una vez que se determinó x3 el proceso serepetirá, esto con el fin de tener una mayor aproximación a la raíz X3, por locual esto traerá de que un valor es descartado.
Al ser un método de aproximación, este se realiza de forma secuencial eiterativamente, donde , remplazan los puntos , , llevando elerror 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étod o d e Müller se esc oge el sign o q ue co inc ida co n el
signo de “b”, esta elección proporciona como resultado el
denom inad or más gran de , lo que dará la raíz estimada más cercana ax2. Una vez que se determinó x3 el proceso se repite, esto trae de queun valor es descartado.
ESTRATEGIAS COMÚNMENTE USADAS
8/18/2019 Manual de teoria y codigos de metodos numericos C++
66/313
Si sólo se localizan raíces reales, elegimos los dos valores originalesmá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 ahoraencontrar las raíces de f´´(x).
EJEMPLOS: Obtén las raíces de los polinomios mediante el método de Müller.
1) () 13 12 ; 4.5, 5.5, 5
(4.5) (4.5) 13(4.5) 1 2 . (5.5) (5.5) 13(5.5) 1 2 .
(5) (5) 13(5) 1 2
ℎ 5.54.5 ℎ 5 5 . 5 .
82.87520.6251 . 4882.8751 2
.
.−. 1 5 1269.75 .
Coeficientes de la parábola
8/18/2019 Manual de teoria y codigos de metodos numericos C++
67/313
Puesto que b es positivo, entonces, respecto al signo ± ubicado en eldenominador, elegiré :
∴ 5 2(48)62.25± (62.25) 4(15)(48) 3.976487042
3.97648704253.976487042 . 100 %
25.73912469 %
¿COMO OBTENER LAS OTRAS DOS RAICES FALTANTES?
Puesto que mi polinomio es de tercer orden, y ya se obtuvo una de tresraíces, entonces puedo dividir a mi ecuación polinomial 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 lasraíces de un polinomio grado dos es prácticamente sencillo.
Efectuando división sintética
1 0 13 12 | á:4 16 12 | 4 4 3 ________________________|________ 1 4 3 0 |
8/18/2019 Manual de teoria y codigos de metodos numericos C++
68/313
Obteniendo raíces de 4 3 : , 4 ± 4 4(1)(3)2(1) 1, 3
Ilustración grafica de () 13 12 y sus respectivas raices.
, ± 42
FORMULA
8/18/2019 Manual de teoria y codigos de metodos numericos C++
69/313
PROGRAMACION
Programando Form 1
-
//---------------------------------------------------------------------------#include #pragma hdrstop
#include "Unit1.h"#include "Unit2.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner)
{
}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){Form2->Show();Form1->Visible=false; /*--------------ENTRAR--------------*/
}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){Close(); /*--------------SALIR--------------*/
}//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
70/313
Programando Form 2
//---------------------------------------------------------------------------#include #include #pragma hdrstop
#include "Unit1.h"#include "Unit2.h"#include "Unit3.h"//--------------------------------------------------------------------------- #pragma package(smart_init)#pragma resource "*.dfm"doublea,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;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm2::Button1Click(TObject *Sender){Label3->Caption="";Label4->Caption="";
Label5->Caption="";
8/18/2019 Manual de teoria y codigos de metodos numericos C++
71/313
if(Er>=0.00000000000001){a=Edit1->Text.ToDouble();
b=Edit2->Text.ToDouble();c=Edit3->Text.ToDouble();
d=Edit4->Text.ToDouble();e=Edit5->Text.ToDouble();x0=Edit6->Text.ToDouble();x1=Edit7->Text.ToDouble();x2=Edit8->Text.ToDouble();
fx0=a*pow(x0,4)+b*pow(x0,3)+c*pow(x0,2)+d*x0+e;
fx1=a*pow(x1,4)+b*pow(x1,3)+c*pow(x1,2)+d*x1+e;
fx2=a*pow(x2,4)+b*pow(x2,3)+c*pow(x2,2)+d*x2+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(DCaption="posiblemente la función solo tenga raicesimaginarias,grafica y prueba nuevosvalores de x1,x2,x3!";}
else
{z=pow(D,0.5);x3=x2-(2*C)/(B+z);w=(x3-x2)/x3;Edit8->Text=AnsiString(x3);
if(wText=AnsiString(x1);Edit7->Text=AnsiString(x2);
Edit9->Text=AnsiString(x3);Edit15->Text=AnsiString(Er); }}}
else {Label4->Caption="EL ERROR es cero,¡¿Que mas quieres?!";}}
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
72/313
void __fastcall TForm2::Button10Click(TObject *Sender){Close(); /*--------------SALIR--------------*/}//---------------------------------------------------------------------------void __fastcall TForm2::Button2Click(TObject *Sender){Label3->Caption="";Label4->Caption="";Label5->Caption="";
if(ER>=0.00000000000001){
b=Edit2->Text.ToDouble();c=Edit3->Text.ToDouble();/*--------------R2--------------*/d=Edit4->Text.ToDouble();e=Edit5->Text.ToDouble();x0=Edit6->Text.ToDouble();
x1=Edit7->Text.ToDouble();x2=Edit8->Text.ToDouble();fx0=b*pow(x0,3)+c*pow(x0,2)+d*x0+e;fx1=b*pow(x1,3)+c*pow(x1,2)+d*x1+e;
fx2=b*pow(x2,3)+c*pow(x2,2)+d*x2+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(DCaption="posiblemente la función solo tenga raicesimaginarias,grafica y prueba nuevosvalores de x1,x2,x3!";}
if(D>=0)
{z=pow(D,0.5);x3=x2-(2*C)/(B+z);
w=(x3-x2)/x3;Edit8->Text=AnsiString(x3);
w=(x3-x2)/x3;if(wText=AnsiString(x1);Edit7->Text=AnsiString(x2);Edit8->Text=AnsiString(x3);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
73/313
Edit10->Text=AnsiString(x3);Edit16->Text=AnsiString(ER); }}}else {Label4->Caption="!EL ERROR YA ES CERO!";}}
//---------------------------------------------------------------------------void __fastcall TForm2::Button3Click(TObject *Sender){
Label3->Caption="";Label4->Caption="";Label5->Caption="";a=Edit3->Text.ToDouble();
b=Edit4->Text.ToDouble();
c=Edit5->Text.ToDouble();
D=b*b-4*a*c;if(DText=AnsiString(x1);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);}}
//---------------------------------------------------------------------------void __fastcall TForm2::Button4Click(TObject *Sender){Label3->Caption="";Label4->Caption="";Label5->Caption="";a=Edit3->Text.ToDouble();
b=Edit4->Text.ToDouble();
c=Edit5->Text.ToDouble();
D=b*b-4*a*c; /*--------------R4--------------*/if(DText=AnsiString(x1);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);}
8/18/2019 Manual de teoria y codigos de metodos numericos C++
74/313
else{D=-D;r=pow(D,0.5);rx1=(-b)/(2*a);
lxl=D/(2*a);Edit12->Text=AnsiString(rx1);}}
//---------------------------------------------------------------------------void __fastcall TForm2::Button5Click(TObject *Sender){Label3->Caption="";Label4->Caption="";Label5->Caption="";a=Edit1->Text.ToDouble();
b=Edit2->Text.ToDouble();c=Edit3->Text.ToDouble();d=Edit4->Text.ToDouble();e=Edit5->Text.ToDouble();
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);Edit4->Text=AnsiString(r);Edit5->Text=AnsiString(u);}//---------------------------------------------------------------------------void __fastcall TForm2::Button6Click(TObject *Sender){Label3->Caption="";Label4->Caption="";Label5->Caption="";a=Edit2->Text.ToDouble();
b=Edit3->Text.ToDouble();c=Edit4->Text.ToDouble();d=Edit5->Text.ToDouble();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";
8/18/2019 Manual de teoria y codigos de metodos numericos C++
75/313
Edit4->Text=AnsiString(p);Edit5->Text=AnsiString(r);}//---------------------------------------------------------------------------void __fastcall TForm2::Button7Click(TObject *Sender){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();}
//---------------------------------------------------------------------------void __fastcall TForm2::Button8Click(TObject *Sender){Form3->Show(); /*--------------GRAFICAR--------------*/Close();}//---------------------------------------------------------------------------void __fastcall TForm2::Button9Click(TObject *Sender){Form1->Show(); /*--------------INICIO-------------*/Close();
}//---------------------------------------------------------------------------
Programando Form 3
8/18/2019 Manual de teoria y codigos de metodos numericos C++
76/313
//---------------------------------------------------------------------------#include #include #pragma hdrstop
#include "Unit1.h"#include "Unit2.h"#include "Unit3.h"//---------------------------------------------------------------------------
#pragma package(smart_init)#pragma resource "*.dfm"
double a,b,c,d,e,x,y,av,pri,seg;TForm3 *Form3;//---------------------------------------------------------------------------
__fastcall TForm3::TForm3(TComponent* Owner)
: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm3::Button1Click(TObject *Sender){Canvas->PenPos=TPoint(160,320);Canvas->LineTo(800,320);Canvas->PenPos=TPoint(480,400);Canvas->LineTo(480,80);Canvas->PenPos=TPoint(500,310);Canvas->LineTo(500,330);Canvas->PenPos=TPoint(520,310);
Canvas->LineTo(520,330);Canvas->PenPos=TPoint(540,310);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
77/313
Canvas->PenPos=TPoint(560,310);Canvas->LineTo(560,330);Canvas->PenPos=TPoint(580,310);Canvas->LineTo(580,330);Canvas->PenPos=TPoint(600,310);Canvas->LineTo(600,330);Canvas->PenPos=TPoint(620,310);Canvas->LineTo(620,330);Canvas->PenPos=TPoint(640,310);Canvas->LineTo(640,330);Canvas->PenPos=TPoint(660,310);Canvas->LineTo(660,330);Canvas->PenPos=TPoint(680,310);Canvas->LineTo(680,330);Canvas->PenPos=TPoint(700,310);Canvas->LineTo(700,330);Canvas->PenPos=TPoint(460,310);Canvas->LineTo(460,330);
Canvas->PenPos=TPoint(440,310);Canvas->LineTo(440,330);Canvas->PenPos=TPoint(420,310);Canvas->LineTo(420,330);Canvas->PenPos=TPoint(400,310);Canvas->LineTo(400,330);Canvas->PenPos=TPoint(380,310);
Canvas->LineTo(380,330);Canvas->PenPos=TPoint(360,310);
Canvas->LineTo(360,330);Canvas->PenPos=TPoint(340,310);Canvas->LineTo(340,330);Canvas->PenPos=TPoint(320,310);Canvas->LineTo(320,330);Canvas->PenPos=TPoint(300,310);Canvas->LineTo(300,330);Canvas->PenPos=TPoint(280,310);Canvas->LineTo(280,330);Canvas->PenPos=TPoint(470,120);Canvas->LineTo(490,120);Canvas->PenPos=TPoint(470,140);Canvas->LineTo(490,140);Canvas->PenPos=TPoint(470,300);Canvas->LineTo(490,300);Canvas->PenPos=TPoint(470,280);Canvas->LineTo(490,280);Canvas->PenPos=TPoint(470,260);Canvas->LineTo(490,260);Canvas->PenPos=TPoint(470,240);Canvas->LineTo(490,240);Canvas->PenPos=TPoint(470,220);Canvas->LineTo(490,220);
Canvas->PenPos=TPoint(470,200);Canvas->LineTo(490,200);C P P TP i (470 180)
8/18/2019 Manual de teoria y codigos de metodos numericos C++
78/313
Canvas->LineTo(490,180);Canvas->PenPos=TPoint(470,160);Canvas->LineTo(490,160);
Label5->Caption="Y";
Label6->Caption="X";Label7->Caption="2";Label8->Caption="4";Label9->Caption="6";Label10->Caption="8";Label11->Caption="10";Label12->Caption="-2";Label13->Caption="-4";
Label14->Caption="-6";Label15->Caption="-8";Label16->Caption="-10";Label17->Caption="10";
a=Edit1->Text.ToDouble(); b=Edit2->Text.ToDouble();c=Edit3->Text.ToDouble();d=Edit4->Text.ToDouble();e=Edit5->Text.ToDouble();
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;priLineTo(480+x*20,320-y*20);}}//---------------------------------------------------------------------------void __fastcall TForm3::Button3Click(TObject *Sender)
{Form2->Show();/*--------------REGRESAR-------------*/Close();}//---------------------------------------------------------------------------void __fastcall TForm3::Button4Click(TObject *Sender){Form1->Close();/*--------------SALIR-------------*/Close();}//---------------------------------------------------------------------------
void __fastcall TForm3::Button2Click(TObject *Sender){Edit1 >Text="";
8/18/2019 Manual de teoria y codigos de metodos numericos C++
79/313
Edit2->Text="";Edit3->Text="";Edit4->Text="";/*--------------RESET-------------*/Edit5->Text="";
Label5->Caption="";
Label6->Caption="";Label7->Caption="";Label8->Caption="";Label9->Caption="";Label10->Caption="";Label11->Caption="";Label12->Caption="";Label13->Caption="";Label14->Caption="";Label15->Caption="";Label16->Caption="";
Label17->Caption="";
Edit1->SetFocus();}//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
80/313
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 cuatroincógnitas se escribe así:
a11x1 + a12x2 + a13x3 + a14x=b1a21x1 + a22x2 + a23x3 +a24x4=b2a31x1 + a32x2 + a33x3+a34x4=b3
Un sistema de m ecuaciones lineales en n incógnitas se puede abreviarescribiendo ú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 seemplea en matemáticas para denotar un arreglo rectangular de números. Lasmatrices 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 enreemplazar el sistema dado por un nuevo sistema que tenga el mismo conjuntosolución, pero que sea más fácil de resolver. Por lo general, este nuevosistema se obtiene en una serie de etapas, aplicando los siguientes tres tiposde operaciones.
1. Multiplicar una ecuación (o renglón) por una constante diferente de cero.
2. Intercambiar dos ecuaciones (renglones).
5. Solución de Ecuaciones Lineales por elmétodo de eliminación de Gauss.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
81/313
3. Sumar un múltiplo de una ecuación (renglón) a otra. Dado que losrenglones (líneas horizontales) de una matriz aumentada correspondena las ecuaciones del sistema asociado, estas tres operaciones equivalena las operaciones con renglones de la matriz aumentada.
8/18/2019 Manual de teoria y codigos de metodos numericos C++
82/313
SOLUCIÓN DE SISTEMA DE ECUACIONES LINEALES POR EL MÉTODODE ELIMINACION DE GAUSS
8/18/2019 Manual de teoria y codigos de metodos numericos C++
83/313
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
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
8/18/2019 Manual de teoria y codigos de metodos numericos C++
84/313
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form2->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
85/313
MENÚ DE SELECCIÓN DE NÚMERO DE INCOGNITAS DEL SISTEMA DEECUACIONES
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.2) 3 Incógnitas: Abre una nueva ventana para resolver sistemas de 3
incógnitas en específico.3) 4 Incógnitas: Abre una nueva ventana para resolver sistemas de 4
incógnitas en específico.4) 5 Incógnitas: Abre una nueva ventana para resolver sistemas de 5
incógnitas en específico.5) Salir: Cierra la ventana del Menú de selección.
PROGRAMACIÓN
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit2.h"
#include "Unit3.h"
#include "Unit4.h"
#include "Unit5.h"
#include "Unit6.h"
//---------------------------------------------------------------------------#pragma package(smart init)
8/18/2019 Manual de teoria y codigos de metodos numericos C++
86/313
#pragma resource "*.dfm"
TForm2 *Form2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button1Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button2Click(TObject *Sender)
{
Form3->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button3Click(TObject *Sender)
{
Form4->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button4Click(TObject *Sender)
{
8/18/2019 Manual de teoria y codigos de metodos numericos C++
87/313
Form5->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button5Click(TObject *Sender)
{
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
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
88/313
#include
#pragma hdrstop
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
double x1, y1, z1, x2, y2, z2, y3, z3;
TForm3 *Form3;
//---------------------------------------------------------------------------
__fastcall TForm3::TForm3(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm3::Button2Click(TObject *Sender)
{
x1= Edit1->Text.ToDouble();
y1= Edit2->Text.ToDouble();
z1= Edit3->Text.ToDouble();
x2= Edit4->Text.ToDouble();
y2= Edit5->Text.ToDouble();
z2= Edit6->Text.ToDouble();
8/18/2019 Manual de teoria y codigos de metodos numericos C++
89/313
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;
Label10->Caption=FormatFloat("0.###",x2);
Label11->Caption=FormatFloat("0.###",y2);
Label12->Caption=FormatFloat("0.###",z2);
x2=x1-x2;
y2=y1-y2;
z2=z1-z2;
if(y2
8/18/2019 Manual de teoria y codigos de metodos numericos C++
90/313
Label13->Caption=FormatFloat("0.###",x1);
Label14->Caption=FormatFloat("0.###",y1);
Label15->Caption=FormatFloat("0.###",z1);
Label16->Caption=FormatFloat("0.###",x2);
Label17->Caption=FormatFloat("0.###",y2);
Label18->Caption=FormatFloat("0.###",z2);
y3=y1*y2;
z3=y1*z2;
y1=y1-y3;
z1=z1-z3;
Label19->Caption=FormatFloat("0.###",x1);
Label20->Caption=FormatFloat("0.###",y1);
Label21->Caption=FormatFloat("0.###",z1);
Label22->Caption=FormatFloat("0.###",x2);
Label23->Caption=FormatFloat("0.###",y2);
Label24->Caption=FormatFloat("0.###",z2);
Label25->Caption="[";
Label26->Caption="]";
Label27->Caption="[";
Label28->Caption="]";
8/18/2019 Manual de teoria y codigos de metodos numericos C++
91/313
Label29->Caption="[";
Label30->Caption="]";
Label31->Caption="x1 -->";
Label32->Caption="x2 -->";
Label33->Caption="RESULTADO:";
Label35->Caption=FormatFloat("0.###",z1);
Label36->Caption=FormatFloat("0.###",z2);
}
//---------------------------------------------------------------------------
void __fastcall TForm3::Button1Click(TObject *Sender)
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit1->SetFocus();
Label7->Caption="";
Label8->Caption="";
Label9->Caption="";
Label10->Caption="";
8/18/2019 Manual de teoria y codigos de metodos numericos C++
92/313
Label11->Caption="";
Label12->Caption="";
Label13->Caption="";
Label14->Caption="";
Label15->Caption="";
Label16->Caption="";
Label17->Caption="";
Label18->Caption="";
Label19->Caption="";
Label20->Caption="";
Label21->Caption="";
Label22->Caption="";
Label23->Caption="";
Label24->Caption="";
Label25->Caption="";
Label26->Caption="";
Label27->Caption="";
Label28->Caption="";
Label29->Caption="";
Label30->Caption="";
Label31->Caption="";
Label32->Caption="";
Label33->Caption="";
Label35->Caption="";
Label36->Caption="";
}
//---------------------------------------------------------------------------
void __fastcall TForm3::Button3Click(TObject *Sender)
8/18/2019 Manual de teoria y codigos de metodos numericos C++
93/313
{
Close();
}
//---------------------------------------------------------------------------
INTERFAZ DE 3 INCÓGNITAS
Se compone de: 63-Label 3-Button 12-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 3 Incógnitas.
PROGRAMACIÓN
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit4.h"
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
94/313
8/18/2019 Manual de teoria y codigos de metodos numericos C++
95/313
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
8/18/2019 Manual de teoria y codigos de metodos numericos C++
96/313
{
c=c/x3;
z3=z3/x3;
y3=y3/x3;
x3=x3/x3;
}
Label13->Caption=FormatFloat("0.###",x1);
Label14->Caption=FormatFloat("0.###",y1);
Label15->Caption=FormatFloat("0.###",z1);
Label16->Caption=FormatFloat("0.###",a);
Label17->Caption=FormatFloat("0.###",x2);
Label18->Caption=FormatFloat("0.###",y2);
Label19->Caption=FormatFloat("0.###",z2);
Label20->Caption=FormatFloat("0.###",b);
Label21->Caption=FormatFloat("0.###",x3);
Label22->Caption=FormatFloat("0.###",y3);
Label23->Caption=FormatFloat("0.###",z3);
Label24->Caption=FormatFloat("0.###",c);
if(x2==0)
{
y2=y2;
z2=z2;
b=b;
}
8/18/2019 Manual de teoria y codigos de metodos numericos C++
97/313
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;
}
8/18/2019 Manual de teoria y codigos de metodos numericos C++
98/313
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;
}
Label25->Caption=FormatFloat("0.###",x1);
Label26->Caption=FormatFloat("0.###",y1);
Label27->Caption=FormatFloat("0.###",z1);
Label28->Caption=FormatFloat("0.###",a);
Label29->Caption=FormatFloat("0.###",x2);
Label30->Caption=FormatFloat("0.###",y2);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
99/313
Label31->Caption=FormatFloat("0.###",y2);
Label32->Caption=FormatFloat("0.###",b);
Label33->Caption=FormatFloat("0.###",x3);
Label34->Caption=FormatFloat("0.###",y3);
Label35->Caption=FormatFloat("0.###",z3);
Label36->Caption=FormatFloat("0.###",c);
y3=y2-y3;
z3=z2-z3;
c=b-c;
c=c/z3;
z3=z3/z3;
Label37->Caption=FormatFloat("0.###",x1);
Label38->Caption=FormatFloat("0.###",y1);
Label39->Caption=FormatFloat("0.###",z1);
Label40->Caption=FormatFloat("0.###",a);
Label41->Caption=FormatFloat("0.###",x2);
Label42->Caption=FormatFloat("0.###",y2);
Label43->Caption=FormatFloat("0.###",z2);
Label44->Caption=FormatFloat("0.###",b);
Label45->Caption=FormatFloat("0.###",x3);
Label46->Caption=FormatFloat("0.###",y3);
Label47->Caption=FormatFloat("0.###",z3);
8/18/2019 Manual de teoria y codigos de metodos numericos C++
100/313
Label48->Caption=FormatFloat("0.###",c);
b=b-(z2*c);
a=a-(y1*b)-(z1*c);
Label49->Caption=FormatFloat("0.###",a);
Label50->Caption=FormatFloat("0.###",b);
Label51->Caption=FormatFloat("0.###",c);
Label54->Caption="x1 ->";
Label55->Caption="x2 ->";
Label56->Caption="x3 ->";
Label57->Caption="[";
Label58->Caption="]";
Label59->Caption="[";
Label60->Caption="]";
Label61->Caption="[";
Label62->Caption="]";
Label63->Caption="RESULTADO:";
}
//---------------------------------------------------------------------------
void __fastcall TForm4::Button3Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
8/18/2019 Manual de teoria y codigos de metodos numericos C++
101/313
void __fastcall TForm4::Button1Click(TObject *Sender)
{
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit1->SetFocus();
Label13->Caption="";
Label14->Caption="";
Label15->Caption="";
Label16->Caption="";
Label17->Caption="";
Label18->Caption="";
Label19->Caption="";
Label20->Caption="";
Label21->Caption="";
Label22->Caption="";
Label23->Caption="";
8/18/2019 Manual de teoria y codigos de metodos numericos C++
102/313
8/18/2019 Manual de teoria y codigos de metodos numericos C++
103/313
Label54->Caption="";
Label55->Caption="";
Label56->Caption="";
Label57->Caption="";
Label58->Caption="";
Label59->Caption="";
Label60->Caption="";
Label61->Caption="";
Label62->Caption="";
Label63->Caption="";
}
//---------------------------------------------------------------------------
INTERFAZ DE 4 INCÓGNITAS
Compuesto de: 117-Label 3-Button 20-Edit 1-Picture
8/18/2019 Manual de teoria y codigos de metodos numericos C++
104/313
1) Solución: Inicia el proceso de solución del sistema de ecuacioneslineales.
2) Borrar todo: Borra el proceso de triangulación y la solución del sistemaasí como la información en los Edit.
3) Salir: Cierra la Interfaz de 4 Incógnitas.
PROGRAMACIÓN
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit5.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
double a, b, c, d, x1, y1, z1, w1, x2, y2, z2, w2, x3, y3, z3, w3, x4, y4, z4, w4;
TForm5 *Form5;
//---------------------------------------------------------------------------
__fastcall TForm5::TForm5(TComponent* Owner)
: TForm(Owner)
{
}//---------------------------------------------------------------------------
void __fastcall TForm5::Button2Click(TObject *Sender)
{
x1= Edit1->Text.ToDouble();
y1= Edit2->Text.ToDouble();