Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Unidad 6 Sistemas de Ecuaciones No Lineales
Unidad 6 Sistemas de Ecuaciones No Lineales
MET O DO S N UME R IC O S
I N TEGRA N TES:
N AR C ISO SO T O ISAAC
DOCEN TE:
CA RERRA :
IN G EN IEIA EL EC T R IC A
Un sist e ma de e cu a cio ne s e s n o line a l, cua n do a l m enos
una de s us ec ua ci one s no es de pri me r gra do .
L a re so lu ción d e e st o s sist em a s se su e le ha ce r p or e l
m é todo de s us ti tuc i ón , p a ra e llo se gu ire m o s lo s sigu ie n t es
p a so s:
1 º S e de s pe ja una i nc ógni ta e n u n a d e la s e cu a cio n e s,
p ref e ren t em en t e en l a de pri me r grado .
y = 7 − x
2 º S e s us ti tu ye el va lo r d e la in cógn it a de sp e jad a en la
otr a e c uac i ón.
x 2 + (7 − x) 2 = 2 5
3 º Se res ue l ve l a e c ua ci ón re su lta nt e .
x2 + 49 − 14x + x2 = 25
2x2− 14x + 24 = 0
x2− 7x + 12 = 0
x = 3 y = 7 − 3 y = 4
x = 4 y = 7 − 4 y = 3
Los sistemas no lineales representan sistemas cuyo comportamiento no es
expresable como la suma de los comportamientos de sus descriptores. Más
formalmente, un sistema físico, matemático o de otro tipo es no lineal cuando las
ecuaciones de movimiento, evolución o comportamiento que regulan su
comportamiento son no lineales. En particular, el comportamiento de sistemas no
lineales no está sujeto al principio de superposición, como lo es un sistema lineal.
Las ecuaciones no lineales son mucho más complejas, y mucho más difíciles de
entender por la falta de soluciones simples superpuestas. Para las ecuaciones no
lineales las soluciones generalmente no forman un espacio vectorial y, en general,
no pueden ser superpuestas para producir nuevas soluciones. Esto hace el
resolver las ecuaciones mucho más difícil que en sistemas lineales.
ECUACIONES NO LINEALES ESPECIFICAS
y = x2 − 1
Sin embargo, los sistemas de ecuaciones no lineales son mucho más complejos.
Similarmente, ecuaciones diferenciales de primer orden no lineales, tal como:
dxu = u2
son fácilmente resueltas (en este caso por separación de variables). Las
ecuaciones diferenciales de orden superior, tales como:
[A][X]=[B]
𝑏1 − 𝑎12𝑥2 − 𝑎13𝑥3
𝑥1 =
𝑎11
(11.5a)
𝑏2 − 𝑎21𝑥1 − 𝑎23𝑥3
𝑥2 =
𝑎22
(11.5b)
𝑏3 − 𝑎31𝑥1 − 𝑎32𝑥2
𝑥2 =
𝑎33
(11.5c)
𝑥𝑖 𝑗 −𝑥𝑖 𝑗−1
│εa,i│= │ │
𝑥𝑖 𝑗
Para todas las i, donde j y j-1 son las interacciones actuales y previas.
SOLUCIÓN:
−19.3 − 0.1(2.616667) + 0
𝑥2 = = −2.794524
7
−19.3−0.1(2.990557)+0.3(7.005610)
𝑥2 = = −2.499625 │εt│=0.015%
7
71.4−0.3(2.990557)+0.2(−2.499625)
𝑥3 = = 7.000291 │εt│=0.0042%
10
El método es, por lo tanto, convergente hacia la solución real. Se puede aplicar
interacciones adicionales para mejorar los resultados. Sin embargo, en un
problema real, no se podría saber la respuesta correcta con anticipación. En
consecuencia, la ecuacion-811.6) provee un medio para estimar el error. Por
ejemplo, para x1,
2.990557−2.616667
│εa.1│= │ │100% = 12.5%
2.990557
Para x2 y x3, los errores estimados son │εa.2│=11.8% y │εa.3│= 0.076%. Observe
que, como cuando se determinaron las raíces de una ecuación simple,
formulaciones como la ecuación (11.6) proveen usualmente una valoración de
convergencia conservativa. Así, cuando ales formulaciones se cumplen, aseguran
que el resultado sea conocido con al menos la tolerancia especificada por εs.
ALGORITMO DE GAUSS-SEIDEL
A continuación el algoritmo:
DO i = 1,n
dummy = ai,i
DO j = 1,n
ai,j = ai,j/dummy
END DO
bi= bi/dummy
END DO
DO i = 1,n
sum = bi
DO j = 1,n
END DO
xi = sum
END DO
iter = 1
DO
sentinel = 1
DO i = 1,n
old = xi
sum = bi
DO j = 1,n
IF ≠ j THEN sum = sum – ai,j * xj
END DO
xi = lambda*sum + (1.-lambda)*old
IF ea › es THEN sentinel = o
END IF
ENDDO
iter = iter +1
END DO
END Gseid
#include <stdio.h>
#include <math.h>
#include <iostream.h>
#include <conio.h>
#define L 10
#define P L
float
A[L][P],MATRIZ[L][P],VECTOR[L],X[L],CX[L],C[L],RESULTADOS[L],tabla[1000];
float a, b, c, d, e, f;
int it,ini,n,x,y,z,cont=0;
void Gauss_Seidel(int n)
for(x=0;x<n;x++)
CX[x]=0;
X[x]=0;
for(y=0;y<n;y++)
cout<<"A["<<y<<"]["<<x<<"] = ";
cin>>e;
A[y][x]=e;
cin>>f;
C[y]=f;
int sum=0,cont=0,reglon=0;
for(int j=0;j<n;j++)
reglon=reglon+abs(A[i][j]);
if(reglon<=sum) cont++;
reglon=0;
int temp[L][P],H[P];
for(i=0;i<n;i++)
for(int j=i;j<n;j++)
int d,e;
d=abs(A[i][i]);
e=abs(A[j][i]);
if(d<e)
for(int z=0;z<n;z++)
temp[i][z]=A[i][z];
A[i][z]=A[j][z];
A[j][z]=temp[i][z];
H[i]=C[i];
H[j]=C[j];
C[i]=H[j];
C[j]=H[i];
i=0;
for(it=0;it<100;it++)
for(y=0;y<n;y++)
for(x=0;x<n;x++)
CX[y]-=(A[y][x]*X[x])/A[y][y];
CX[y]+=(C[y]/A[y][y]);
X[y]=CX[y];
i++;
}
}
void titulo(int n)
int o=10,i=1;
clrscr();
for(i=1;i<n+1;i++)
o=o+10;
gotoxy(o,3);
cout<<"X"<<i;
gotoxy(15,4);cout<<"--------------------------------------------";
void resultados()
int q=0,i=1,t=3,s=n,r=0;
int sw=0,w=0,ite=0,h=0;
while((sw==0)&&(w<20))
h=0;
while(h<n)
if(tabla[r]==tabla[r+s])
{
cont++;
if(cont==n)
sw=1;
r++;
s++;
h++;
ite++;
w++;
w=ite-1;
for(int j=0;j<w;j++)
t=t+2;
if((i%10==0))
textcolor(LIGHTRED+BLINK);
gotoxy(5,t-2);
getch();
textcolor(GREEN);
clrscr();
t=5;
titulo(n);
gotoxy(15,t);cout<<i<<"ø";
int y=20,z=0;
for(int r=0;r<n;r++)
gotoxy(y+z,t);cout<<tabla[q];
q++;
z=z+10;
i++;
void main()
textcolor(GREEN);
clrscr();
scanf("%d",&n);
Gauss_Seidel(n);
titulo(n);
resultados();
for(x=0;x<n;x++)
RESULTADOS[x]=X[x];
cout<<"\nX["<<x<<"]= "<<RESULTADOS[x];
getch();
𝑓(𝑥𝑖 )
𝑥𝑖+1 = 𝑥𝑖 −
𝑓′(𝑥𝑖 )
Se puede usar un planteamiento similar abierto para encontrar un óptimo de 𝑓(𝑥)
al definir una nueva función , 𝑔(𝑥) = 𝑓′(𝑥). Así, como el mismo valor óptimo de 𝑥 ∗
satisface ambos
𝑓 ′ (𝑥 ∗ ) = 𝑔(𝑥 ∗ ) = 0
Se puede usar lo siguiente
𝑓′(𝑥𝑖 )
𝑥𝑖+1 = 𝑥𝑖 −
𝑓′′(𝑥𝑖 )
Como una técnica para encontrar el mínimo o máximo de 𝑓(𝑥). Se debería
observar que esta ecuación puede también derivarse al escribir una serie de
Taylor de segundo orden para 𝑓(𝑥) e igualar a la derivada de la seria a cero. El
método de Newton es abierto y similar al de Newton – Raphson porque no
requiere de valores iniciales que contengan el óptimo. Además, también comparte
la desventaja de poder ser divergente. Por último, es una buena idea verificar que
la segunda derivada tenga usualmente el signo correcto para confirmar que la
técnica converge sobre el resultado deseado.
Gráficamente podemos
darnos una idea del
método de Newton –
Raphson de la siguiente
manera:
La función ƒ es mostrada
en azul y la línea tangente
en rojo. Vemos que xn+1 es
una mejor aproximación
que xn para la raíz x de la
función f.
Su principal desventaja en este caso sería lo costoso que pudiera ser hallar g(x) y
g'(x) si f(x) no es fácilmente derivable.
Por otro lado, la convergencia del método se demuestra cuadrática para el caso
más habitual en base a tratar el método como uno de punto fijo: si g'(r)=0, y g' '(r)
es distinto de 0, entonces la convergencia es cuadrática. Sin embargo, está sujeto
a las particularidades de estos métodos.
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.
𝑥2
Use el método de Newton para encontrar el máximo de: 𝑓(𝑥) = 2 𝑠𝑒𝑛 𝑥 −
10
con un valor inicial de 𝑥0 = 2.5
𝑥
𝑓 ′ (𝑥) = 2 cos 𝑥 −
5
1
𝑓 ′′ (𝑥) = −2 𝑠𝑒𝑛 𝑥 −
5
𝑥
2 cos 𝑥𝑖 −
𝑥𝑖+1 = 𝑥𝑖 − 5
1
−2 𝑠𝑒𝑛 𝑥𝑖 −
5
Al sustituir el valor inicial se obtiene:
0.995
2 cos 0.995 −
𝑥1 = 2.5 − 5 = 𝟎. 𝟗𝟗𝟓𝟎𝟖
1
−2 𝑠𝑒𝑛 0.995 −
5
La cual tiene un valor de la función de 1.57859. La segunda iteración da como
resultado:
0.995
2 cos 0.995 −
𝑥1 = 0.995 − 5 = 𝟏. 𝟒𝟔𝟗𝟎𝟏
1
−2 𝑠𝑒𝑛 0.995 −
5
Así dentro de las cuatro iteraciones, el resultado converge en forma rápida sobre
el valor verdadero
Sabemos que f '(x) = -sin(x) - 3x2. Ya que cos(x) ≤ 1 para todo x y x3 > 1 para x>1,
deducimos que nuestro cero está entre 0 y 1. Comenzaremos probando con el
valor inicial x0 = 0,5
function newtonIterationFunction(x) {
return x - (cos(x) - x^3) / (-sin(x) - 3*x^2)
}
var x := 0,5
for i from 0 to 99 {
print "Iteraciones: " + i
print "Valor aproximado: " + x
xold := x
x := newtonIterationFunction(x)
if x = xold {
print "Solución encontrada!"
break
}
}
function x =newton()
disp ('NEWTON-RAPHSON')
xo=input('Valor inicial =');
n=input ('numero de iteraciones=');
salida=ones(n,4); % matiz de salida de datos
for i=1:n
x1=xo-[(exp(-xo)-xo)]/[(-exp(-xo)-1)];
vsal=[xo;x1];
er=[[abs((xo-x1)/xo)]]*100; % error relativo porcentual
ea=[[abs((x1-xo)/x1)]]*100; % error
xo=x1;
salida(i,1)=i;
salida(i,2)=x1;
salida(i,3)=er;
salida(i,4)=ea;
end
disp('ite raiz er ea');
disp(num2str(salida));
Aunque el método de Newton – Raphson trabaja bien en algunos casos, no es
practico en otros donde las derivadas no se pueden evaluar en forma conveniente.
Para estos casos, se dispone de otros procedimientos que no involucran la
evaluación de la derivada. Por ejemplo, un método de Newton, en versión como la
secante, se puede desarrollar al usar aproximaciones por diferencia finita para las
evaluaciones de la derivada.
Una restricción mayor con respecto al procedimiento es que puede divergir con
base en la naturaleza de la función y la calidad del valor inicial. Asi, usualmente se
emplea solo cuando esta cerca del optimo. Las técnicas hibridas que usan
procedimientos con intervalos lejos del optimo y los métodos abiertos cercanos al
optimo intentan explotar los puntos fuertes de ambos procedimientos.
http://ocw.upm.es/matematica-aplicada/programacion-y-metodos-
numericos/contenidos/TEMA_8/Apuntes/EcsNoLin.pdf