Cambiar pot_dyc() por pot_dyc_n() y pot_dyc_k().
El enunciado nos pide que se construyan dos versiones del algoritmo de
potenciacion por division y conquista que hagamos: una para la multiplicacion
naif y otra para la multiplicacion por Karatsuba-Ofman.
Este patch toma la funcion pot_dyc() y arma con ella las dos pedidas. Ademas
actualiza main.cpp y number.cpp acorde.

Agregar scripts de generacion y verificacion.

Hacer que pot_ko() use karatsuba().

Agrega explicación de la resta.

Implementa programa principal.
Implementación del programa principal con Makefile incluido. Por omisión compila
optimizado (en modo 'release' digamos), para compilar con símbolos de debug (y
dándole bola al assert y eso) usar: make DEBUG=1

Agregar algunos casos de prueba en number.cpp.

Acomodar ambas multiplicaciones.

Acomodar loop de menorEnModuloQue().

El signo no necesita ser mutable.

The ugliest patch ever.
Sí, es por lejos el parche más feo que hice en mi vida y no estoy nada
orgulloso, pero a esta altura no podemos ponernos en exquisitos =(

Implementa el constructor a partir de un string.
Lo hace a través de un parser que va construyendo el número grande evualuando un
polinomio de potencias de 10. El polinomio se evalua usando la Reglar de Horner).

resta corregida + un par de asserts

Agrega primer draft del informe.

Agrega carátula.

Agrega método menorEnModuloQue() para que vuelva a andar la resta.

Reescribe normalize_length().
Además de arreglar un bug, ahora normalize length también recorta los números si
tiene muchos ceros en la perte más significativa, de manera tal que no crezcan
exponencialmente (lo que acelera increíblemente las cosas).
Sigue dejando los números con tamaño potencia de 2, pero elimina todos los ceros
que puede en el camino.

Bugfix en normalize_length() (usaba una potencia más de la necesaria).

Bugfix a operator< para que compare bien dos números negativos.

Reimplementa operator< para que sea realmente const.
El operator< utilizaba la función normalize_length() que tomaba parámetros
variables. Ahora operator< es completamente const y no necesita normalizar los
argumentos.

Agrega assert a split para verificar que no se lo llame con un chunk de tamaño 1.

Cambia alineación de declaración de operadores.
Cambio meramente estético para que sea más claro visualmente.

Pone los constructores con inicializador atributo para el signo.

Acomodar signos en los constructores.

Contempla suma de números de signo distinto.
Utiliza a la resta para manejar esos casos. En el test quedó un caso que rompe
tanto a la suma (como resta) como a la potencia (por un problema que, como
mínimo, baja hasta la multiplicación).

Merge con parche anterior.

operator -=, borrow y el stdint.h para VC++

Potenciación con división y conquista.
Este parche agrega el algoritmo de potenciación por división y conquista. Además
agrega varios métodos y funciones complementarias:
dividido_dos(): devuelve el número dividido 2 O(n) (haciendo shift bit a bit)
es_impar(): indica si es impar O(1) (viendo el bit menos significativo)
operator==(): comparación O(n) (en el peor caso, que es cuando son iguales)

Simplifica salida de operator<< para ostream.
Sólo pone el signo si es negativo (y lo pone pegado al número). Así es más
natural para leer.

Agrega signo a la salida del operator<< para un ostream.

Bugfix en la suma.
Tenía un problema cuando el 2do operando era MAX - 1 y había carry, no se sumaba
nada y tampoco se detectaba que había carry (porque pega la vuelta
indefectiblemente, sin importar el valor del operando 1).

Fixito para pot_ko().
Nuestro template de numero no tiene el operador ++, por lo que usamos += 1 por
ahora.

Agregar karatsuba() y pot_ko().
En este patch se reintroduce karatsuba() (todavia no probado porque falta la
resta, pero no deberia distar mucho de su implementacion final) y pot_ko(),
tampoco probada. Soy un loco barbaro.

Implementar normalize_length() a potencia de 2.
Este patch hace que el normalize_lenght() redondee para arriba hasta la
potencia de 2 mas proxima.

Tambien saca la multiplicacion por Karatsuba, que sera reintroducida en un
patch a continuacion.

Invierte orden de native_type al imprimir para que se lea más natural.

Arregla fines de linea (saca \r) y otros detalles menores.

operator <

Agrega dependencia del .h en el Makefile de tests.

Bugfix de cast a la C++.

Usa naif() como operator*.

Casts a la C++ (static_cast).

Implementar el algoritmo naif de multiplicacion.

Sacamos el private por ahora.
Mientras estemos puertas adentro, seamos promiscuos. Despues vemos de
"emprolijar" esto.

Prototipo de karatsuba() con const y &.

Sacar el sign_type afuera.
Y que???

Acomodar el split().

Muestra salida con ancho fijo de native_type.

Salida en hexa.

Acomodar los retornos de linea en number.cpp.

Renombrar "divide_n_conquer" por "karatsuba".

Incluir stdint.h.

Acomodar indentacion a 80 cols y espacios en blanco.

Bugfixes para que compile.

Merge y limpieza.
Merge del parche que implementa K-O y limpieza de algunos \r y se ponen algunos
funciones como métodos. Si bien compila el test, puede explotar porque realmente
nunca está compilando la mayor parte de las cosas porque están parametrizadas y
no se usarn.

Casi casi divide and conquer

Reverse iterators para imprimir en orden

Para que compile en Visual C++ 6

Agrega parámetro para número extendido.
Además cambiar atomic_type por native_type y agrega parámetros por default.

Agrega signo (por ahora dummy).

Agrega enunciado.

Bugfix de propagación del carry.

Saca cosas inútiles del Makefile de test.

Documenta un poco y saca métodos grandes fuera de la declaración de la clase.

Estructura inicial y tipo básico.
Mini estructura de directorios con lo básico. Hay un tipo parametrizado
number< T > (diseñado para unsigned's, si anda con otra cosa es casualidad) que
ya tiene implementada la suma y una forma _muy_ precaria de imprimirse.
Lo básico como para empezar a trabajar.