¿Cómo puedo calcular la serie de Fibonacci en Austra, utilizando una secuencia? Con vectores (voy a usar vectores y secuencias reales para evitar problemas de desbordamiento), es relativamente sencillo, si aprovechamos los safe indexers en una expresión lambda:
vec::new(128, (i, v) =>
if i = 0 then 1 else v{i-1} + v{i-2})
El problema de esta solución es que consume memoria. Tenemos los dos últimos números generados a la izquierda (por así decirlo) del número que estamos generando, pero en realidad, es porque tenemos todo la memoria del vector ya reservada. ¿Y si quisiéramos hacerlo con las nuevas secuencias?
La solución en lenguajes funcionales
Los lenguajes funcionales suelen usar una función unfold para estos casos. Por ejemplo, en F# se define unfold de esta manera:
val unfold : ('State -> ('T * 'State) option) -> 'State -> seq<'T>
La función, en sí, escrita como una secuencia infinita, sería más o menos esto.
let fib = Seq.unfold (fun (lastValue, currentValue)
-> Some (lastValue,
(currentValue, lastValue + currentValue))) (1, 1)
Ahora, las explicaciones: necesitaríamos que Austra fuese un lenguaje con tipos genéricos e inferencia automática de tipos… y no es un objetivo mío a corto plazo. Nyx, que es una idea de lenguaje con capacidades numéricas y aceleración que me guardo bajo la manga, tendrá genericidad, pero no estoy del todo convencido que tenga que ser funcional «puro». La función en F#, que sería casi idéntica en Haskell, necesita un «estado» para ir arrastrando en las sucesivas llamadas. En el caso de Fibonacci, el estado son los últimos dos números generados.
De regreso a Austra
No obstante, podemos hacer algo útil para el 99% de los casos. Estos son los tres métodos que se han implementado en C# para soportar unfold en el lenguaje de fórmulas:
public static DSequence Unfold(int size, double seed, Func<double, double> unfold); public static DSequence Unfold(int size, double seed, Func<int, double, double> unfold); public static DSequence Unfold(int size, double first, double second, Func<double, double, double> unfold);
La idea es proporcionar sobrecargas para los casos más frecuentes. El primer caso es para cuando el estado es un solo número real. El segundo caso es más sutil: el estado es un número real… más la posición del elemento que se va a generar. Si estuviésemos en un lenguaje funcional, esa posición tendría que estar explícitamente representada en el estado. Y en el tercer caso, el estado son dos números reales, como necesitamos para la secuencia de Fibonacci.
Veamos ahora cómo se usa esto en el lenguaje de fórmulas:
-- Potencias de 2, desde 2 a 1024. seq::unfold(10, 2, x => 2x); -- Serie de Maclaurin para exp(1). 1 + seq::unfold(100000, 1, (n, x) => x / (n + 1)).sum;
He tenido que sumar explícitamente un uno a la serie de Maclaurin, porque era lo más sencillo. Si quiere practicar, piense en cómo calcular ln(2) con una secuencia de estas.
La secuencia de Fibonacci se calcula así:
seq::unfold(50, 1, 1, (x, y) => x + y);
Con números enteros, haríamos esto:
iseq::unfold(30, 1, 1, (x, y) => x + y);
No es la solución perfecta, pero es fácil de entender, y encima se ejecuta con rapidez.
Algo curioso relacionado con el diseño de lenguajes: imagine un lenguaje que ofrece un vec<double> y un vec<complex>, en vez del vec y el cvec del lenguaje de fórmulas de Austra. ¿Se ha dado cuenta de que el vector de complejos no podría soportar todas las operaciones del vector de números reales? El caso más evidente: no se puede ordenar el vector de complejos, ni calcular la entrada con el menor o mayor valor. Los números complejos no soportan un orden total que tenga sentido. ¿Cómo haría usted para que una clase genérica tuviese en cuenta estos detalles? Ahora mismo, si quieres hacer esto en C#, tienes que definir una clase genérica «recortada», en plan Vec<T>, y las clases finales serán clases que ya no serán genéricas, pero que añadirían la funcionalidad no común. Algo así es que lo hace Math.NET.
Ese es el problema que intento resolver: un lenguaje de programación con auto-vectorización, en el que programar una librería como la de Austra no sea tan complicado, y que me deje definir tipos matemáticos como el vector de complejos y el vector de reales utilizando una base común genérica. Hay más cosas en las matemáticas que no se ajustan a la idea de la programación de que «lo derivado tiene más operaciones».