implementación del método de la secante y falsa posición en matlab

[msad]

Buenas tardes, tengo que hacer un programa con matlab con una ecuación no lineal del movimiento sobre-amortiguado, pero tengo que hacerlo con condiciones, por ejemplo el primer paso sería agregar las variables de la ecuación diferencial de segundo orden y que el programa las pida, el segundo paso sería que el programa vea si es sobre amortiguado o no, y hacer el método de la secante y de falsa posición cuando es sobre-amortiguado, y cuando no sea sobre-amortiguado que de error y diga que no se puede hacer porque no es sobre amortiguado, pero en forma general para cualquier ecuación que sea de un circuito sobre-amortiguado, y no tengo ni idea de cómo comenzar, ya que no se usar el matlab, espero puedan ayudarme

[mathtruco]

Un buen manual de matlab: Aprenda matlab como si estuviera en primero.

Matlab es muy utilizado en numérico, así que es muy fácil encontrar cosas hechas en internet:

por ejemplo: http://matlabmorena.blogspot.com/2008/02/metodo-de-la-secante.html

No he checkeado como está. Pero es buena idea buscar algún programa hecho y modificarlo.

[msad]

gracias, ya lo estoy leyendo, ¿como declaro las variables y agrego mi ecuacion? yo se usar el force, es de lenguaje fortran y tiene algunas cosas parecidas al lenguaje de matlab

[mathtruco]

Las variable no es necesario declararlas, basta con usarlas. Si haces A=2 matlab entiende que es un real. Si luego haces A='hola' entiende que ahora será un string.


Para que el programa te pregunte que función quieres puedes hacer:

fun=input('Ingrese la funcion:\n','s')

Por ejemplo, para evaluarla en 1 basta escribir: fun(1).

si tu ingresaste la función x^2+1, para evaluarla en x=1 debes escribir:

x=1; eval(fun)

Hay otras formas de definir funciones. Por ejmplo con el comando inline

[msad]

Ok, entonces seria con ese comando introduzco me ecuación de segundo grado, y luego vendría un if porque quiero que evalúe primero si b/2 > raíz de c, de ser así el ejercicio es sobre-amortiguado y luego pediría la ecuación final para aplicar el método de la secante, y si no es sobre amortiguado daría error, ¿no?

[mathtruco]

 

[msad]

esto es lo que estoy haciendo en matlab:

>> fun=input('Ingrese la funcion:\n','s')
Ingrese la funcion:
ax^2+bx+c

fun =

ax^2+bx+c

