# Resolución de ecuaciones

## Ecuaciones y operaciones con ecuaciones

Una ecuación es una expresión de la forma

expresion1 = expresion2

3*x^2+2*x+x^3-x^2 = 4*x^2;

Podemos utilizar un nombre para referirnos a ella

ec1 : 3*x^2+2*x+x^3-a*x^2 = 4*x^2;

y operar como con culaquier otra expresión

ec1-4*x^2;

Podemos seleccionar el miembro de la izquierda o de la derecha de la ecuación con las instrucciones

lhs

y

rhs

lhs(ec1);

rhs(ec1);

## Resolución de ecuaciones

### La orden solve

solve(ecuacion, variable)

solve(x^2-3*x+1=0,x);

Si no se pone el signo =, entonces se asume que es igual a 0

solve(ec1,x);

Y si la ecuación tiene una sola variable, entonces podemos omitirla

solve(x^2+2*x=3);

Habrá que indicarla si en la ecuación hay más de una variable

ec1 : 3*x^2+2*x+x^3-a*x^2 = 4*x^2;
solve(ec1);

solve(ec1,a);

solve(ec1,x);

Para polinomios, hay que tener en cuenta la multiplicidad de las raíces, estas se guardan de forma 
automática en la variable 

multiplicities

ec2 : x^7-2*x^6+2*x^5-2*x^4+x^3;
solve(ec2);

multiplicities;

La orden solve también se puede usar para ecuaciones no algebráicas

ec3 : sin(x)*cos(x)=0;
solve(ec3,x);

Obviamente hay algunas ecuaciones que no podemos resolver

eq: x + 3 = sqrt(x+1);
solve(eq);

pero podemos ayudarle

(x^2 + 6x + 9) = x + 1

solve(eq^2=0);

### Soluciones

Como hemos visto la función solve devuelve las soluciones en forma de ecuación

solve(x^2-4*x+3);

Para manejar estos valores hacemos uso de las funciones rhs 

solucion : solve(x^2-4*x+3);

rhs(part(solucion,1));

rhs(part(solucion,2));

También podemos emplear subíndices con []

rhs(solucion[1]);

rhs(solucion[2]);

O también podemos usar la instrucción map

sol:map(rhs, solve(x^2-4*x+3));

### Sistemas de ecuaciones

Podemos resolver sistemas de ecuaciones

ec1 : x^2+y^2 = 1;
ec2 : (x-2)^2+(y-1)^2=4;

solve([ec1,ec2],[x,y]);

Por defecto, MAXIMA devuelve todas las soluciones, incluidas las complejas

solve([x^2+y^2=1,x+y=5],[x,y]);

Si la solución depende de un parámetro, entonces MAXIMA utiliza %r1, %r2,....

solve([x+y+z=3, x-y=z],[x,y,z]);

Sistema sin solución

solve([x+y=0, x+y=1],[x,y]);

Cualquier valor

solve((x+1)^2=x^2+2*x+1);

Para sistemas de ecuaciones

ecuacion:(x+y)^2=x^2+2*x*y+y^2;
solve(ecuacion,[x,y]);

Para referirnos a las soluciones de sistemas, por ejemplo

soluciones : solve([x*y=1,x-y=1],[x,y]);

En este caso map no sirve

map(rhs,soluciones);

aunque podemos usar makelist

makelist(map(rhs,i),i,soluciones);

y de nuevo podemos utilizar subíndices, para alcanzar cada valor de la solución

rhs(soluciones[1][1]);

## Otras funciones

A veces solve no puede resolver la ecuación

ecuacion : 3*x = sqrt(x^2+1);
solve(ecuacion,x);

to_poly_solve

to_poly_solve(ecuacion,x);

Solve 

solve(x*cos(x)=0,x);

to_poly_solve

to_poly_solve(x*cos(x)=0,x);

## Ecuaciones algebráicas

