Sólo necesito lo que es el problema en sí, la 'xs', la parte de MATLAB ya la puedo hacer yo.
No sé como sacar la 'xs'... si alguien me pudiera echar una mano.
O.o Madre mía, espero que sea de universidad porque yo no se que es Matlab ese y mira que iba a clase de mates y atendía eh xD
#7 Pero la parte de MATLAB digo que no me interesa, que la puedo hacer yo. Sólo me interesa la otra parte.
A ver si esto te ayuda. El hecho que ponga la ecuación del (xs+1)... y todo eso es una manera de fijar el error máximo admisible. Dicho de otro modo, en caso que "y" fuera 2000, se podría aceptar una "x" de 6 ya que si resuelves la ecuación con este valor te da 1224 y con x=7 ya pasa a 2303. En sí el método es cutrísimo porque el error es muy alto, pero es lo que piden.
Esto, en código de Matlab, sería lo siguiente:
clear all
y=2000;
Dx=1;
T=0;
x=0;
while T==0
yaux=x^4-2*x^2;
if yaux>y
T=1;
x=x-Dx
end
x=x+Dx;end[/i]
Como ya he dicho es muy basto. La "y" obviamente la puedes cambiar y funciona (lo he comprobado). El Dx tiene que ser 1 precisamente por las condiciones del problema, ya que la "y" tiene que estar entre una "xs" y una "xs+1". La T es simplemente una variable auxiliar usada para la convergencia. Del modo en que lo he propuesto (no es el único) la "x" que muestre en pantalla tiene que ser en realidad "x-1" en ese momento, dado que ya has superado el valor de "y".
De todos modos, haciendo un pequeño cambio podemos tener muchísima más precisión, aunque ya no estarías cumpliendo las exigencias del enunciado:
clear all
y=2000;
Dx=0.001;
T=0;
x=0;
while T==0
yaux=x^4-2*x^2;
if yaux>y
T=1;
x=x-Dx
end
x=x+Dx;end[/i]
fíjate que lo único que he hecho es cambiar el Dx a 0.001. Prácticamente tarda lo mismo en calcularlo, es decir, nada. Hay otras formas más elaboradas de hacer una convergencia para que sea todo más óptimo, pero creo que no es el objetivo de este problema así que no vale la pena ponerse a mejorar este código que a fin de cuentas usa la fuerza bruta.
Espero que te sirva. Si tienes alguna duda preguntamelo.
edit:
Como no tenía nada que hacer he hecho algo más elegante, aunque tampoco te sirve para tu problema, simplemente como curiosidad. El código sería el siguiente:
clear all
y=2000;
delta=10-9;
T=0;
x=5;
while T==0
x=(2000+2*x^2)^0.25;
yaux=x^4-2*x^2;
if abs(yaux-y)<delta
T=1;
x
end end[/i]
Puedes ver como sin agregar más sentencias, simplemente retocando algún aspecto, se puede conseguir una convergencia mucho más óptima usando un método llamado Gauss-Seidel (resuelves la ecuación implícita "inventándote" un valor inicial y a partir de ahí colocas el valor anterior).
Para que te hagas una idea, con el anterior código usando un Dx=0.00001, se obtiene un error absoluto de 7.6*10-3 pero se hacen 676 260 iteraciones. Usando este error absoluto como "delta" en esta nueva función se ve como se han realizado sólo 4 iteraciones. El código de fuerza bruta es, por tanto, unas 170 000 veces peor, aunque como el caso es sencillo no se aprecia la diferencia en tiempo de ejecución. Es un ejemplo claro de la importancia de la optimización en programación; nadie quiere un programa que tarde 2 minutos en abrirse cuando puede hacer exactamente lo mismo en 0.1 segundo.
Gracias, creo que ya me he enterado del asunto!! por fin alguien que responde en serio.
Yo lo he hecho así:
function[xs]=solent(y)
s=0;
while ssss-2s*s<=y %no nos dejan usar el ^
s=s+1;
end
xs=s-1;
(la versión cutre, que es la que piden XD)
#17 Sí, es básicamente eso. Te ahorras la variable "T" al hacer la comparación directamente en la cabecera del bucle y también el Dx ya que en el caso del problema es siempre 1, así queda todo más compacto.
Muchas gracias Rabbitter!!
La asignatura es informática, pero no estoy estudiando informática, sólo que tengo esta asignatura.
Todos menos #2
Lo he probasdo y los panchitos estos te sueltan de todos menos la respuesta a lo que preguntas.
