From: Alberto Bertogli <albertogli@telpin.com.ar>
Date: Tue, 4 Oct 2005 04:29:57 +0000 (+0000)
Subject: Implementar normalize_length() a potencia de 2.
X-Git-Tag: Entrega_1~41
X-Git-Url: https://git.llucax.com/z.facultad/75.29/dale.git/commitdiff_plain/cbfd67d82e0913165b67283f702b00b781e7b3ae?ds=inline

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.
---

diff --git a/src/number.h b/src/number.h
index 1e857ac..2c2d281 100644
--- a/src/number.h
+++ b/src/number.h
@@ -103,9 +103,6 @@ struct number
 	sign_type sign;
 
 	// Helpers
-	// Normaliza las longitudes de 2 numbers, completando con 0s a la izquierda
-	// al más pequeño. Sirve para División y Conquista
-	number& normalize_length(const number& n);
 	// parte un número en dos mitades de misma longitud, devuelve un par de
 	// números con (low, high)
 	std::pair< number, number > split() const;
@@ -253,10 +250,9 @@ bool number< N, E >::operator< (const number< N, E >& n)
 	number< N, E > n2 = n;
 
 	// igualo los largos
-	n1.normalize_length(n2);
-	n2.normalize_length(n1);
+	normalize_length(n1, n2);
 
-	// obtengo el largo 
+	// obtengo el largo
 	size_type length = n1.chunk.size();
 	size_type i = length - 1;
 
@@ -324,20 +320,6 @@ number< N, E > operator* (const number< N, E >& n1, const number< N, E >& n2)
 	return naif(n1, n2);
 }
 
-template < typename N, typename E >
-number< N, E >& number< N, E >::normalize_length(const number< N, E >& n)
-{
-	// si son de distinto tamaño tengo que agregar ceros a la izquierda al
-	// menor para división y conquista
-	while (chunk.size() < n.chunk.size())
-	{
-		chunk.push_back(0);
-	}
-
-	return *this;
-
-}
-
 template < typename N, typename E >
 std::pair< number< N, E >, number< N, E > > number< N, E >::split() const
 {
@@ -366,40 +348,36 @@ std::pair< number< N, E >, number< N, E > > number< N, E >::split() const
 	return par;
 }
 
-// es el algoritmo de división y conquista, que se llama recursivamente
+
 template < typename N, typename E >
-number < N, E > karatsuba(const number< N, E > &u, const number< N, E > &v)
+void normalize_length(number< N, E >& u, number< N, E >& v)
 {
 	typedef number< N, E > num_type;
+	typename num_type::size_type max, p, t, pot2;
 
-	// tomo el chunk size de u (el de v DEBE ser el mismo)
-	typename num_type::size_type chunk_size = u.chunk.size();
+	max = std::max(u.chunk.size(), v.chunk.size());
 
-	if (chunk_size == 1)
-	{
-		// condición de corte. Ver que por más que tenga 1 único
-		// elemento puede "rebalsar" la capacidad del atomic_type,
-		// como ser multiplicando 0xff * 0xff usando bytes!!!
-		return u.chunk[0] * v.chunk[0];
+	/* Buscamos hacer crecer a ambos a la potencia de 2 mas proxima; para
+	 * lo cual la obtenemos y guardamos en p. */
+	t = max;
+	p = 0;
+	while (t != 0) {
+		t = t >> 1;
+		p++;
 	}
 
-	std::pair< num_type, num_type > u12 = u.split();
-	std::pair< num_type, num_type > v12 = v.split();
+	/* Ahora guardamos en pot2 el tamaño que deben tener. */
+	pot2 = 1 << p;
 
-	// Los nombres M, D y H los puso Rosita en clase, cambiar si se les
-	// ocurren algunos mejores!
-	// m = u1*v1
-	// d = u2*v2
-	// h = (u1+v1)*(u2+v2) = u1*u2+u1*v2+u2*v1+u2*v2
-	num_type m = karastuba(u12.first, v12.first);
-	num_type d = karastuba(u12.second, v12.second);
-	num_type h = karastuba(u12.first + v12.first,
-			u12.second + v12.second);
+	/* Y finalmente hacemos crecer los dos numeros agregando 0s hasta
+	 * completar sus tamaños. */
+	while (u.chunk.size() < pot2)
+		u.chunk.push_back(0);
 
-	// H-D-M = u1*u2+u1*v2+u2*v1+u2*v2 - u2*v2 - u1*v1 = u1*v2+u2*v1
-	// u1*v1 << base^N + u1*v2+u2*v1 << base^N/2 + u2*v2
-	return (m << chunk_size) + ((h - d - m) << chunk_size / 2) + h;
+	while (v.chunk.size() < pot2)
+		v.chunk.push_back(0);
 
+	return;
 }
 
 
@@ -467,6 +445,7 @@ number < N, E > naif(const number< N, E > &u, const number< N, E > &v)
 	/* u*v = (u1*v1) * 2^n + (u1*v2 + u2*v1) * 2^(n/2) + u2*v2
 	 * PERO! Como los numeros estan "al reves" nos queda:
 	 *     = m22 * 2^n + (m12 + m21) * 2^(n/2) + m11
+	 * FIXME: seria mejor hacer el acomode en la llamada a naif arriba?
 	 */
 	num_type res;
 	res = m22 << chunk_size;