1 Problema de demografía (ejercicio 2.1.3)

Los datos son poblaciones (en millones) de tres países en cuatro censos:

Con cuatro puntos por país buscamos, en cada caso, el único polinomio cúbico que pasa por ellos. Como ya vimos con los datos de población de China en la sección 2.1, conviene no trabajar directamente con los años (1990, 2000, …) como variable independiente, porque las potencias de números tan grandes producen una matriz de Vandermonde con columnas de magnitudes muy dispares y mal condicionada. En su lugar usamos

con lo que la matriz de Vandermonde queda con entradas entre y , mucho más manejable.

year = [1990, 2000, 2010, 2020]
t = (year .- 1990) ./ 10
V = [ t[i]^j for i in 1:4, j in 0:3 ]

(a) Estados Unidos en 2005. Resolviendo con los datos de Estados Unidos se obtiene el polinomio, en la variable ,

El año 2005 corresponde a . Evaluando,

c = V \ usa
p = Polynomial(c)
p(1.5)   # 295.83593750000006

(b) El pico de Polonia. Con los mismos nodos y los datos de Polonia se obtiene

Un máximo de en el intervalo cumple . Derivando,

y resolviendo la cuadrática salen dos raíces, y . Solo la primera cae dentro de la ventana de datos (, entre 1990 y 2020); la segunda corresponde a un año fuera de esa ventana (2028) y es un artefacto de extrapolar el comportamiento algebraico del polinomio más allá de donde hay datos, no algo en lo que debamos confiar (el mismo tipo de advertencia que discutimos sobre no usar un interpolante para predecir fuera del rango observado).

Revisando el signo de en cada raíz se confirma que es efectivamente un máximo y la otra raíz es un mínimo. Entonces el pico ocurre en

Es decir, según esta interpolación la población de Polonia alcanzó su máximo alrededor del año 2001, con algo más de 38,5 millones de habitantes, y descendió de forma sostenida en la década siguiente.

(c) La curva de India. El mismo procedimiento con los datos de India da un polinomio cúbico que, graficado junto con los cuatro puntos originales, se ve así:

La curva es suave y estrictamente creciente en todo el intervalo, sin ningún vaivén: con solo cuatro puntos y un cúbico no hay espacio para que aparezcan las oscilaciones que sí se ven con interpolantes de grado mucho más alto (el fenómeno de Runge, que se estudia más adelante en el capítulo 9). Aquí el interpolante se comporta como uno esperaría de una curva real de crecimiento poblacional.

2 Sistemas con matrices triangulares inferiores (algoritmo 2.3.1 (forwardsub))

El problema que resuelve este algoritmo es un sistema donde es triangular inferior, es decir, todas las entradas por encima de la diagonal son cero. La idea es que la primera ecuación del sistema involucra solamente a :

La segunda ecuación involucra a y , pero ya lo conocemos del paso anterior, así que despejamos :

y así sucesivamente: la ecuación involucra a , pero los primeros ya se calcularon en pasos anteriores, de modo que solo queda una incógnita por despejar. En general,

Este proceso, de avanzar calculando un componente a la vez, es lo que le da el nombre de sustitución hacia adelante. Su implementación en Julia sigue la fórmula al pie de la letra:

function forwardsub(L, b)
    n = size(L, 1)
    x = zeros(n)
    x[1] = b[1] / L[1, 1]
    for i in 2:n
        s = sum(L[i, j] * x[j] for j in 1:i-1)
        x[i] = (b[i] - s) / L[i, i]
    end
    return x
end

El primer componente se calcula aparte porque la suma vacía (de a ) le daría problemas al sum de Julia. Dentro del ciclo, s acumula exactamente la parte ya conocida de la ecuación , y la línea siguiente despeja .

Vale la pena notar el costo: cada paso hace multiplicaciones para formar la suma, así que el total en todo el algoritmo es del orden de operaciones, muy por debajo de las que cuesta resolver un sistema arbitrario por eliminación gaussiana completa. Esta es la razón por la que triangularizar un sistema primero (mediante la factorización LU de la siguiente sección) resulta tan valioso: una vez triangular, resolverlo es barato.