Para encontrar las raíces de los polinomios podemos utilizar las siguientes funciones

allroots(polinomio): trata de buscar las soluciones aproximadas

bfallroots(polinomio): búsqueda de raíces con precisión arbitraria

realroots(polinomio): búsqueda de raíces reales
realroots(polinomio, error): búsqueda de raíces reales con cota de error

nroots(polinomio,a,b): número de raíces reales en un intervalo [a,b]

algsys([ecuaciones],[variables]): resolución de ecuaciones

ecuacion : x^9+x^7-x^4+x=0;

allroots(ecuacion);

fpprec;

fpprec:6;
bfallroots(ecuacion);

realroots(ecuacion);

ecuacion2 : x^4-3*x^3+x^2-4*x+12=0;

allroots(ecuacion2);

realroots(ecuacion2);

realroots(ecuacion2,10^(-5));

ecuacion3: (x-2)^2*ecuacion2;
realroots(ecuacion3);
multiplicities;

nroots(ecuacion,0,2);

nroots(ecuacion3,0,2);

Orden algsys para resolver sistemas de cuaciones algebráicas, 

La primera diferencia es que hay que utilizar siempre [] para incluir las ecuaciones,
aunque solo sea una ecuación

ecuacion : x^2-4*x+3;

algsys([ecuacion],[x]);

La segunda diferencia es que si no encuentra la solución exacta, intentará encontrar la aproximación numérica

ecuacion : x^6+x+1=0;
solve(ecuacion);

algsys([ecuacion],[x]);

Variable realonly

La variable realonly indica a algsys si solo se buscan raíces reales o no, por defecto es false

realonly;

Podemos buscar solo raíces reales cambiando su valor a true

ecuacion: x^4-1=0;
realonly: false;
algsys([ecuacion],[x]);
realonly : true;
algsys([ecuacion],[x]);
realonly:false;

## Teorema de Bolzano. Método de Bipartición

find_root(f(x),x,a,b)
bf_find_root(f(x),x,a,b)

f(x):=exp(x)+log(x);
wxplot2d(f(x),[x,0.001,3]);

Localizamos dos puntos donde la función cambie de signo

f(exp(-3)),numer;

f(1),numer;

find_root(f(x),x,exp(-3),1);

Podemos usar precisión arbitraria fpprec y bf_find_root

fpprec;
find_root(f(x),x,exp(-3),1);
fpprec:20;
bf_find_root(f(x),x,exp(-3),1);

## Método Iterativo

Consiste en construir la sucesión iterativa

x_(n+1) = g(x_n)

usando una aproximación inicial x_0, donde g(x) = x- f(x), y f(x) es la función para la que queremos encontrar una raíz, f(r)=0

Si la sucesión así construida es convergente, lo hará a un punto fijo (por las propiedades de las sucesiones)

r = g(r) 

y por tanto se cumplirá

g(r) = r-f(r) = r ==> f(r) =0

/* Vamos a resolver la ecuación 

x = cos(x)

es decir, buscamos r que cumpla

r = cos(r) ==> r- cos(r) = 0

la función f(x) será x-cos(x) */

define(f(x),x-cos(x));

/* mientras que la función g(x) = x - f(x) será precisamente cos(x) */
define(g(x),x-f(x));

/* Usamos un punto inicial */
x0 : 0.0;

/* Iteramos, vamos a utilizar un bucle for */
for k:1 thru 100 do (
    x1 : g(x0),
    print("En la Iteración ",i," el valor aproximado es ", x1),
    x0:x1
);

## Método de Newton-Raphson

En el método de Newton-Raphson la ecuación

f(x)=0

se puede resolver construyendo la sucesión

x_(n+1) = x_n + f(x_n) / f'(x_(n+1))

en MAXIMA este método está implementado en la librería mnewton

load(mnewton);

Se usa dando la función f(x) y el punto inicial

mnewton(x^3-5,x,3);