Manual de teoria y codigos de metodos numericos C++

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”


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


3/313

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


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


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


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.


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


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:


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)


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;


Fx3=a*(pow(h,4))+ b*(pow(h,3))+c*(pow(h,2))+d*h+e;


12/313


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

}


13/313

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


{

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


}

}

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


{

Form3->Show();

Form3->Canvas->Pen->Color=clGreen;

Form3->Canvas->Pen->Width=2;

Form3->Canvas->PenPos=TPoint(0,350);

Form3->Canvas->LineTo(1300,350);


14/313



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;


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

}

}

}

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


{

a=0;

b=0;

c=0;


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


16/313

Edit14->Text="";

Edit15->Text="";

Edit16->Text="";

Edit17->Text="";

Edit18->Text="";

Edit19->Text="";

Edit20->Text="";

Label13->Caption="";



}

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


{

Close();

}

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


17/313

Còdigo de programaciòn:

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

#include

#pragma hdrstop

#include "Unit3.h"

//---------------------------------------------------------------------------#pragma package(smart_init)


TForm3 *Form3;

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

__fastcall TForm3::TForm3(TComponent* Owner)

: TForm(Owner)

{

}

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


{

Close();

}

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


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


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.


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.


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”.


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.


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


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 resource "*.dfm" TForm1 *Form1;

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

fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

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


25/313

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

#pragma hdrstop

//Incuyendo los “Unit del 3 al 7”

#include "Unit2.h"

#include "Unit3.h"

#include "Unit4.h"

#include "Unit5.h"

#include "Unit6 h"


26/313

#include "Unit7.h"

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



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

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


: TForm(Owner)

{

}

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


{

//Botón que cierra el interfaz 2

Close();

}


27/313

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


{

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

}

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


{


28/313

//Habilitar Graficas y Tabla de Iteraciones

RadioGroup1->Enabled=true;


//Leer los datos

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



29/313






//Habilitar gráfica y Tabla de Iteraciones.

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


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;


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;

}

}

}

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



32/313


33/313

Form4->Canvas->PenPos=TPoint(650+x*10,355);


}



}

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


34/313

Form5->Show();

Form5->Canvas->Pen->Color=clBlack; Form5->Canvas->Pen->Width=1;







}



}



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


35/313


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;






}



}


36/313



}



x=-650;

Form6->Canvas->PenPos=TPoint(650+x,350-


+d*x/40+e));



+d*x/40+e));

}

}

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

UNIT 3.

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


37/313

#include

#pragma hdrstop

#include "Unit3.h"

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



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


: TForm(Owner)

{

}

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


{

//Botón cerrar

Close();

}

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

UNIT 4.

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

#include


38/313

#pragma hdrstop

#include "Unit4.h"

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



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


: TForm(Owner)

{

}

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


{

//Botón cerrar

Close();

}

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

UNIT 5.

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

#include

#pragma hdrstop

#include "Unit5.h"

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


39/313



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


: TForm(Owner)

{

}

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


{

//Botón cerrar

Close();

}

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

UNIT 6.

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

#include

#pragma hdrstop

#include "Unit6.h"

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



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


40/313


: TForm(Owner)

{

}

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


{

//Botón cerrar

Close();

}

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

UNIT 7.

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

#include

#pragma hdrstop

#include "Unit7.h"

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



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


: TForm(Owner)

{

}


41/313

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

UNIT 8.

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

#include

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


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


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:


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


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:


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)


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


: TForm(Owner) { }

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


{

Form2->Show();

}

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


{

Close();

}


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.


48/313

Línea de Programación:

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

#include

#pragma hdrstop

#include "Unit1.h"

#include "Unit2.h"

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



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

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


: TForm(Owner)

{

}

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


{

A=Edit1->Text.ToDouble();

B=Edit2->Text.ToDouble();

C=Edit3->Text.ToDouble();

D=Edit4->Text.ToDouble();

E=Edit5->Text.ToDouble();


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


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;


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



}

if(Dis1>0)

{

x1=-u/2*i+sqrt(Dis1)/(2*i);

x2=-u/2*i-sqrt(Dis1)/(2*i);

y1=0;

y2=0;


52/313





}

if(Dis1>0&&u!=0)

{

x1=-u/2*i;

x2=-u/2*i;

y1=sqrt(-Dis1)/(2*i);

y2=-sqrt(-Dis1)/(2*i);





}

if(Dis1Text=AnsiString(x1);




}

Dis2=(w*w)-(4*i*z);

if(Dis2==0)

{

x3=-w/2*i;

x4=x3;

y3=0;

y4=0;


53/313





}

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;







}



54/313




}

}

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;



Edit8 >Text=AnsiString(x2);


55/313


}

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;







}




Edit9 >Text=AnsiString(y2);


56/313

}

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;






Edit13 >Text=AnsiString(y4);


57/313

}





}

}

}

else

{

if(A==0)

{

Label13->Caption="No se puede realizar,es una ecuación cúbica!!";

}

}

}

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


{

Close();

}

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


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


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


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


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


62/313


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


64/313


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


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


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 |


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


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

}//---------------------------------------------------------------------------


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;

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


: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm2::Button1Click(TObject *Sender){Label3->Caption="";Label4->Caption="";

Label5->Caption="";


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?!";}}

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


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


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



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



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


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


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


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


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


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)


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


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


Edit1->SetFocus();}//---------------------------------------------------------------------------


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.


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.


82/313

SOLUCIÓN DE SISTEMA DE ECUACIONES LINEALES POR EL MÉTODODE ELIMINACION DE GAUSS


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"

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



84/313


TForm1 *Form1;

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


: TForm(Owner)

{

}

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


{

Form2->Show();

}

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


{

Close();

}

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


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


86/313


TForm2 *Form2;

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


: TForm(Owner)

{

}

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


{

Close();

}

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


{

Form3->Show();

}

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


{

Form4->Show();

}

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


{


87/313

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

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


88/313

#include

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



z2= Edit6->Text.ToDouble();


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;




x2=x1-x2;

y2=y1-y2;

z2=z1-z2;

if(y2


90/313







y3=y1*y2;

z3=y1*z2;

y1=y1-y3;

z1=z1-z3;







Label25->Caption="[";

Label26->Caption="]";




91/313



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



92/313


























}

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



93/313

{

Close();

}

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


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"

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


94/313


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


96/313

{

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;

}


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;

}


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;

}








99/313







y3=y2-y3;

z3=z2-z3;

c=b-c;

c=c/z3;

z3=z3/z3;













100/313


b=b-(z2*c);

a=a-(y1*b)-(z1*c);




Label54->Caption="x1 ->";









Label63->Caption="RESULTADO:";

}

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


{

Close();

}

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


101/313


{

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













102/313


103/313











}

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


Compuesto de: 117-Label 3-Button 20-Edit 1-Picture


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"

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



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)

{

}//---------------------------------------------------------------------------


{



Documents

Manual de teoria y codigos de metodos numericos C++