El algoritmo solo falla si algún es cero, porque ahí aparecería una división por cero; y por el Teorema 2.3.1 del libro, eso ocurre exactamente cuando es singular.

L = [-2 0 0; 1 -1 0; 3 2 1]
b = [-4, 2, 1]
x = forwardsub(L, b)   # [2.0, 0.0, -5.0]
b - L*x                 # [0.0, 0.0, 0.0]

3 ¿Mal condicionamiento o inestabilidad? (ejercicio 2.3.7)

El sistema es con

es triangular superior, así que se resuelve con sustitución hacia atrás (el análogo de forwardsub, pero empezando por ). Aplicando la fórmula fila por fila:

y en la primera fila,

Con aritmética exacta, entonces, sin importar los valores de y : los términos y se cancelan algebraicamente y desaparecen del resultado. El problema, visto así, es completamente inofensivo.

Pero eso es cierto solo en el papel. El algoritmo de sustitución hacia atrás no ve esa cancelación de antemano: primero calcula y guarda el número como una entrada de la matriz, y cuando es mucho más grande que , esa resta ya pierde casi todas las cifras significativas de antes de que el cálculo de siquiera empiece. Es la misma cancelación catastrófica de la nota de condicionamiento, aquí escondida dentro de una sola entrada de la matriz en vez de en la ecuación final.

Resolviendo con y en aritmética de doble precisión:

	calculado

function backsub(U, b)
    n = size(U, 1)
    x = zeros(n)
    x[n] = b[n] / U[n, n]
    for i in n-1:-1:1
        s = sum(U[i, j] * x[j] for j in i+1:n)
        x[i] = (b[i] - s) / U[i, i]
    end
    return x
end

α = 0.1
for k in 1:12
    β = 10.0^k
    U = [1 -1 0 (α-β) β; 0 1 -1 0 0; 0 0 1 -1 0; 0 0 0 1 -1; 0 0 0 0 1]
    b = [α, 0, 0, 0, 1]
    x = backsub(U, b)
    println(β, "  ", x[1], "  ", abs(x[1]-1))
end

2 La grande y la equivalencia asintótica

La pequeña sirve para decir que algo es despreciable frente a otra cantidad. Para decir que algo está acotado por otra cantidad, sin ser necesariamente despreciable, se usa la grande.

Decimos que cuando (la misma definición sirve para sucesiones, con ) si permanece acotado cerca de . Aquí la convención por defecto es distinta a la de la pequeña: si no se especifica , se sobreentiende (o para sucesiones), porque la grande es la que usamos para describir cuánto crece un algoritmo cuando el tamaño del problema crece, no el comportamiento local cerca de un punto.

Un tercer símbolo, más fino que la , es la equivalencia asintótica: decimos que cuando si Por ejemplo, cuando , y cuando .

Veamos con cuidado, directamente desde la definición, que . El cociente tiende a cuando , así que existe tal que para todo ese cociente es menor que, digamos, : en particular está acotado, que es justamente lo que pide la definición de .

Este argumento se generaliza de inmediato: si y son positivas y el límite existe y es finito, entonces automáticamente , porque un cociente convergente en particular está acotado.

Con esta observación es fácil clasificar sumas que aparecen todo el tiempo al contar operaciones. Por ejemplo, así que . Técnicamente también es cierto que , o de cualquier potencia mayor, pero esa afirmación, aunque verdadera, casi no dice nada: en la práctica siempre buscamos la función más pequeña posible para la cual se cumple, porque es ahí donde la notación aporta información útil. El mismo argumento con la suma de cuadrados da , y en general .

3 Conteo de flops

Un flop (floating point operation) es una suma, resta, multiplicación, división o raíz cuadrada entre números de punto flotante. FLOPS (con S final) son flops por segundo, la unidad con la que se mide la capacidad de cómputo de una máquina. Se usan los prefijos usuales de potencias de mil:

Prefijo	Símbolo	Factor
kilo	K
mega	M
giga	G
tera	T
peta	P

