METODO DE NEWTON RAPHSON USANDO R Y PYTHON

newton_raphson <- function(f, df, x0, tol = 1e-7, max_iter = 1000) {
  x <- x0
  iter <- 0
  
  while (iter < max_iter) {
    x_new <- x - f(x) / df(x)
    
    if (abs(x_new - x) < tol) {
      return(list(raiz = x_new, iteraciones = iter))
    }
    
    x <- x_new
    iter <- iter + 1
  }
  
  return(list(raiz = NA, iteraciones = iter, mensaje = "No convergió"))
}

# Ejemplo de uso
f <- function(x) x^3 - x - 2
df <- function(x) 3*x^2 - 1

resultado <- newton_raphson(f, df, x0 = 1)
print(resultado)

$raiz
[1] 1.52138

$iteraciones
[1] 5

def newton_raphson(f, df, x0, tol=1e-7, max_iter=1000):
    x = x0
    iter = 0
    
    while iter < max_iter:
        x_new = x - f(x) / df(x)
        
        if abs(x_new - x) < tol:
            return {'raiz': x_new, 'iteraciones': iter}
        
        x = x_new
        iter += 1
    
    return {'raiz': None, 'iteraciones': iter, 'mensaje': 'No convergió'}

# Ejemplo de uso
f = lambda x: x**3 - x - 2
df = lambda x: 3*x**2 - 1

resultado = newton_raphson(f, df, x0=1)
print(resultado)

{'raiz': 1.5213797068045676, 'iteraciones': 5}

newton_raphson <- function(f, df, x0, tol = 1e-7, max_iter = 1000) {
  x <- x0
  iter <- 0
  
  while (iter < max_iter) {
    x_new <- x - f(x) / df(x)
    
    if (abs(x_new - x) < tol) {
      return(list(raiz = x_new, iteraciones = iter))
    }
    
    x <- x_new
    iter <- iter + 1
  }
  
  return(list(raiz = NA, iteraciones = iter, mensaje = "No convergió"))
}

# Ejemplo 1: Función trigonométrica (f(x) = sin(x) - 0.5)
f1 <- function(x) sin(x) - 0.5
df1 <- function(x) cos(x)

resultado1 <- newton_raphson(f1, df1, x0 = 1)
print(resultado1)

$raiz
[1] 0.5235988

$iteraciones
[1] 4

# Ejemplo 2: Función exponencial (f(x) = e^x - 2)
f2 <- function(x) exp(x) - 2
df2 <- function(x) exp(x)

resultado2 <- newton_raphson(f2, df2, x0 = 1)
print(resultado2)

$raiz
[1] 0.6931472

$iteraciones
[1] 4

# Ejemplo 3: Función logarítmica (f(x) = log(x) - 1)
f3 <- function(x) log(x) - 1
df3 <- function(x) 1 / x

resultado3 <- newton_raphson(f3, df3, x0 = 2)
print(resultado3)

$raiz
[1] 2.718282

$iteraciones
[1] 4

# Ejemplo 4: Combinación de funciones (f(x) = e^x - x^2)
f4 <- function(x) exp(x) - x^2
df4 <- function(x) exp(x) - 2*x

resultado4 <- newton_raphson(f4, df4, x0 = 1)
print(resultado4)

$raiz
[1] -0.7034674

$iteraciones
[1] 5

def newton_raphson(f, df, x0, tol=1e-7, max_iter=1000):
    x = x0
    iter = 0
    
    while iter < max_iter:
        x_new = x - f(x) / df(x)
        
        if abs(x_new - x) < tol:
            return {'raiz': x_new, 'iteraciones': iter}
        
        x = x_new
        iter += 1
    
    return {'raiz': None, 'iteraciones': iter, 'mensaje': 'No convergió'}

import math

# Ejemplo 1: Función trigonométrica (f(x) = sin(x) - 0.5)
f1 = lambda x: math.sin(x) - 0.5
df1 = lambda x: math.cos(x)

resultado1 = newton_raphson(f1, df1, x0=1)
print(resultado1)

{'raiz': 0.5235987755982989, 'iteraciones': 4}

# Ejemplo 2: Función exponencial (f(x) = e^x - 2)
f2 = lambda x: math.exp(x) - 2
df2 = lambda x: math.exp(x)

resultado2 = newton_raphson(f2, df2, x0=1)
print(resultado2)

{'raiz': 0.6931471805599453, 'iteraciones': 4}

# Ejemplo 3: Función logarítmica (f(x) = log(x) - 1)
f3 = lambda x: math.log(x) - 1
df3 = lambda x: 1 / x

resultado3 = newton_raphson(f3, df3, x0=2)
print(resultado3)

{'raiz': 2.7182818284590455, 'iteraciones': 4}

# Ejemplo 4: Combinación de funciones (f(x) = e^x - x^2)
f4 = lambda x: math.exp(x) - x**2
df4 = lambda x: math.exp(x) - 2*x

resultado4 = newton_raphson(f4, df4, x0=1)
print(resultado4)

{'raiz': -0.7034674224983917, 'iteraciones': 5}

RAICES COMPLEJAS USANDO NEWTON RAPHSON CON R Y PYTHON.

# Método de Newton-Raphson para números complejos
newton_raphson_complejo <- function(f, df, x0, tol = 1e-7, max_iter = 1000) {
  x <- x0
  iter <- 0
  
  while (iter < max_iter) {
    x_new <- x - f(x) / df(x)
    
    if (Mod(x_new - x) < tol) {
      return(list(raiz = x_new, iteraciones = iter))
    }
    
    x <- x_new
    iter <- iter + 1
  }
  
  return(list(raiz = NA, iteraciones = iter, mensaje = "No convergió"))
}

# Ejemplo de uso
# Polinomio f(x) = x^3 - 1, que tiene raíces complejas
f <- function(x) x^3 - 1
df <- function(x) 3 * x^2

# Punto inicial (semilla) complejo
x0 <- complex(real = 0.5, imaginary = 0.5)

resultado <- newton_raphson_complejo(f, df, x0)
print(resultado)

$raiz
[1] -0.5+0.8660254i

$iteraciones
[1] 8

# Método de Newton-Raphson para números complejos
def newton_raphson_complejo(f, df, x0, tol=1e-7, max_iter=1000):
    x = x0
    iter = 0
    
    while iter < max_iter:
        x_new = x - f(x) / df(x)
        
        if abs(x_new - x) < tol:
            return {'raiz': x_new, 'iteraciones': iter}
        
        x = x_new
        iter += 1
    
    return {'raiz': None, 'iteraciones': iter, 'mensaje': 'No convergió'}

# Ejemplo de uso
# Polinomio f(x) = x^3 - 1, que tiene raíces complejas
f = lambda x: x**3 - 1
df = lambda x: 3 * x**2

# Punto inicial (semilla) complejo
x0 = complex(0.5, 0.5)

resultado = newton_raphson_complejo(f, df, x0)
print(resultado)

{'raiz': (-0.4999999999999986+0.8660254037844375j), 'iteraciones': 8}