1. Método de la Falsa Posición ¿Qué es?

Referencia: Burden p56, Chapra&Canale 5.3 p131

El método de la posición falsa, falsa posición, regla falsa o regula falsi, considera dividir el intervalo cerrado [a,b] donde se encontraría una raíz de la función f(x) basado en la cercanía a cero que tenga f(a) o f(b).

El método une f(a) con f(b) con una línea recta, la intersección de la recta con el eje x representaría una mejor aproximación hacia la raíz.

Al reemplazar la curva de f(x) por una línea recta, se genera el nombre de "posición falsa" de la raíz. El método también se conoce como interpolación lineal.

A partir de la gráfica, usando triángulos semejantes, considerando que f(a) es negativo en el ejemplo, se estima que:

donde la fórmula de la falsa posición se obtiene al despejar c.

Calculado el valor de c, éste reemplaza a uno de los valores iniciales [a,b], cuyo valor evaluado tenga el mismo signo que f(c).

Nota: La forma de la expresión presentada para c, se usa para comparar con el método de la secante. Se obtiene sumando y restando b y reagrupando.

1.1 Control de iteraciones

Las correcciones del intervalo que se realizan en cada iteración tienen a ser más pequeñas, por lo que el control de iteraciones se realizan sobre la porción o tramo que se redujo el intervalo.

Si la reducción del intervalo es por la izquierda, tramo=c-a
Si la reducción del intervalo es por la derecha, tramo=b-c

2. Ejercicio

Referencia: Burden 2.1 ejemplo 1 p38

La ecuación mostrada tiene una raíz en [1,2], ya que f(1)=-5 y f(2)=14. Muestre los resultados parciales del algoritmo de la falsa posición con una tolerancia de 0.0001

3. Desarrollo Analítico - ejemplo paso a paso

Semejante a los métodos anteriores, el método posición falsa, falsa posición, regla falsa o regula falsi, usa un intervalo [a,b] para buscar la raíz.

Se divide el intervalo en dos partes al calcular el punto c que divide al intervalo siguiendo la ecuación:

iteración 1

el signo de f(c) es el mismo que f(a), se ajusta el lado izquierdo

iteración 2

el signo de f(c) es el mismo que f(a), se ajusta el lado izquierdo

iteración 3

el signo de f(c) es el mismo que f(a), se ajusta el lado izquierdo

valores que se resumen en la tabla

se puede continuar con las iteraciones como tarea

4. Algoritmo en Python para el Método de la Falsa Posición

El algoritmo requiere la función f(x), el intervalo de búsqueda [a,b] y la tolerancia. Las instrucciones básicas para obtener los resultados es:

# Método de la Falsa Posición - tabla
# busca en intervalo [a,b]
import numpy as np

# INGRESO
fx = lambda x: x**3 + 4*x**2 - 10

a = 1
b = 2
tolera = 0.001

# PROCEDIMIENTO
tramo = abs(b-a)
while not(tramo<=tolera):
    fa = fx(a)
    fb = fx(b)
    c = b - fb*(a-b)/(fa-fb)
    fc = fx(c)
    cambia = np.sign(fa)*np.sign(fc)
    if (cambia > 0): # cambio de signo derecha
        tramo = abs(c-a)
        a = c
    else: # cambio de signo izquierda
        tramo = abs(b-c)
        b = c

# SALIDA
print('raiz: ',c)

Para seguimiento con el desarrollo analítico en cada iteración, se puede mejorar el algoritmo para mostrar la tabla de cálculos del método de la Falsa Posición. Los valores de cada iteración se almacenan en orden en una tabla a ser mostrada en el bloque de salida.

# Algoritmo Posicion Falsa para raices
# busca en intervalo [a,b]
import numpy as np

# INGRESO
fx = lambda x: x**3 + 4*(x**2) -10

a = 1
b = 2
tolera = 0.0001

# PROCEDIMIENTO
tabla = []
tramo = abs(b-a)
fa = fx(a)
fb = fx(b)
while not(tramo<=tolera):
    c = b - fb*(a-b)/(fa-fb)
    fc = fx(c)
    unafila = [a,c,b,fa,fc,fb,tramo]
    cambio = np.sign(fa)*np.sign(fc)
    if cambio>0: # cambio de signo derecha
        tramo = abs(c-a)
        a = c
        fa = fc
    else: # cambio de signo izquierda
        tramo = abs(b-c)
        b = c
        fb = fc
    unafila[6]=tramo
    tabla.append(unafila)
tabla = np.array(tabla)
ntabla = len(tabla)

# SALIDA
np.set_printoptions(precision=6)
print('método de la Posición Falsa ')
print('i', ['a','c','b'],[ 'f(a)', 'f(c)','f(b)'])
print('  ','tramo')
for i in range(0,ntabla,1):
    print(i, tabla[i,0:3],tabla[i,3:6])
    print('   ', tabla[i,6])

print('raiz: ',c)

Observe el número de iteraciones realizadas, tan solo 6 vs 9 comparado con el método de la Bisección, realizadas hasta presentar el valor de la raíz en 1.3652 con un error de 0.000079585 en la última fila de la tabla.

Sin embargo, observe que la tabla solo muestra cálculos de filas completas, el último valor de c y error no se ingresó a la tabla, que se muestra como c y tramo, y es el más actualizado en los cálculos.

Método de la falsa posición
i ['a', 'c', 'b'] ['f(a)', 'f(c)', 'f(b)']
   tramo
