Método de Newton-Raphson

01 · Punto de partida

Aproximar la curva mediante una tangente

Los métodos acotados conservan un intervalo con una raíz. Newton-Raphson adopta otra estrategia: desde una estimación xₙ, reemplaza localmente la curva por su recta tangente y utiliza la intersección de esa recta con el eje horizontal como nueva aproximación.

Cerca de una raíz simple y con una función suficientemente regular, el método puede duplicar aproximadamente la cantidad de cifras correctas en cada paso. Sin embargo, esa velocidad es local y no está garantizada desde cualquier punto inicial.

• ¿Cómo se obtiene la fórmula?
• ¿Qué ocurre si la derivada es cero o muy pequeña?
• ¿Cómo influye la estimación inicial?
• ¿Por qué las raíces múltiples reducen la velocidad?
• ¿Cómo combinar rapidez y seguridad?

02 · Construcción geométrica

Derivar la fórmula de Newton

La recta tangente a f en xₙ tiene ecuación:

Buscamos dónde esa recta alcanza y=0:

Despejando:

La fracción f/f′ estima cuánto debemos movernos horizontalmente para que la aproximación lineal de la función llegue a cero.

function pasoNewton(funcion, derivada, x) {
  const fx = funcion(x);
  const dfx = derivada(x);

  if (dfx === 0) {
    throw new Error("La derivada es cero");
  }
  return x - fx / dfx;
}

03 · Condiciones locales

¿Cuándo esperamos que funcione?

Las condiciones exactas pueden formularse de varias maneras, pero una situación favorable incluye:

• una raíz simple r, con f(r)=0 y f′(r)≠0;
• primera y segunda derivadas continuas cerca de la raíz;
• un valor inicial suficientemente cercano a r;
• derivadas alejadas de cero durante las iteraciones;
• evaluaciones finitas y dentro del dominio.

Newton no requiere un intervalo con cambio de signo y puede aplicarse a raíces de multiplicidad par. A cambio, no mantiene automáticamente una raíz encerrada.

04 · Ejemplo manual

Aproximar √2

Planteamos f(x)=x²−2 y f′(x)=2x. La iteración resulta:

Es el método babilónico estudiado anteriormente.

Después de alcanzar el límite de precisión de Number, nuevas iteraciones dejan de mejorar el valor almacenado.

05 · Procedimiento

El algoritmo paso a paso

1. 1
   Evaluar la función.

   Calcular f(xₙ) y comprobar el residuo.

2. 2
   Evaluar la derivada.

   Calcular f′(xₙ) y verificar que sea utilizable.

3. 3
   Calcular el paso.

   Formar sₙ=f(xₙ)/f′(xₙ).

4. 4
   Actualizar.

   Asignar xₙ₊₁=xₙ−sₙ.

5. 5
   Verificar.

   Comprobar cambio, residuo, dominio, finitud, ciclos y límites.

06 · Velocidad local

Convergencia cuadrática

Si r es una raíz simple y se cumplen las condiciones locales, el error eₙ=xₙ−r satisface aproximadamente:

El error siguiente es proporcional al cuadrado del anterior. Cuando ya estamos cerca de la raíz, el número de cifras correctas puede duplicarse en cada iteración.

07 · Región de atracción

Elegir el valor inicial

Una función con varias raíces divide el dominio en regiones de atracción. Dos valores iniciales cercanos pueden converger a soluciones diferentes, especialmente en problemas complejos.

Para elegir x₀ conviene:

• explorar primero con un gráfico o tabla;
• utilizar conocimiento físico o restricciones del modelo;
• evitar puntos donde |f′(x)| sea pequeño;
• comenzar dentro de un intervalo que aísle la raíz;
• probar varios valores iniciales y comparar residuos.

Una condición suficiente frecuente

Si en un intervalo [a,b] la derivada no se anula, la segunda derivada mantiene signo y hay cambio de signo, suele elegirse un extremo x₀ que satisfaga:

Bajo hipótesis adicionales, esta elección favorece una aproximación monótona desde un lado. No es una regla universal fuera de ese contexto.

08 · Pasos peligrosos

Derivada cero o muy pequeña

