Introducción al cálculo numérico

01 · Punto de partida

Cuando conocer la fórmula no alcanza

En los cursos de matemática solemos buscar una respuesta exacta: una fracción, una raíz, una expresión algebraica o una función. En programación necesitamos además convertir esa respuesta en operaciones que una computadora pueda ejecutar con memoria y tiempo finitos.

Ese cambio de perspectiva abre preguntas nuevas:

• ¿Qué hacemos si el problema no tiene una fórmula cerrada?
• ¿Cómo representamos números con infinitos decimales?
• ¿Cuántas operaciones necesitamos para alcanzar una precisión determinada?
• ¿Cómo sabemos si las aproximaciones se están acercando a la solución?
• ¿Cuándo conviene detener el algoritmo?

El cálculo numérico responde estas preguntas mediante métodos que producen aproximaciones controladas. No busca simplemente “un número parecido”, sino un resultado acompañado por información sobre su error, su costo y las condiciones bajo las cuales podemos confiar en él.

02 · Definición y alcance

¿Qué estudia el cálculo numérico?

El cálculo numérico —también llamado análisis numérico cuando incluye el estudio teórico de los métodos— diseña, analiza e implementa algoritmos para resolver problemas matemáticos mediante números aproximados.

A lo largo del curso aplicaremos esta idea a diferentes familias de problemas:

Los métodos numéricos conectan matemática, algoritmos y experimentación. Para utilizarlos correctamente necesitamos comprender las tres áreas: la ecuación que modela el problema, el procedimiento que la aproxima y el comportamiento real del programa.

03 · Dos clases de resultado

Solución exacta y solución aproximada

Una solución exacta conserva toda la información matemática. Por ejemplo, la diagonal de un cuadrado de lado 1 es exactamente √2. Una solución aproximada reemplaza ese valor por uno cercano y representable, como 1.4142.

Una aproximación no es necesariamente inferior. Para mostrar una distancia en pantalla, simular un movimiento o resolver una ecuación física, un número con suficientes cifras correctas suele ser más útil que una expresión simbólica difícil de evaluar.

04 · Motivación

¿Por qué necesitamos métodos numéricos?

En cada situación aceptamos una aproximación a cambio de obtener un resultado computable. La pregunta práctica no es “¿hay error?”, porque casi siempre lo hay, sino “¿cuánto error hay y es aceptable para este problema?”.

05 · Método de trabajo

Del problema real al resultado

Un cálculo confiable comienza antes del código y termina después de obtener un número. El flujo completo puede organizarse en seis etapas:

1. 1
   Definir el problema.

   Precisar qué se conoce, qué se busca, las unidades y las restricciones.

2. 2
   Construir el modelo matemático.

   Representar las relaciones mediante funciones, ecuaciones o datos.

3. 3
   Elegir un método numérico.

   Considerar precisión, convergencia, estabilidad, costo y propiedades del problema.

4. 4
   Implementar el algoritmo.

   Traducir el método a código, validar entradas y registrar información útil.

5. 5
   Verificar el cálculo.

   Probar casos conocidos, estimar el error y comparar métodos o tamaños de paso.

6. 6
   Interpretar el resultado.

   Regresar al problema original y decidir si la respuesta es coherente y suficiente.

Un error en cualquiera de estas etapas puede producir una respuesta inútil. Un programa puede ejecutar perfectamente un algoritmo que resuelve la ecuación equivocada.

06 · Primer algoritmo iterativo

Aproximar √2 sin utilizar Math.sqrt

Buscamos un número x tal que x² = 2. Una estrategia antigua, conocida como método babilónico o de Herón, comienza con una estimación positiva y la mejora promediándola con 2/x:

Si empezamos con x₀ = 1, obtenemos:

Cada fila utiliza el resultado anterior para construir uno mejor. A esto lo llamamos método iterativo. La sucesión de aproximaciones parece estabilizarse rápidamente cerca de la raíz.

function aproximarRaizDeDos(iteraciones) {
  let x = 1;

  for (let i = 0; i < iteraciones; i++) {
    x = (x + 2 / x) / 2;
  }

  return x;
}

console.log(aproximarRaizDeDos(4));
console.log(aproximarRaizDeDos(4) ** 2);

La segunda salida permite comprobar el resultado sin conocer previamente √2: si la aproximación es buena, su cuadrado debe estar muy cerca de 2.

07 · Calidad del resultado

Error, residuo y convergencia

Para evaluar un método necesitamos distinguir tres conceptos que aparecerán durante todo el curso:

Error

Diferencia entre la solución exacta x* y la aproximación xₙ. En valor absoluto: |x* − xₙ|.

Residuo

Cuánto incumple la aproximación la ecuación. Para x² = 2: |xₙ² − 2|.

Convergencia

Comportamiento por el cual las aproximaciones se acercan a una solución al continuar el proceso.

Tolerancia

Umbral que determina cuándo la aproximación se considera suficientemente buena.

El error verdadero requiere conocer la solución exacta, precisamente lo que muchas veces buscamos. El residuo puede calcularse directamente y es una señal útil, aunque un residuo pequeño no siempre implica un error pequeño. Estudiaremos esa diferencia con detalle al hablar de condicionamiento.

Detenerse por una condición, no por casualidad