0 [1.       1.263158 2. ] [-5.       -1.602274 14. ]
   0.26315789473684204
1 [1.263158 1.338828 2. ] [-1.602274 -0.430365 14. ]
   0.0756699440909967
2 [1.338828 1.358546 2. ] [-0.430365 -0.110009 14. ]
   0.019718502996940224
3 [1.358546 1.363547 2. ] [-0.110009 -0.027762 14. ]
   0.005001098217311428
4 [1.363547 1.364807 2. ] [-2.776209e-02 -6.983415e-03  1.400000e+01]
   0.0012595917846898175
5 [1.364807 1.365124 2. ] [-6.983415e-03 -1.755209e-03  1.400000e+01]
   0.0003166860575976038
6 [1.365124 1.365203 2. ] [-1.755209e-03 -4.410630e-04  1.400000e+01]
    7.958577822231305e-05
Método de la falsa posición
iteraciones: 7
raíz en:  1.3652033036626001
errado: 7.958577822231305e-05

5. Algoritmo como función en Python

Para usar bloques de cada algoritmo se añade la función en Python, con las opciones para ver tabla de resultados, la precisión o número de dígitos a mostrar en cada iteración. Con lo que se puede realizar el seguimiento de cada iteración para el desarrollo analítico de cada ejercicio.

# Método de falsa posición para raíces
# [a,b] se seleccionan de la gráfica de f(x)
import numpy as np
 
def falsaposicion(fx,a,b,tolera,iteramax = 50,
                  vertabla=False, precision=6):
    '''fx en forma numérica lambda
    Los valores de [a,b] son seleccionados
    desde la gráfica de la función
    error = tolera
    '''
    fa = fx(a)
    fb = fx(b)
    tramo = np.abs(b-a)
    itera = 0
    cambia = np.sign(fa)*np.sign(fb)
    tabla=[]
 
    if cambia<0: # existe cambio de signo f(a) vs f(b)
        if vertabla==True:
            print('Método de la falsa posición')
            print('i', ['a','c','b'],[ 'f(a)', 'f(c)','f(b)'])
            print('  ','tramo')
            np.set_printoptions(precision)
 
        while (tramo >= tolera and itera<=iteramax):
            c = b - fb*(a-b)/(fa-fb)
            fc = fx(c)
            cambia = np.sign(fa)*np.sign(fc)
            unafila = np.array([a,c,b,fa,fc,fb])
            if (cambia > 0): # cambio de signo derecha
                tramo = np.abs(c-a)
                a = c
                fa = fc
            else: # cambio de signo izquierda
                tramo = np.abs(b-c)
                b = c
                fb = fc

            unafila = np.concatenate([unafila,[tramo]],axis=0)
            tabla.append(unafila)
            if vertabla==True:
                print(itera,unafila[0:3],unafila[3:6])
                print('  ',tramo)
            itera = itera + 1
        respuesta = c
        # Valida respuesta
        if (itera>=iteramax):
            respuesta = np.nan
    else: 
        print(' No existe cambio de signo entre f(a) y f(b)')
        print(' f(a) =',fa,',  f(b) =',fb) 
        respuesta=np.nan
    tabla = np.array(tabla,dtype=float)
    return(respuesta,tabla)
 
# PROGRAMA ----------------------
# INGRESO
fx  = lambda x: x**3 + 4*x**2 - 10
a = 1
b = 2
tolera = 0.0001
verdigitos = 4 # ver digitos en tabla

# PROCEDIMIENTO
c,tabla = falsaposicion(fx,a,b,tolera,
                        vertabla=True,
                        precision=verdigitos)
n = len(tabla)
errado = tabla[n-1,6]

# SALIDA
print('Método de la falsa posición')
print('iteraciones:',n)
print('raíz en: ',c)
print('errado:',errado)

6. Gráfica en Python

La sección para la gráfica, contiene las variantes:

Las muestras para la gráfica de f(x), con la marca de un punto de la raíz.

Para el caso de realizar la gráfica de una iteración particular, usar la variable itera_graf. Por ejemplo para las gráficas presentadas en cada iteración en la sección de desarrollo analítico.

Las instrucciones que se añaden al algoritmo como función son:

# GRAFICA ---------------------
import matplotlib.pyplot as plt
 
muestras = 21 # en intervalo [a,b]
itera_graf = n-1 # iteración en gráfica
 
titulo = 'Falsa Posición'
xk = np.linspace(a,b,muestras)
fk = fx(xk)
[ai,ci,bi] = tabla[itera_graf,0:3]
[fai,fci,fbi] = tabla[itera_graf,3:6]
 
plt.plot(xk,fk, label='f(x)')
 
if itera_graf==(n-1): # iteración final
    plt.plot(c,0,'D',color='orange',label='c')
 
if itera_graf<(n-1): # una iteración en gráfica
    titulo = titulo + ', itera='+str(itera_graf)
    plt.plot(ai,fai,'o',color='red',label='a')
    plt.plot(bi,fbi,'o',color='green',label='b')
    plt.plot(ci,fci,'o',color='orange',label='c')

    plt.plot([ci,ci],[fci,0],'--',color='orange')
    plt.plot([ai,ai],[fai,0],'--',color='red')
    plt.plot([bi,bi],[fbi,0],'--',color='green')
    plt.plot([ai,bi],[fai,fbi],color='orange')
 
plt.axhline(0,color='gray')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title(titulo)
plt.grid()
plt.legend()
plt.tight_layout()
plt.show()