El paso de Newton divide por f′(xₙ). Si la pendiente es pequeña, la tangente es casi horizontal y su cruce con el eje puede quedar muy lejos:

Comprobar únicamente f′(x)===0 no basta: un valor diminuto también puede ser problemático. La tolerancia apropiada depende de la escala de la función y la variable.

function pasoNewtonSeguro(f, df, x, toleranciaDerivada = 1e-14) {
  const fx = f(x);
  const dfx = df(x);

  if (!Number.isFinite(fx) || !Number.isFinite(dfx)) {
    throw new Error("Evaluación no finita");
  }
  if (Math.abs(dfx) <= toleranciaDerivada) {
    throw new Error("Derivada demasiado pequeña");
  }
  return x - fx / dfx;
}

En una implementación avanzada puede utilizarse una prueba escalada o limitar directamente la longitud del paso.

09 · Dinámicas problemáticas

Divergencia, ciclos y saltos de raíz

const f = x => x ** 3 - 2 * x + 2;
const df = x => 3 * x ** 2 - 2;

let x = 0;
for (let i = 0; i < 6; i++) {
  x = x - f(x) / df(x);
  console.log(x); // 1, 0, 1, 0...
}

10 · Raíces múltiples

Pérdida de convergencia cuadrática

Si una raíz tiene multiplicidad m>1, entonces f′(r)=0. Newton estándar suele converger solo linealmente, con factor aproximado:

Si conocemos la multiplicidad, podemos modificar el paso:

Para f(x)=(x−1)³, Newton estándar produce:

El error se multiplica por 2/3. Con m=3, la versión modificada llega a la raíz en un paso en aritmética exacta.

11 · Controlar el paso

Newton amortiguado

Podemos multiplicar el paso por λ:

Si el paso completo empeora el residuo o sale del dominio, reducimos λ —por ejemplo, a la mitad— hasta encontrar un avance aceptable.

function pasoNewtonAmortiguado(f, df, x, maxReducciones = 20) {
  const fx = f(x);
  const dfx = df(x);
  if (!Number.isFinite(fx) || !Number.isFinite(dfx) || Math.abs(dfx) <= 1e-14) {
    throw new Error("Función o derivada inválida");
  }
  const paso = fx / dfx;
  let lambda = 1;

  for (let i = 0; i <= maxReducciones; i++) {
    const candidato = x - lambda * paso;
    const valor = f(candidato);
    if (Number.isFinite(valor) && Math.abs(valor) < Math.abs(fx)) {
      return { candidato, lambda, valor };
    }
    lambda /= 2;
  }
  throw new Error("No se encontró un paso que reduzca el residuo");
}

El amortiguamiento mejora robustez global, aunque puede reducir la velocidad. Cerca de una raíz favorable esperamos aceptar λ=1 y recuperar convergencia cuadrática.

12 · Código reutilizable

Implementación robusta en JavaScript