En vez de ejecutar siempre cuatro iteraciones, podemos detener el proceso cuando el residuo sea menor que una tolerancia. También imponemos un máximo de iteraciones para evitar un ciclo interminable.

function raizCuadrada(numero, tolerancia = 1e-10, maxIteraciones = 100) {
  if (numero < 0) throw new Error("Se requiere un número no negativo");
  if (numero === 0) return { valor: 0, iteraciones: 0, residuo: 0 };

  let x = numero >= 1 ? numero : 1;

  for (let i = 1; i <= maxIteraciones; i++) {
    const siguiente = (x + numero / x) / 2;
    const residuo = Math.abs(siguiente ** 2 - numero);

    if (residuo <= tolerancia) {
      return { valor: siguiente, iteraciones: i, residuo };
    }
    x = siguiente;
  }

  throw new Error("El método no alcanzó la tolerancia solicitada");
}

console.log(raizCuadrada(2));
console.log(raizCuadrada(10, 1e-12));

08 · Fuentes de incertidumbre

¿De dónde provienen los errores?

El error final no tiene una única causa. Conviene identificar al menos cuatro niveles:

El análisis numérico se concentra especialmente en los errores de truncamiento y redondeo, pero un resultado profesional debe considerar toda la cadena. No tiene sentido pedir quince decimales al algoritmo si los datos fueron medidos con dos cifras significativas.

09 · Elegir un método

No existe un algoritmo mejor para todos los casos

Dos métodos pueden resolver el mismo problema y comportarse de manera muy diferente. Para compararlos utilizaremos varios criterios:

Por ejemplo, un método para raíces puede ser muy rápido cerca de la solución pero fallar con una estimación inicial inadecuada. Otro puede ser más lento, aunque garantice convergencia bajo condiciones fáciles de comprobar. Elegir requiere conocer el problema y las fortalezas de cada alternativa.

10 · Exploración interactiva

Laboratorio: observar una sucesión de aproximaciones

Modificá el número, la estimación inicial y la cantidad de iteraciones. El gráfico muestra la distancia de cada aproximación respecto del valor calculado por Math.sqrt, usado aquí únicamente como referencia para estudiar el método.

Preguntas para explorar

1. ¿Cuántas iteraciones hacen falta para que las cifras visibles dejen de cambiar?
2. ¿Qué sucede al comenzar con una estimación muy alejada de la raíz?
3. Compará números menores y mayores que 1. ¿Cambia la velocidad de convergencia?
4. ¿Seguir iterando mejora siempre el valor mostrado por JavaScript?

11 · Verificación computacional

Cómo comprobar un algoritmo numérico

Un único ejemplo exitoso no demuestra que el programa sea correcto. Conviene combinar varias estrategias:

1. A
   Casos simples.

   Probar valores cuya respuesta conocemos, como las raíces de 0, 1, 4 y 9.

2. B
   Propiedades.

   Verificar que el resultado al cuadrado se acerque al número original.

3. C
   Comparación.

   Contrastar con otro algoritmo o con una función de referencia.

4. D
   Casos límite.

   Examinar cero, números muy pequeños, valores grandes y entradas inválidas.

5. E
   Seguimiento.

   Registrar iteraciones, residuos y condiciones de parada para explicar el resultado.

function comprobarRaiz(numero, aproximacion, tolerancia) {
  const residuo = Math.abs(aproximacion ** 2 - numero);
  return {
    numero,
    aproximacion,
    residuo,
    aceptada: residuo <= tolerancia
  };
}

console.log(comprobarRaiz(2, 1.41421356237, 1e-9));
console.log(comprobarRaiz(9, 3, 1e-12));

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Ejercicios

Ejercicio 1: clasificar resultados

Indicá si cada expresión conserva una solución exacta o presenta una aproximación:

1. π / 4
2. 0.7854 como valor de π / 4
3. 2 / 7
4. 0.285714 como valor de 2 / 7

Ejercicio 2: realizar dos iteraciones

Usá el método babilónico para aproximar √10 comenzando con x₀ = 3. Calculá x₁, x₂ y el residuo final |x₂² − 10|.

Ejercicio 3: mejorar una función

El siguiente código puede ejecutar un ciclo infinito. Agregá validación de entradas, una tolerancia y un máximo de iteraciones.

function raiz(numero) {
  let x = numero;
  while (x * x !== numero) {
    x = (x + numero / x) / 2;
  }
  return x;
}

function raiz(numero, tolerancia = 1e-10, maxIteraciones = 100) {
  if (!Number.isFinite(numero) || numero < 0) {
    throw new Error("El número debe ser finito y no negativo");
  }
  if (numero === 0) return 0;

  let x = numero >= 1 ? numero : 1;
  for (let i = 0; i < maxIteraciones; i++) {
    const siguiente = (x + numero / x) / 2;
    if (Math.abs(siguiente ** 2 - numero) <= tolerancia) {
      return siguiente;
    }
    x = siguiente;
  }
  throw new Error("No se alcanzó la tolerancia");
}

Ejercicio 4: diseñar pruebas

Proponé cinco casos de prueba para la función anterior e indicá qué propiedad comprobarías en cada uno.

14 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos cómo representa números una computadora: sistema binario, punto flotante, estándar IEEE 754, rango, precisión y comportamientos particulares del tipo Number de JavaScript.