Este es el algoritmo de la bisección para encontrar raíces de una función.

Vamos a desglosarlo paso a

paso:

1. Ingreso de datos:

o Se define la función f(x)=x3+4x2−10, y se establecen los límites del intervalo [a, b],
donde se espera encontrar la raíz de la función.

o Se define la tolerancia (tolera), que determina cuán cerca queremos estar de la raíz real.

2. Procedimiento:

o El algoritmo itera hasta que la longitud del intervalo [a, b] sea menor que la tolerancia
(tramo<tolera).

o En cada iteración, se calcula el punto medio c del intervalo [a, b].

o Se evalúan las funciones en los extremos del intervalo y en el punto medio: f(a), f(b) y
f(c).

o Se comprueba el cambio de signo entre f(a) y f(c). Si el producto f(a)⋅f(c) es negativo,

significa que hay una raíz en el intervalo [a, c], por lo tanto, se actualiza b = c. Si es
positivo, la raíz está en el intervalo [c, b], por lo que se actualiza a = c.

o Se recalcula el tamaño del intervalo tramo=b−a

3. Salida:

o Una vez que el bucle termina (cuando el intervalo es lo suficientemente pequeño), se

imprime la raíz aproximada (c) y el error en el tamaño del intervalo (tramo).
Otra manera sin el uso de numpy

En resumen, el uso de lambda es una manera conveniente de definir la función f(x), mientras que el uso
de NumPy en este código específico es sólo para la función ‘sign’, que puede ser reemplazada por una
versión pura de Python si se desea.

El uso de lambda en este código no está relacionado directamente con NumPy, aunque NumPy se utiliza
en el código. La función lambda en Python se usa para crear funciones pequeñas y anónimas de manera
rápida. En este caso, se usa para definir la función matemática f(x) = x^3 + 4x^2 - 10

Vamos a desglosar los diferentes elementos:

1. Uso de lambda:

o lambda x: x**3 + 4*x**2 - 10 define una función anónima (sin nombre) que toma un
argumento x y devuelve el valor de x3+4x2−10.

2. Uso de NumPy (np):

o np.sign(fa) * np.sign(fc) utiliza la función sign de NumPy, que devuelve el signo de un

número: -1 para números negativos, 1 para números positivos y 0 para cero. En este
contexto, se usa para verificar si hay un cambio de signo entre f(a) y f(c), lo que indica
que hay una raíz en el intervalo.

La estructura del código en sí:

  Este algoritmo de bisección puede implementarse sin NumPy. La función lambda es una
característica estándar de Python para definir funciones anónimas y es particularmente
útil para funciones matemáticas simples.

Procedimiento sin NumPy:

 Se puede reemplazar np.sign por una función equivalente en Python puro:

def sign(x):
if x > 0:
return 1
elif x < 0:
return -1
else:
return 0

Método de Newton Raphson

Explicación General

El método de Newton-Raphson es una técnica iterativa para encontrar aproximaciones a las

raíces de una función f(x). Comienza con una suposición inicial y mejora esa suposición
repetidamente utilizando la derivada de la función hasta que la diferencia entre iteraciones
sucesivas es menor que una tolerancia predefinida.

Pasos del Método de Newton-Raphson

1. Ingreso de datos:
o Se define la función f(x) y su derivada f′(x).
o Se establece un valor inicial x0 y una tolerancia tolera.
2. Procedimiento:
o Se inicia una iteración con la suposición inicial x0.
o En cada iteración, se calcula una nueva aproximación utilizando la fórmula:
 o Se calcula el tramo, que es la diferencia absoluta entre la nueva aproximación y la
anterior.
o Se almacena cada iteración en una tabla para análisis posterior.
o El proceso se repite hasta que el tramo es menor que la tolerancia.
3. Salida:
o Se imprime la tabla de iteraciones, la raíz aproximada y el error.

Código Detallado
Vamos a desglosar el código paso a paso.
# Importar numpy para trabajar con arreglos
import numpy as np

# INGRESO
# Definir la función f(x) y su derivada f'(x) usando lambda
fx = lambda x: x**3 + 4*(x**2) - 10
dfx = lambda x: 3*(x**2) + 8*x

# Suposición inicial y tolerancia

x0 = 2
tolera = 0.001

# PROCEDIMIENTO
# Inicializar la tabla para almacenar las iteraciones
tabla = []
# Inicializar el tramo con un valor suficientemente grande
tramo = abs(2 * tolera)
# Inicializar xi con el valor inicial x0
xi = x0

# Iterar hasta que el tramo sea menor que la tolerancia

while (tramo >= tolera):
# Calcular la nueva aproximación usando la fórmula de Newton-Raphson
xnuevo = xi - fx(xi) / dfx(xi)
# Calcular el tramo como la diferencia absoluta entre la nueva y la antigua aproximación
tramo = abs(xnuevo - xi)
# Agregar la iteración actual a la tabla
tabla.append([xi, xnuevo, tramo])
# Actualizar xi para la siguiente iteración
xi = xnuevo

# Convertir la lista de iteraciones a un arreglo numpy para mejor presentación