Para dar un par de puntos de referencia: el supercomputador Lonestar6 (TACC) tiene una capacidad de cómputo del orden de PFLOPS, es decir, unas operaciones de punto flotante por segundo. Un computador portátil corriente, como los que usamos en clase, es menor que un 1 TFLOPS.

En Julia, LinearAlgebra.peakflops() mide directamente la capacidad de tu propia máquina, y BenchmarkTools.jl (para medir tiempos), junto con alguna herramienta de conteo de flops, permite estimar cuántas operaciones de punto flotante consume una función específica.

4 Ejemplo: flops del producto matriz-vector

Supongamos que y , y queremos calcular . Cada componente de es que cuesta productos y sumas: unas operaciones si no nos preocupamos por el término de orden inferior. En código, el patrón para calcular una sola fila se ve así:

for j in 1:n
    y[i] += A[i, j] * x[j]
end

Ese bucle interno tiene dos operaciones de punto flotante (una suma y un producto) repetidas veces, y hay que repetirlo para cada una de las filas. El total es es decir, la cuenta crece del orden de operaciones de punto flotante: el algoritmo es .

Vale la pena ser precisos sobre qué mide esto. Cuando decimos que un algoritmo tiene complejidad computacional (temporal) , estamos contando exclusivamente el número de operaciones aritméticas en función del tamaño de la entrada, sin tener en cuenta todavía los recursos concretos de la máquina donde corre: acceso a memoria, caché, paralelismo. Esa es una capa adicional, real e importante en la práctica, que dejamos de lado por ahora para quedarnos con la pregunta puramente matemática de cuántas operaciones exige el algoritmo.

5 Comparando teoría y práctica: gráficas log-log

El conteo de flops da una predicción teórica de cómo debería crecer el tiempo de ejecución de un algoritmo, pero conviene contrastarla con mediciones reales (por ejemplo, con @time o BenchmarkTools.jl). Si el tiempo de un algoritmo obedece para alguna constante y algún exponente (el mismo que predice el conteo de flops), tomando logaritmo en ambos lados se obtiene Esta es la ecuación de una recta en el plano , con pendiente . Por eso, al graficar tiempos medidos contra en escala log-log, un algoritmo de complejidad debería verse como una línea recta de pendiente aproximadamente : la pendiente medida en la gráfica se compara directamente contra el exponente que predijo el conteo de flops, y una discrepancia entre ambos es indicio de que la implementación real no se comporta como el conteo teórico predice (acceso a memoria, alojamiento innecesario de arreglos, etc.).

1 La rejilla de la máquina

Trabajando en precisión doble de IEEE 754 (52 bits de mantisa), la distancia entre dos números de punto flotante consecutivos cerca de un valor (la unidad en el último lugar, o ULP) es aproximadamente

Con su asignado, calculen , determinen si y se almacenan como el mismo número de punto flotante o son distinguibles, y si son distinguibles calculen cuántos números representables existen estrictamente entre y . Antes de tocar Julia, con base en esto, predigan si esperan que el algoritmo ingenuo para sea preciso o falle catastróficamente, y por qué.

TipSolución

Si es el espaciado entre flotantes consecutivos, un intervalo de longitud 1 contiene huecos iguales entre marcas; por conteo de postes de cerca, eso deja representables estrictamente adentro (sin contar los dos extremos):

siempre un entero exacto, porque es potencia de 2.

			?	# representables entre y
	6		No
	9		No
	13		No
	16		No
	19		No

En ninguno de estos valores y colapsan al mismo flotante (eso solo ocurre desde ), así que en este rango se predice degradación progresiva del algoritmo ingenuo, pero no un colapso total.

2 El expediente del condicionamiento

Deriven el número de condición relativo de , calculen , y evalúen para su valor asignado. Con esta evidencia sola, sin haber corrido nada todavía, ¿el problema es responsable de un eventual fallo? Justifiquen.

TipSolución

Con , factorizando por diferencia de raíces se obtiene , así que

Como ,

y como para todo , de hecho siempre: el problema nunca amplifica el error relativo de entrada más de la mitad, en ningún punto de su dominio.