function newton(funcion, derivada, inicial, opciones = {}) {
  const {
    toleranciaAbsoluta = 1e-12,
    toleranciaRelativa = 1e-9,
    toleranciaResiduo = 1e-10,
    toleranciaDerivada = 1e-14,
    maxIteraciones = 100,
    guardarHistorial = false
  } = opciones;

  if (!Number.isFinite(inicial)) {
    throw new Error("El valor inicial debe ser finito");
  }
  if (!Number.isInteger(maxIteraciones) || maxIteraciones < 1) {
    throw new Error("El máximo debe ser un entero positivo");
  }

  let haceDos = null;
  let x = inicial;
  const historial = [];

  for (let iteracion = 1; iteracion <= maxIteraciones; iteracion++) {
    const fx = funcion(x);
    if (!Number.isFinite(fx)) {
      return resultado(x, false, "funcion_no_finita",
        iteracion - 1, { residuo: Math.abs(fx), historial });
    }
    if (Math.abs(fx) <= toleranciaResiduo) {
      return resultado(x, true, "residuo",
        iteracion - 1, { residuo: Math.abs(fx), historial });
    }

    const dfx = derivada(x);
    if (!Number.isFinite(dfx) || Math.abs(dfx) <= toleranciaDerivada) {
      return resultado(x, false, "derivada_invalida",
        iteracion - 1, { residuo: Math.abs(fx), derivada: dfx, historial });
    }

    const siguiente = x - fx / dfx;
    const cambio = Math.abs(siguiente - x);
    const limite = toleranciaAbsoluta
      + toleranciaRelativa * Math.abs(siguiente);
    const residuoSiguiente = Math.abs(funcion(siguiente));

    if (guardarHistorial) {
      historial.push({ iteracion, x, fx, dfx, siguiente,
        cambio, residuo: residuoSiguiente });
    }
    if (!Number.isFinite(siguiente) || !Number.isFinite(residuoSiguiente)) {
      return resultado(siguiente, false, "valor_no_finito",
        iteracion, { cambio, residuo: residuoSiguiente, historial });
    }
    if (cambio <= limite && residuoSiguiente <= toleranciaResiduo) {
      return resultado(siguiente, true, "tolerancias",
        iteracion, { cambio, residuo: residuoSiguiente, historial });
    }
    if (siguiente === x) {
      return resultado(siguiente, false, "estancamiento",
        iteracion, { cambio, residuo: residuoSiguiente, historial });
    }
    if (haceDos !== null && siguiente === haceDos) {
      return resultado(siguiente, false, "ciclo_periodo_2",
        iteracion, { cambio, residuo: residuoSiguiente, historial });
    }

    haceDos = x;
    x = siguiente;
  }

  return resultado(x, false, "maximo_iteraciones",
    maxIteraciones, { residuo: Math.abs(funcion(x)), historial });
}

function resultado(valor, convergio, motivo, iteraciones, datos = {}) {
  return { valor, convergio, motivo, iteraciones, ...datos };
}

La tolerancia de derivada absoluta es una política básica. Para problemas con escalas muy distintas conviene definir un umbral relativo o limitar el paso resultante.

13 · Rapidez con protección

Newton salvaguardado

Si disponemos de un intervalo [a,b] con cambio de signo, podemos combinar Newton con bisección:

1. proponer un paso de Newton;
2. aceptarlo si es finito, queda dentro del intervalo y ofrece progreso;
3. si no, utilizar el punto medio;
4. actualizar el intervalo según los signos.

Este patrón de método híbrido es habitual en bibliotecas numéricas: combina garantías globales con velocidad local.

14 · Exploración interactiva

Laboratorio: seguir las tangentes

Elegí una función, un valor inicial y una cantidad de iteraciones. El gráfico muestra los segmentos tangentes y permite observar convergencia, ciclos y raíces múltiples.

Preguntas para explorar

1. Para x²−2, probá x₀ cerca de cero. ¿Qué ocurre con el primer paso?
2. Seleccioná x³−2x+2 y comenzá en cero. ¿Qué ciclo aparece?
3. Compará la rapidez de una raíz simple con (x−1)³.
4. En cos(x)−x, probá varios valores iniciales y observá la región de atracción.

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: una iteración

Para f(x)=x³−5, calculá una iteración desde x₀=2.

Ejercicio 2: dos pasos para √3

Aplicá Newton a f(x)=x²−3 desde x₀=2.

Ejercicio 3: derivada cero

¿Qué sucede al intentar resolver f(x)=x³−1 comenzando en x₀=0?

Ejercicio 4: raíz múltiple

Derivá la iteración de Newton estándar para f(x)=(x−2)² y determiná su factor de convergencia.

Ejercicio 5: método modificado

Implementá Newton con una multiplicidad conocida m.

function pasoNewtonMultiple(f, df, x, multiplicidad) {
  if (!Number.isInteger(multiplicidad) || multiplicidad < 1) {
    throw new Error("La multiplicidad debe ser un entero positivo");
  }
  const derivada = df(x);
  if (derivada === 0) {
    throw new Error("Derivada cero");
  }
  return x - multiplicidad * f(x) / derivada;
}

const f = x => (x - 2) ** 3;
const df = x => 3 * (x - 2) ** 2;
console.log(pasoNewtonMultiple(f, df, 5, 3)); // 2

17 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos el método de la secante, que conserva la idea de Newton pero aproxima la derivada a partir de dos valores anteriores.