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.