El problema está óptimamente condicionado en todo el rango asignado ( siempre): si el algoritmo ingenuo falla, la responsabilidad es exclusivamente del algoritmo, no de .

3 El interrogatorio en Julia

Implementen el algoritmo ingenuo sqrt(x+1) - sqrt(x) y evalúenlo en . Encuentren, mediante racionalización, una forma equivalente de que evite restar cantidades casi iguales, e impleméntenla. Usando BigFloat como referencia de alta precisión, construyan una tabla comparando ambos algoritmos en un barrido que incluya su . Escriban su veredicto forense en 4 o 5 líneas: si el problema está bien o mal condicionado, en qué paso exacto entra la inestabilidad, y cuál algoritmo recomiendan.

TipSolución

La racionalización multiplica y divide por el conjugado:

f_ingenuo(x)    = sqrt(x + 1) - sqrt(x)
f_estable(x)    = 1 / (sqrt(x + 1) + sqrt(x))
f_referencia(x) = Float64(sqrt(BigFloat(x) + 1) - sqrt(BigFloat(x)))

f_estable solo suma cantidades positivas, así que no hay cancelación posible en ningún paso.

	ingenuo	estable	error rel. ingenuo	error rel. estable
		igual
		igual
		igual
		igual

En este rango el error del algoritmo ingenuo nunca supera : todavía está lejos del colapso, pero ya muestra degradación consistente y medible frente al estable, que se mantiene en o en el orden de en todos los casos.

Veredicto modelo: “El problema en tiene : bien condicionado, y de hecho para todo . El algoritmo ingenuo pierde precisión progresivamente porque en el paso se restan dos cantidades cada vez más parecidas a medida que crece; aunque en este rango no llega a colapsar del todo, la tendencia ya es clara y se vuelve catastrófica para mucho mayores (a partir de , donde y dejan de ser distinguibles). La causa es inestabilidad algorítmica, no mal condicionamiento. La forma racionalizada, al no restar cantidades parecidas, mantiene precisión de máquina en todo el rango probado.”

2 Estudio de caso: evaluación de un polinomio — el método de Horner

Antes de hablar de estabilidad numérica, vale la pena ver un ejemplo de que “distintos algoritmos para el mismo problema” no es solo una cuestión de precisión: también puede ser una cuestión de eficiencia.

Consideremos

Evaluación directa. Calculamos (1 producto), luego (1 producto más), y finalmente los tres productos , , (3 productos). En total: 5 productos y 3 sumas — 8 operaciones aritméticas.

Método de Horner. Reescribimos anidando la variable: Cada uno de los tres paréntesis cuesta exactamente 1 producto y 1 suma: 3 productos y 3 sumas — 6 operaciones en total.

El método de Horner ahorra el 25% del esfuerzo computacional respecto a la evaluación directa, y esta ventaja crece con el grado del polinomio: para grado , la evaluación directa requiere productos (si no se reutiliza ) o al menos productos y sumas incluso reutilizando potencias, mientras que Horner siempre usa exactamente productos y sumas.

"""
    horner(coefs, x)

Evalúa el polinomio con coeficientes `coefs = [a_n, a_{n-1}, ..., a_1, a_0]`
(de mayor a menor grado) en el punto `x`, usando el método de Horner.
"""
function horner(coefs, x)
    resultado = coefs[1]
    for c in coefs[2:end]
        resultado = resultado * x + c
    end
    return resultado
end

@show horner([5, 4, 3, 2], 2.0)   # p(2) = 5·8 + 4·4 + 3·2 + 2 = 64

horner([5, 4, 3, 2], 2.0) = 64.0

3 Ejercicio 1.4.2 —

using ForwardDiff

f(x) = x == 0 ? 1.0 : (exp(x) - 1)/x
κ(x) = abs(x * ForwardDiff.derivative(f, x) / f(x))

xs = range(-1, 1, length=20001)
kmax, imax = findmax(κ.(xs))
kmin, imin = findmin(κ.(xs))

@show xs[imax], kmax   # (1.0, 0.5819767068693265)
@show xs[imin], kmin   # (0.0, 0.0)
@show 1/(exp(1)-1)      # 0.5819767068693265  -- coincide exactamente