>> n=input('ingrese el valor de a');
ingrese el valor de a
>> n2=input(ingrese el valor de c');
n2=input(ingrese el valor de c');
                     |
Error: Missing MATLAB operator.

>> n=input('ingrese el valor de b:');
ingrese el valor de b:
>> n=input('ingrese el valor de c:');
ingrese el valor de c:
>> alfa=b/2

alfa =

    3.1250

>> wo=sqrt[c]
wo=sqrt[c]
           |
Error: Unbalanced or misused parentheses or brackets.

>> wo= (c)^(1/2)

wo =

    1.8803

>> if alfa>wo %el circuito es sobreamortiguado
fun=input('Ingrese la funcion:\n','s');
x0=input('Ingrese el primer punto inicial:\n');
x1=input('Ingrese el segundo punto inicial:\n');
tol=input('Ingrese la tol:\n');
it=0;
fprintf('it x0 x1 x2 x1-x2');
while(it<50) it="it+1;" x="x0;" f0="eval(fun);" x="x1;" f1="eval(fun);" x2="(x0*f1-x1*f0)/(f1-f0);"> fprintf('el procedimiento se completo satisfactoriamente:\n');
break
end
x0=x1;
x1=x2;
end
fprintf('la raiz buscada es=%15.9f\n',x2);
ezplot(fun),
grid on
while(it<50) it="it+1;" x="x0;" f0="eval(fun);" x="x1;" f1="eval(fun);" x2="(x0*f1-x1*f0)/(f1-f0);"> fprintf('el procedimiento se completo satisfactoriamente:\n');
                    |
Error: Missing variable or function.

>> end
end
    |
Error: Illegal use of reserved keyword "end".

eso es lo que me sale  creo que no entendí bien, me da el resultado de alfa y wo, y no he agregado valores todavía

[mathtruco]

Tienes toda la información/indicaciones para hacer el programa. Ahora debes estudiar qué hace cada comando (buscando en google o en el manual que te sugerí). Te sugiero ir probándolos de uno en uno para asegurarte que hacen lo que tú esperas. En las lineas que escribiste hay varios errores:

Por ejemplo:

(...)
>> fun=input('Ingrese la funcion:\n','s')
Ingrese la funcion:
ax^2+bx+c

fun =

ax^2+bx+c

(...)

Nota que en Matlab, si colocas ax esa es una variable llamada así, y no es la multiplicación de a por x.

Lo que debiste escribir (para que sea la ecuación de segundo grado) es:

Código:

a*x^2+b*x+c

Ahora, si quieres evaluar ese polinomio en algún x, debes darle valores a las variables a,b,c y  x:

Código:

a=1;
b=2;
c=1;
x=100;

o bien pedir que el usuario los ingrese (como bien escribiste):

Código:

a=input('ingrese el valor de a');
b=input('ingrese el valor de b');
c=input('ingrese el valor de c');

Para evaluar el polinomio con los valores anteriores habría que escribir:

eval(fun)

(esto último te lo expliqué mal. Corregí mi post de arriba con lo que debía ser).

Debes ir probando y cerciorándote que entiendes qué hace cada comando. Si llegas y escribes un programa largo sin estar seguro seguro te ganarás varios dolores de cabeza. Te sugiero ir probrando linea por linea.

wo=sqrt[c]
Error: Unbalanced or misused parentheses or brackets.

Los argumentos de las funciones se encierran entre paréntesis redondos (como te sugiere el error).
Debiste colocar:

Código:

wo=sqrt(c)

Revisa el resto. Quizás también hayan errores.

[msad]

Gracias por responder mathtruco, ya realice esa parte pero ahora con la parte del método de la secante, no entiendo algo que sale en el pseudocódigo, la parte de it=0, tampoco entiendo la parte de:

 while(it<50) it="it+1;" x="x0;" f0="eval(fun);" x="x1;" f1="eval(fun);" x2="(x0*f1-x1*f0)/(f1-f0);"> fprintf('el procedimiento se completo satisfactoriamente:\n');
break
end

 la parte de fprintf('la raiz buscada es=%15.9f\n',x2) tampoco la entiendo

y al finalizar que escribo la ecuación me pide que inserte la tol, que significa esa tol? además me da este error:

 it x0 x1 x2 x1-x2??? while(it<50) it="it+1;" x="x0;" f0="eval(fun);" x="x1;" f1="eval(fun);" x2="(x0*f1-x1*f0)/(f1-f0);"> fprintf('el procedimiento se completo satisfactoriamente:\n');
                    |
Error: Missing variable or function.

[mathtruco]

Lo mejor es entender el algoritmo que tú tienes y tratar de implementarlo tal y como se te ocurre que es. Hacer unos ejemplos a mano (aunque parezca mucho trabajo) es muy recomendable. Eso te ayudará también a verificar que lo que programaste da los resultados que deben dar.

Te recomiendo que hagas eso.

Lo de buscar un programa hecho te lo decía sólo para conocer los comandos que te servirán en la programación (ya que no conocías los comandos), más que para quebrarte la cabeza pensando en qué trató de hacer la persona (todos programamos distinto).


it=0 es el contador que parte en 0, y que cada vez que entra al bucle (al while) aumenta en 1, mientras sea menor que 50 (con esos aseguras que el programa no se pegará infinitamente). Tiene sentido hacerlo, ya que 50 iteraciones son más que suficientes para calcular tu solución. Además que en cada iteración se cometen errores de numéricos de truncación, por lo que a pesar de que en teoría el método converja, si itera demasiadas veces no tendrás la solución buscada...   Por esto, imponer un máximo de iteraciones es una muy buena costumbre al momento de programar un método numérico iterativo.


Por otro lado, tol denota la tolerancia, o el error="solución exacta menos la solución aproximada". Si el método es convergente, entonces en cada iteración te estarás acercando más y más a tu solución exacta. Con eso le dices al programa que cuando la solución aproximada esté a una distancia menor que tol de la solución exacta se detenga. Cada método numérico tiene su propia condición para determinar qué criterio de parada es el más conveniente.

En todo caso, no veo que el programa use dicha tolerancia, lo cual muestra un error del programador. Yo que tú no confío mucho en el programa y lo haces a tu pinta.


Como te decía arriba, lo mejor es que tomes esto como idea, pero lo programes como a ti te convenza. No creas en algo que postea alguien en internet, a menos que te convenza (uncluido a un forista desconocido).

[msad]

No tengo idea de cómo hacer al algoritmo a mano mathtruco, ya me he familiarizado con algunos comandos y ya estoy haciéndolo a mi modo, pero al tratar de ejecutarlo me da este error:

it t0 t1 t2 t1-t2??? while(it<25) it="it+1;" t="t0;" f0="eval(fun);" t="t1;" f1="eval(fun);" t2="(t0*f1-x1*f0)/(f1-f0);"tolt2<tol”;> fprintf('el procedimiento se completo satisfactoriamente:\n');
                    |
Error: Missing variable or function.

Ya me había dado cuenta que no usa la tolerancia y trate de usarla, pero no se si es asi.

Le coloque it<25 porque yo quiero que me dé el resultado de la iteración nº 24, ya que hasta ahí fue que lo hice a mano  ; y el error o tolerancia que me dio al calcularla, fue un 0.32% de error

Otra cosa, como puedo trabajar en matlab sin que me pida que ingrese los datos de una vez? porque cada vez que escribo n=input('ingrese el primer tiempo'); me lo pide de una vez y no quiero que eso suceda, si me entiendes mathtruco?

[mathtruco]

Me refiero de entender el pseudocódigo, es decir, hacer un par de ejemplos y entender qué programarás. el programa será una generalización de eso.

Un pseudocódigo para el método de bisección: link.


También me parece molesto tener que ingresar los datos cada vez, por eso me gustan los programas "ruteros", donde tanto el código como las entradas van escritas en tu archivo .m (algo te comenté más arriba).


Para escribir tu función puedes poner:

Código:

p = @(a,b,c,x) a*x^2+b*x+c

y para evaluar, por ejemplo, p(x)=x^2+2x+1 en x=1 debes poner:

Código:

p(1,2,1,1)

Con respecto del código, trata de hacerlo tú como a ti te convenza y deja ese de lado.


Para que corra:

Código:

while(it<50)
    it='it+1';
     x='x0';
     f0='eval(fun)';
     x='x1';
     f1='eval(fun)';
     x2='(x0*f1-x1*f0)/(f1-f0)';
     fprintf('el procedimiento se completo satisfactoriamente:\n');
    break
end
x0=x1;
x1=x2;

((el problema no es el indentado, eran los paréntesis)).

[msad]

Si, gracias mathtruco, quiero tratar de entender lo que hizo esa persona con el método de la secante para entender bien ese método, al correr el programa me da lo siguiente:

Ingrese la función:
-0.158*exp(-1.09*t)+1.653*exp(-11.40*t)
Ingrese el primer punto inicial:
0.2
Ingrese el segundo punto inicial:
0.5

it t0 t1 t2 t1-t2el procedimiento se completo satisfactoriamente:
la raiz buscada es=   40.000000000
la raiz buscada es=  116.000000000
la raiz buscada es=   48.000000000
la raiz buscada es=   42.000000000
la raiz buscada es=  102.000000000
la raiz buscada es=   49.000000000
la raiz buscada es=   45.000000000
la raiz buscada es=  116.000000000
la raiz buscada es=   49.000000000
la raiz buscada es=   42.000000000
la raiz buscada es=  102.000000000
la raiz buscada es=   48.000000000
la raiz buscada es=   41.000000000
la raiz buscada es=   47.000000000
la raiz buscada es=   40.000000000
la raiz buscada es=  102.000000000
la raiz buscada es=   49.000000000
la raiz buscada es=   45.000000000
la raiz buscada es=  102.000000000
la raiz buscada es=   48.000000000
la raiz buscada es=   41.000000000

y el valor que yo obtuve analíticamente fue 0.2346

[mathtruco]

Insisto en la idea: en internet podemos publicar cualquiera cualquier cosa.

Hay muy buen material si se busca con cuidado, pero en particular, ese programa no hace lo que dice. No se merece que perdamos más tiempo analizándolo. ¿No te parece?.

Usando el código

fzero(inline('-0.158*exp(-1.09*x)+1.653*exp(-11.40*x)'),0)

me da: 0.227716010164312  (bien parecido a lo que te da calculando a mano).


Trata de hacer el programa tal y como lo entiendes. Ya tienes todas las herramientas.

[msad]

Sí, tienes razón. Eso es lo que estoy tratando de hacer, hasta ahora he hecho esto:

fun=input('Ingrese la funcion:\n','s');
t0=input('Ingrese el primer punto inicial:\n');
t1=input('Ingrese el segundo punto:\n');
tol=input('Ingrese la tol:\n');
it=0;
while (abs(f1)>tol) & (it<25)

   a = t1-f1*((t1-t0)/ (f1-f0));                 
   f0=f1;
   f1=subs (fun,a);    
   fprintf(1, 'it= %i, a= %t0,f= %e  \n', it,a ,f1)
   iter = it + 1;
   t0=t1;
   t1=a;
     fprintf('el procedimiento se completo satisfactoriamente:\n');

end
fprintf('la raiz buscada es=%15.9f\n',t2);


pero me da el siguiente error:
Error using ==> mrdivide
Matrix dimensions must agree.

¿Qué puedo hacer?

[mathtruco]

No haz definido (iniciado) f1,  f0 ni  t2.

Si los añades el programa corre (analiza qué son y qué valores debes ponerle. Sólo he analizado que corra, nada más).



fun=input('Ingrese la funcion:\n','s');
t0=input('Ingrese el primer punto inicial:\n');
t1=input('Ingrese el segundo punto:\n');
tol=input('Ingrese la tol:\n');
it=0;
f1=1000;
f0=0;
t2=0;
while (abs(f1)>tol) & (it<25)

   a = t1-f1*((t1-t0)/ (f1-f0));
   f0=f1;
   f1=subs (fun,a);
   fprintf(1, 'it= %i, a= %t0,f= %e  \n', it,a ,f1)
   iter = it + 1;
   t0=t1;
   t1=a;
     fprintf('el procedimiento se completo satisfactoriamente:\n');

end
fprintf('la raiz buscada es=%15.9f\n',t2);
~                                                                                                                                                           

[msad]

lo que tengo que hacer es que el nuevo valor que se calcula, lo sustituya como el nuevo b0 y asi sucesivamente hasta llegar al valor deseado, llevo hasta ahorita esto y todavia no me da bien:

f=input('Ingrese la funcion:\n','s');
an=0.2;
bn=0.5;
n=1;
funcion=inline('f');
t=an:0.01:bn;
ft=funcion(t);
fan=funcion(an);
fbn=funcion(bn);
while(n<50)
    a(n+1)=an;
    b(n+1)=bn;
    fa(n+1)=fan;
    fb(n+1)=fbn;
     cn=' a(n+1)-[fa(n+1)*(a(n+1)-b(n+1)/(fa(n+1)-fb(n+1))]';
     
     fprintf('el procedimiento se completo satisfactoriamente:\n');
    break
end
fprintf('la raiz buscada es=%15.9f\n',cn);

[mathtruco]

El algoritmo del método de la secante es bien corto y dice:

    

Como puedes ver, para echar a correr el método, es decir, para calcular necesitas dos aproximaciones y (quizás puedes intuirlas mirando el gráfico).

El método corre "mientras" (en el algoritmo: while) no se alcance el número de iteraciones (que llamé maxiter) o se alcance la tolerancia: .

Nota que el algoritmo en sí son 4 lineas (lo que está dentro del while).




% Algoritmo de la secante
%
% informacion de tu funcion:
fun = @(x) sin(x); % funcion a la que calcularas los ceros
x0=1;x1=4;          % x0 y x1 son dos aproximaciones inicitales
%
% informacion del criterio de parada:
%     el algoritmo se detiene cuando |f_n-f_{n+1}|<tol, o cuando
%     se alcanza el numero maximo de iteraciones maxiter
tol     = 0.01;      % tolerancia
maxiter = 10;      % numero maximo de iteraciones
%
%
% Variable de salida:
%     raiz: valor aproximado de la raiz dado por el metodo de la secante
f0=subs(fun,x0);
f1=subs(fun,x1);
iter=1;
while(abs(f1-f0)>tol) & (iter<maxiter)
    raiz = x1-((x1-x0)/(f1-f0))*f1;    % metodo de la secante
    f0=f1; f1=subs(fun,raiz);         % Actualiza f0 y f1
   iter = iter + 1;                    % Cuenta el numero de iteraciones
   x0=x1;   x1=raiz;            % actualiza x
end

% imprime salida
raiz