Cómo resolver para x: [matemáticas] (x-0.861) / x = 0.435 ^ {(1 / x)} [/ matemáticas]

Answer 1

Puede convertir la ecuación a la forma x = f (x) para alguna función f y luego calcular el punto fijo de f . Eso no está garantizado, pero si puedes encontrar uno, también es una solución a la ecuación.

Al tomar registros de ambos lados y un poco de masaje, obtienes
x = ln (0.435) / ln (1 – 0.861 / x)

A continuación se muestra el código directo de Haskell para calcular el punto fijo de una función y aplicar f arriba, donde consideramos los valores “lo suficientemente cercanos” si difieren en no más de 0.001 , y comenzamos nuestra suposición desde -1.

-- δ: threshold beyond which we consider values close enough
-- f: function to compute fixpoint for
-- x: guessed value to start computing fixpoint from
fixedPoint δ fx | abs (x' - x) < δ = x'
| otherwise = fixedPoint δ f x'
where x' = fx ans = fixedPoint 0.001 (\x -> log 0.435 / log (1 - 0.861 / x)) (-1)
-- ==> -12.364847713203252


-- δ: threshold beyond which we consider values close enough
-- f: function to compute fixpoint for
-- x: guessed value to start computing fixpoint from
fixedPoint δ fx | abs (x' - x) < δ = x'
| otherwise = fixedPoint δ f x'
where x' = fx ans = fixedPoint 0.001 (\x -> log 0.435 / log (1 - 0.861 / x)) (-1)
-- ==> -12.364847713203252


Answer 2

Hay formas más humildes de lidiar con esto. Puedo trazar esto usando la biblioteca Sympy de Python con estos comandos. (Sage sería una alternativa; está disponible para su uso en SageMathCloud).

Con un poco de panorámica y zoom, encuentro que la vista predeterminada no muestra los lugares donde el gráfico cruza, o podría cruzar, el eje x. Por lo tanto, vuelvo a ejecutar el comando plot como

El examen del lado positivo del eje x y un poco de reflexión lleva a la conclusión de que no hay soluciones positivas. Un poco de trabajo en la panorámica y el zoom de la trama me da esto.

Al pasar el cursor sobre la intersección del locus azul con el eje x, se obtiene un valor de solución de -12.45.

Answer 3

Deje [math] y = 1 / x [/ math], entonces

[matemáticas] 1-ay = b ^ y [/ matemáticas]

La igualdad se satisface para [math] y = 0 [/ math], por lo que dos soluciones son [math] x \ rightarrow \ pm \ infty [/ math].

Podría haber otra solución, veamos si hay una alrededor de 0, que es [matemáticas] | y | \ ll 1 [/ matemáticas]. Si este supuesto se cumple, podemos usar la serie Taylor

[matemáticas] b ^ y = e ^ {y \ log {b}} \ aprox 1 + y \ log {b} + \ frac {y ^ 2 \ log ^ 2 {b}} {2} [/ math]

y encontrar

[matemática] y \ aprox -2 \ frac {a + \ log {b}} {\ log ^ 2 {b}} \ aprox -.0825 [/ matemática]

que es consistente con la suposición de y pequeño (la otra solución para nuestra cuadrática es [math] y = 0 [/ math]). La inversión da [matemática] x \ aprox -12.1 [/ matemática]. Puede usar la teoría de perturbación para refinar esta estimación.

Answer 4

Me gusta abogar por el método de iteración de punto fijo para aproximar numéricamente este tipo de problemas porque es realmente fácil entender por qué funciona (cuando realmente funciona).

Para su ecuación, quiero reescribirla en forma de [matemáticas] x = f (x) [/ matemáticas]. Hay muchas formas de hacer esto, y algunas conducirán a una secuencia que convergerá en una solución y otras no. Para su problema, hacemos los siguientes pasos de álgebra:

[matemáticas] (x-0.861) / x = 0.435 ^ {(1 / x)} [/ matemáticas]

[matemáticas] 1- \ frac {0.861} x = 0.435 ^ {(1 / x)} [/ matemáticas]

[matemática] \ ln \ left (1- \ frac {0.861} x \ right) = \ frac {\ ln (0.435)} x [/ math]

[matemáticas] x = \ frac {\ ln (0.435)} {\ ln \ left (1- \ frac {0.861} x \ right)} [/ math]

Entonces, en este caso, dejamos que [math] f (x) = \ frac {\ ln (0.435)} {\ ln \ left (1- \ frac {0.861} x \ right)} [/ math], y buscamos un punto fijo de [matemáticas] f [/ matemáticas]. Un punto fijo es un valor de [matemáticas] x [/ matemáticas] que se asigna a sí mismo de modo que [matemáticas] f (x) = x [/ matemáticas]. Observe que un punto fijo de [matemáticas] f [/ matemáticas] debe ser una solución a su ecuación.

Para encontrar un punto fijo, configuramos la siguiente secuencia:

[matemáticas] x_0 = -1 [/ matemáticas]
[matemática] x_n = f (x_ {n-1}) [/ matemática] para [matemática] n = 1,2,3, \ ldots [/ matemática]

Si la secuencia converge, entonces [math] x = \ lim_ {n \ to \ infty} x_n [/ math] es un punto fijo y, por lo tanto, una solución a la ecuación.

Esta secuencia en realidad converge muy lentamente. Se necesitan 913 iteraciones para converger a la precisión de la máquina. Aquí están los primeros y los “últimos” pocos términos:

[matemáticas] x_0 = -1.00000000000000 [/ matemáticas]
[matemáticas] x_1 = -1.34018759492314 [/ matemáticas]
[matemáticas] x_2 = -1.67761051007136 [/ matemáticas]
[matemáticas] x_3 = -2.00945428277578 [/ matemáticas]
[matemáticas] x_4 = -2.33424741575659 [/ matemáticas]
[matemáticas] \ vdots [/ matemáticas]
[matemáticas] x_ {910} = – 12.3935545997801 [/ matemáticas]
[matemáticas] x_ {911} = – 12.3935545997802 [/ matemáticas]
[matemáticas] x_ {912} = – 12.3935545997802 [/ matemáticas]
[matemática] x_ {n} = – 12.3935545997803 [/ matemática] para todos [matemática] n \ ge 913 [/ matemática]

Hay otros algoritmos numéricos que convergerán más rápidamente y tienen otras propiedades agradables, pero son un poco más difíciles de entender, por eso recomiendo este a cualquiera que no esté familiarizado con el análisis numérico.

Aquí hay un código de Octave / Matlab para hacer el trabajo:

[correo electrónico protegido] (x) log (.435) / log (1-0.861 / x)% define la función
x = ceros (3,1); % initialize array para iteraciones
x (1) = – 1; % elige un valor inicial para la secuencia
x (2) = f (x (1)); % encuentra el siguiente término
cnt = 2; % mantiene un contador de iteraciones
mientras que x (cnt) ~ = x (cnt-1)% secuencia no ha convergido
cnt = cnt + 1; % aumenta el contador
x (cnt) = f (x (cnt-1)); % encuentra el siguiente término
% Los siguientes comandos cambian el tamaño de la matriz una vez que se llena
si cnt == length (x)% array está lleno, por lo que debemos hacerlo más grande
x = [x; ceros (longitud (x), 1)]; % doble la longitud
fin
fin
x = x (1: cnt); % tirar todas las piezas innecesarias de la matriz
formato largo% mostrar todos los decimales
disp ([‘La solución convergió en el número de iteración:’ num2str (cnt-1)])
disp ([‘El valor final es:’])
disp (x (final))

Este script devuelve:
La solución convergió en el número de iteración: 915
El valor final es:
-12.3935545997803