(xs[imax], kmax) = (1.0, 0.5819767068693265)
(xs[imin], kmin) = (0.0, 0.0)
1 / (exp(1) - 1) = 0.5819767068693265

3.2 (b)–(d) Dos algoritmos para el mismo problema

Algoritmo ingenuo: evaluar tal cual, con la resta explícita.

f_ingenuo(x) = (exp(x) - 1)/x

Algoritmo por serie de Maclaurin (8 términos):

function p_maclaurin(x)
    s = 0.0
    for k in 0:7
        s += x^k / factorial(k+1)
    end
    return s
end

Evaluando ambos en y comparando contra un valor de referencia de alta precisión:

	ingenuo	Maclaurin (8 términos)	error rel. ingenuo	error rel. Maclaurin

Importante¿Cuál es más preciso, y por qué?

El algoritmo de Maclaurin es dramáticamente más preciso: mantiene error relativo cercano a (–) en todo el rango, mientras que el ingenuo se degrada progresivamente — de en a en , donde el error deja de crecer porque toca el límite de lo que la representación de misma permite distinguir.

La razón es exactamente la del Ejemplo 1.4.1: el algoritmo ingenuo calcula (que para pequeño está muy cerca de ) y luego resta , cancelando los primeros dígitos compartidos y dejando expuesto el ruido de redondeo de como si fuera señal. El polinomio de Maclaurin, en cambio, nunca resta cantidades parecidas: todos sus términos para son positivos y decrecientes, así que solo hay sumas de cantidades del mismo signo — sin cancelación posible.

Nótese que cuando : el problema se vuelve más fácil, no más difícil, cerca de cero. La degradación del algoritmo ingenuo no tiene nada que ver con el condicionamiento — es pura inestabilidad algorítmica, el mismo fenómeno ya documentado para en la nota de condicionamiento, ahora cuantificado en todo el intervalo y comparado explícitamente contra una alternativa estable.

4 Conexión con la nota de condicionamiento

Este ejercicio es la contraparte natural de lo visto en la nota anterior: allí establecimos que es un problema bien condicionado cerca de cero (); aquí confirmamos que esa buena condición se sostiene en todo (máximo ), y mostramos dos algoritmos concretos para el mismo problema — uno inestable (cancelación explícita) y uno estable (serie de Maclaurin, sin resta de cantidades parecidas) — cuantificando la brecha entre ellos. Es exactamente el mismo patrón del Ejemplo 1.4.1: problema bien condicionado, algoritmo mal elegido, error inexplicable por el condicionamiento — y una alternativa que lo resuelve sin cambiar el problema, solo la ruta de cálculo.

2 El número de condición relativo

La pregunta natural es: ¿qué tan sensible es un problema, independientemente del algoritmo o la máquina que se use para resolverlo?

3 Ejercicio 1.2.3 —

4 Comportamiento de en

Ya sabemos que . Para completar el panorama, veamos qué le pasa a , con y , en los dos extremos.

Cuando : tanto como divergen ( domina en ambos), así que es indeterminado y L’Hôpital aplica:

(se usó y ; tras una sola aplicación de L’Hôpital el cociente ya se simplifica sin quedar indeterminado). Entonces : el problema se vuelve arbitrariamente mal condicionado para grande — aunque de forma “mansa”, porque crece solo linealmente (no exponencialmente).

Cuando : aquí no hay indeterminación, porque y ambos, numerador y denominador, convergen a valores finitos directamente:

( porque la exponencial decae más rápido de lo que cualquier polinomio crece)

En resumen

Para , queda acotado entre 0 y 1: el problema está uniformemente bien condicionado en todo el semieje negativo. Para positivo y grande, el problema se vuelve mal condicionado, pero solo linealmente (consistente con los valores numéricos: , , , ).

5 Ejercicio 1.2.5 — condición del inverso

Sea con número de condición , y su inversa. Queremos mostrar

Demostración, sin invocar el teorema de la función inversa: sea .

Primero, : con , .

Por la regla de la cadena para números de condición (ejercicio 1.2.4), aplicada a :

Como , . Despejando:

Esta ruta es más corta que aplicar el teorema de la función inversa directamente, y no exige demostrar por separado que es derivable.

6 Raíces de un polinomio cuadrático

Consideremos . Los datos son los coeficientes ; el resultado son las raíces (posiblemente complejas). Formalmente, .

Fijamos y perturbamos solo el coeficiente principal , para ver cómo responde : . Partiendo de la identidad y derivando implícitamente respecto a (con fijos):

Usando la fórmula cuadrática, :

El problema está mal condicionado exactamente cuando — es decir, cuando las raíces están mucho más cerca entre sí que del origen. En el caso extremo de una raíz doble (), .

7 Simulación — sensibilidad de las raíces de

Para hacer tangible la fórmula anterior, parametrizamos el polinomio directamente por sus raíces y su coeficiente principal :

de modo que, en ausencia de redondeo, las raíces son exactamente y para cualquier . La simulación perturba solo el coeficiente , mantiene fijos (tal como en la derivación de ), recalcula las raíces con la fórmula cuadrática, y compara:

• el error relativo predicho por la teoría:
• el error relativo real, medido directamente sobre la raíz recalculada

Mueve los controles y observa qué pasa con cuando y se acercan.

8 Tarea

Resolver los siguientes ejercicios de la sección 1.2 (“Exercises”) de Fundamentals of Numerical Computation, disponibles en https://fncbook.com/julia/conditioning/#exercises:

2 El sistema posicional decimal

Fracciones simples:

Forma general de un número posicional, con dígitos :

3 Otras bases

la expansión termina exactamente, porque .

Para contraste, en base 3 no termina:

Alfabetos según la base:

• Binario: → un dígito es un bit
• Octal: → un dígito octal (byte) representa 3 bits
• Hexadecimal: → un dígito hexadecimal (nibble) representa 4 bits

Correspondencia binario ↔︎ octal (3 bits):

4 El conjunto 𝔽 de números de punto flotante

• exponente
• significando (mantisa)
• 
• se llama la precisión binaria

5 Cuántos elementos de 𝔽 hay por binade

Referencia de las notas: float32/float → ; float64/double → (IEEE 754).

6 Espaciado dentro de un binade

Retomando con , si :

— el mismo espacio; hay números.

El binade empieza en (es decir, en ) y termina en :

7 Machine epsilon

El número que le sigue a 1 es , entonces el épsilon de máquina es

Definimos .

La distancia en cada binade es .

Cada número real está a una distancia a lo más

8 De error absoluto a error relativo

Al dividir por :

9 Precisión y exactitud

Si expresamos

en base 10, se convierte en

donde cada y . Esto no es otra cosa que la notación científica, con cifras significativas.

La precisión de un número flotante son los dígitos binarios. La exactitud es qué tan lejos está la aproximación del resultado.

Si es la aproximación de :

• Exactitud absoluta: — mismas unidades que .
• Exactitud relativa: — adimensional.

Por ejemplo, si la exactitud de la aproximación anterior es , el entero más cercano a

da la “cantidad de dígitos de exactitud”, sin necesidad de aproximarlo al entero:

(el logaritmo cuenta esa cadena inicial de ceros). Ejemplo clásico: frente a .

9.1 El estándar IEEE 754

Tipo	(bits de significando)	(bits de exponente)
Float32 (precisión sencilla)	23	8
Float64 (precisión doble)	52	11

Con las funciones sign, exponent y significand podemos extraer las partes de un .

10 Aritmética de máquina

La aritmética se calcula de tal manera que si , entonces de tal manera que

Estos ejemplos muestran que la ley asociativa de la suma se rompe en aritmética de punto flotante: el orden en que se agrupan las operaciones puede cambiar el resultado.

11 Tarea

Resolver todos los ejercicios de la sección 1.1.4 (“Exercises”) de Fundamentals of Numerical Computation, disponibles en https://fncbook.com/julia/floating-point/#exercises: los ejercicios 1.1.1 a 1.1.5, sobre el conjunto , la equivalencia de las cotas de error, aproximaciones racionales a , precisión sencilla IEEE 754, y nextfloat.