tabla = np.array(tabla)
# Obtener el número de iteraciones
n = len(tabla)

# SALIDA
# Imprimir los encabezados de la tabla
print(['xi', 'xnuevo', 'tramo'])
# Configurar la impresión de numpy para mostrar 4 decimales
np.set_printoptions(precision=4)
# Imprimir la tabla de iteraciones
print(tabla)
# Imprimir la raíz aproximada y el error del tramo final
print('raiz en: ', xi)
print('con error de: ', tramo)

Si no usamos NumPy en este código, tendríamos que realizar algunos cambios para manejar las
iteraciones y la presentación de resultados sin las funciones de NumPy. Aquí está el código modificado
para no usar NumPy:
# INGRESO
# Definir la función f(x) y su derivada f'(x)
def fx(x):
return x**3 + 4*(x**2) - 10

def dfx(x):
return 3*(x**2) + 8*x

# Suposición inicial y tolerancia

x0 = 2
tolera = 0.001

# PROCEDIMIENTO
# Inicializar la lista para almacenar las iteraciones
tabla = []
# Inicializar el tramo con un valor suficientemente grande
tramo = abs(2 * tolera)
# Inicializar xi con el valor inicial x0
xi = x0

# Iterar hasta que el tramo sea menor que la tolerancia

while (tramo >= tolera):
# Calcular la nueva aproximación usando la fórmula de Newton-Raphson
xnuevo = xi - fx(xi) / dfx(xi)
# Calcular el tramo como la diferencia absoluta entre la nueva y la antigua aproximación
tramo = abs(xnuevo - xi)
# Agregar la iteración actual a la lista
tabla.append([xi, xnuevo, tramo])
 # Actualizar xi para la siguiente iteración
xi = xnuevo

# Obtener el número de iteraciones

n = len(tabla)

# SALIDA
# Imprimir los encabezados de la tabla
print(['xi', 'xnuevo', 'tramo'])

# Imprimir cada iteración de la tabla

for row in tabla:
# Formatear los valores con 4 decimales
print([f"{value:.4f}" for value in row])

# Imprimir la raíz aproximada y el error del tramo final

print('raiz en: ', xi)
print('con error de: ', tramo)
Si no usamos NumPy en este código, tendríamos que realizar algunos cambios para manejar las
iteraciones y la presentación de resultados sin las funciones de NumPy. Aquí está el código modificado
para no usar NumPy:

# INGRESO
# Definir la función f(x) y su derivada f'(x)
def fx(x):
return x**3 + 4*(x**2) - 10

def dfx(x):
return 3*(x**2) + 8*x
# Suposición inicial y tolerancia
x0 = 2
tolera = 0.001

# PROCEDIMIENTO
# Inicializar la lista para almacenar las iteraciones
tabla = []
# Inicializar el tramo con un valor suficientemente grande
tramo = abs(2 * tolera)
# Inicializar xi con el valor inicial x0
xi = x0

# Iterar hasta que el tramo sea menor que la tolerancia

while (tramo >= tolera):
# Calcular la nueva aproximación usando la fórmula de Newton-Raphson
xnuevo = xi - fx(xi) / dfx(xi)
# Calcular el tramo como la diferencia absoluta entre la nueva y la antigua aproximación
tramo = abs(xnuevo - xi)
# Agregar la iteración actual a la lista
tabla.append([xi, xnuevo, tramo])
# Actualizar xi para la siguiente iteración
xi = xnuevo

# Obtener el número de iteraciones

n = len(tabla)

# SALIDA
# Imprimir los encabezados de la tabla
print(['xi', 'xnuevo', 'tramo'])

# Imprimir cada iteración de la tabla

for row in tabla:
# Formatear los valores con 4 decimales
print([f"{value:.4f}" for value in row])

# Imprimir la raíz aproximada y el error del tramo final

print('raiz en: ', xi)
print('con error de: ', tramo)

Cambios detallados
1. Definición de funciones:
o Las funciones fx y dfx se definen usando def en lugar de lambda para mantener la
consistencia fuera del contexto de NumPy.
2. Eliminación de NumPy:
o No se importa NumPy al inicio del código.
3. Almacenamiento de iteraciones:
o La lista tabla se usa para almacenar las iteraciones.
4. Conversión y presentación de la tabla:
o En lugar de convertir la lista tabla a un arreglo de NumPy, se imprime
directamente.
o Al imprimir, se utiliza un bucle for para recorrer cada fila de tabla y se formatean
los valores para mostrar 4 decimales.
Justificación de cambios
 Funciones fx y dfx: Se mantienen como funciones definidas por def para evitar el uso de
lambda en un entorno sin NumPy.
 Manejo de iteraciones: La lista tabla sigue funcionando igual sin necesidad de
conversión a un arreglo de NumPy.
  Presentación: Usamos bucles y formateo de cadenas para mostrar los resultados de las
iteraciones, logrando el mismo resultado que con NumPy pero sin su uso.
Este código proporciona la misma funcionalidad que el original pero sin depender de NumPy,
utilizando solo las funciones estándar de Python.