-}\r
-\r
-// Normaliza las longitudes de 2 numbers, completando con 0s a la izquierda\r
-// al más pequeño. Sirve para División y Conquista\r
-template < typename T >\r
-void normalize_length (number< T >& l_op, number< T >& r_op)\r
-{\r
- //si son de distinto tamaño tengo que agregar ceros a la izquierda al menor para división y conquista\r
- while (l_op.chunk.size()<r_op.chunk.size())\r
- {\r
- l_op.chunk.push_back(0);\r
- }\r
-\r
- while (l_op.chunk.size()>r_op.chunk.size())\r
- {\r
- r_op.chunk.push_back(0);\r
- }\r
-\r
- //si no tiene cantidad par de números le agrego un atomic_type 0 a la izquierda para no tener que contemplar\r
- //splits de chunks impares\r
- if (l_op.chunk.size()%2 != 0)\r
- {\r
- l_op.chunk.push_back(0);\r
- r_op.chunk.push_back(0);\r
- }\r
-}\r
-\r
-//parte un número en dos mitades de misma longitud\r
-template < typename T >\r
-void split (const number< T >&full, number< T >& upper_half, number< T >& lower_half)\r
-{\r
- size_type full_size = full.chunk.size();\r
- size_type halves_size = full_size / 2;\r
- size_type i = 0;\r
-\r
- // vacío las mitades\r
- upper_half.chunk.clear();\r
- lower_half.chunk.clear();\r
-\r
- // la primera mitad va al pedazo inferior\r
- for (i = 0; i < halves_size; i++)\r
- {\r
- lower_half.chunk.push_back(full.chunk[i]);\r
- }\r
-\r
- // la segunda mitad (si full_size es impar es 1 más que la primera mitad) va al pedazo superior\r
- for ( ; i < full_size; i++)\r
- {\r
- upper_half.chunk.push_back(full.chunk[i]);\r
- }\r
-}\r
-\r
-// es el algoritmo de división y conquista, que se llama recursivamente\r
-template < typename T >\r
-number < T > divide_n_conquer (number< T > u, number< T > v)\r
-{\r
- //tomo el chunk size de u (el de v DEBE ser el mismo)\r
- size_type chunk_size = u.chunk.size();\r
- \r
- if (chunk_size == 1)\r
- {\r
- //condición de corte. Ver que por más que tenga 1 único elemento puede "rebalsar" la capacidad\r
- //del atomic_type, como ser multiplicando 0xff * 0xff usando bytes!!!\r
- return u.chunk[0]*v.chunk[0];\r
- }\r
- \r
- number < T > u1, u2, v1, v2;\r
- split (u, u1, u2);\r
- split (v, v1, v2);\r
-\r
- // Los nombres M, D y H los puso Rosita en clase, cambiar si se les ocurren algunos mejores!\r
- // M = u1*v1\r
- // D = u2*v2\r
- // H = (u1+v1)*(u2+v2) = u1*u2+u1*v2+u2*v1+u2*v2\r
- number < T > M = divide_n_conquer (u1, v1);\r
- number < T > D = divide_n_conquer (u2, v2);\r
- number < T > H = divide_n_conquer (u1+v1, u2+v2);\r
-\r
- // H-D-M = u1*u2+u1*v2+u2*v1+u2*v2 - u2*v2 - u1*v1 = u1*v2+u2*v1\r
- // u1*v1 << base^N + u1*v2+u2*v1 << base^N/2 + u2*v2\r
- return (M << chunk_size) + ((H-D-M) << chunk_size/2) + H;\r
- \r
-}\r
-\r
-template < typename T >
-number< T >& number< T >::operator*= (const number< T >& n)\r
-{\r
- number < T > r_op = n;\r
-\r
- normalize_length(*this, n);\r
- *this = divide_n_conquer(*this, n);\r
- \r
- return *this;\r
-}\r
-\r
-template < typename T >\r
-number< T > operator* (const number< T >& n1, const number< T >& n2)\r
-{\r
- number< T > tmp = n1;\r
- tmp *= n2;\r
- return tmp;\r
-}\r
+}
+
+template < typename N, typename E >
+std::string numberToHex(const number< N, E >& n)
+{
+ std::ostringstream os;
+ typename number< N, E >::const_reverse_iterator i = n.chunk.rbegin();
+ typename number< N, E >::const_reverse_iterator end = n.chunk.rend();
+ // Salteo ceros
+ for (; i != end; ++i)
+ if (*i != 0)
+ break;
+ if (i != end) // Si no llegué al final, imprimo sin 'leading zeros'
+ {
+ os << std::hex << *i;
+ ++i; // y voy al próximo
+ }
+ // imprimo el resto con 'leading zeros'
+ for (; i != end; ++i)
+ os << std::setfill('0') << std::setw(sizeof(N) * 2) << std::hex
+ << *i;
+ return os.str();
+}
+
+template < typename N, typename E >
+std::string numberToHexDebug(const number< N, E >& n)
+{
+ std::ostringstream os;
+ // FIXME sacar una salida bonita en ASCII =)
+ if (n.sign == negative)
+ os << "-";
+ typename number< N, E >::const_reverse_iterator i = n.chunk.rbegin();
+ typename number< N, E >::const_reverse_iterator end = n.chunk.rend();
+ for (; i != end; ++i)
+ os << std::setfill('0') << std::setw(sizeof(N) * 2) << std::hex
+ << *i << " ";
+ return os.str();
+}
+
+template < typename N, typename E >
+bool number< N, E >::operator==(const number< N, E >& n) const
+{
+ if (sign != n.sign)
+ {
+ return false;
+ }
+
+ size_type ini = 0;
+ size_type fin = std::min(chunk.size(), n.chunk.size());
+ size_type i; //problema de VC++, da error de redefinición
+
+ // "intersección" entre ambos chunks
+ // +-----+-----+------+------+
+ // | | | | | <--- mio
+ // +-----+-----+------+------+
+ // +-----+-----+------+
+ // | | | | <--- chunk de n
+ // +-----+-----+------+
+ //
+ // |------------------|
+ // Esto se procesa en este for
+ for (i = ini; i < fin; ++i)
+ {
+ if (chunk[i] != n.chunk[i])
+ {
+ return false;
+ }
+ }
+
+ // si mi chunk es más grande que el del otro, sólo me queda
+ // ver si el resto es cero.
+ chunk_type const *chunk_grande = 0;
+ if (chunk.size() > n.chunk.size())
+ {
+ chunk_grande = &chunk;
+ fin = chunk.size() - n.chunk.size();
+ }
+ else if (chunk.size() < n.chunk.size())
+ {
+ chunk_grande = &n.chunk;
+ fin = n.chunk.size() - chunk.size();
+ }
+
+ // Si tienen tamaños distintos, vemos que el resto sea cero.
+ if (chunk_grande)
+ {
+ for (; i < fin; ++i) // Sigo desde el i que había quedado
+ {
+ if ((*chunk_grande)[i] != 0)
+ {
+ return false;
+ }
+ }
+ }
+ return true; // Son iguales
+}
+
+template < typename N, typename E >
+number< N, E >& number< N, E >::operator*= (const number< N, E >& n)
+{
+ *this = naif(*this, n);
+ return *this;
+}
+
+template < typename N, typename E >
+number< N, E > operator* (const number< N, E >& n1, const number< N, E >& n2)
+{
+ return naif(n1, n2);
+}
+
+template < typename N, typename E >
+std::pair< number< N, E >, number< N, E > > number< N, E >::split() const
+{
+ assert(chunk.size() > 1);
+ typedef number< N, E > num_type;
+ typename num_type::size_type full_size = chunk.size();
+ typename num_type::size_type halves_size = full_size / 2;
+ typename num_type::size_type i = 0;
+
+ // vacío las mitades
+ std::pair< num_type, num_type > par;
+
+ // la primera mitad va al pedazo inferior
+ par.first.chunk[0] = chunk[0];
+ for (i = 1; i < halves_size; i++)
+ {
+ par.first.chunk.push_back(chunk[i]);
+ }
+
+ // la segunda mitad (si full_size es impar es 1 más que la primera
+ // mitad) va al pedazo superior
+ par.second.chunk[0] = chunk[i];
+ for (i++ ; i < full_size; i++)
+ {
+ par.second.chunk.push_back(chunk[i]);
+ }
+ return par;
+}
+
+
+// Lleva los tamaños de chunk a la potencia de 2 más cercana, eliminando o
+// agregando ceros.
+template < typename N, typename E >
+void normalize_length(const number< N, E >& u, const number< N, E >& v)
+{
+ typename number< N, E >::size_type max, p, t, pot2, size_u, size_v;
+
+ // Busco el primer chunk no nulo de u
+ for (size_u = u.chunk.size() - 1; size_u != 0; --size_u)
+ if (u.chunk[size_u] != 0)
+ break;
+ size_u++;
+
+ // Busco el primer chunk no nulo de v
+ for (size_v = v.chunk.size() - 1; size_v != 0; --size_v)
+ if (v.chunk[size_v] != 0)
+ break;
+ size_v++;
+
+ max = std::max(size_u, size_v);
+
+ /* 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 ((1u << p) < max)
+ p++;
+
+ /* Ahora guardamos en pot2 el tamaño que deben tener. */
+ pot2 = 1 << p;
+
+ /* Y finalmente hacemos crecer los dos numeros agregando 0s hasta
+ * completar sus tamaños. */
+ u.chunk.resize(pot2, 0);
+ v.chunk.resize(pot2, 0);
+}
+
+
+/* Algoritmo "naif" (por no decir "cabeza" o "bruto") de multiplicacion. */
+template < typename N, typename E >
+number < N, E > naif(const number< N, E > &u, const number< N, E > &v)
+{
+ typedef number< N, E > num_type;
+
+ normalize_length(u, v);
+
+ /* como acabo de normalizar los tamaños son iguales */
+ typename num_type::size_type chunk_size = u.chunk.size();
+
+ sign_type sign;
+
+ if (u.sign == v.sign) {
+ sign = positive;
+ } else {
+ sign = negative;
+ }
+
+ if (chunk_size == 1)
+ {
+ /* Si llegamos a multiplicar dos de tamaño 1, lo que hacemos
+ * es usar la multiplicacion nativa del tipo N, guardando el
+ * resultado en el tipo E (que sabemos es del doble de tamaño
+ * de N, ni mas ni menos).
+ * Luego, armamos un objeto number usando al resultado como
+ * buffer. Si, es feo.
+ */
+ E tmp;
+ tmp = static_cast< E >(u.chunk[0]) * static_cast< E >(v.chunk[0]);
+ num_type tnum = num_type(reinterpret_cast< N* >(&tmp), 2, sign);
+ return tnum;
+ }
+
+ std::pair< num_type, num_type > u12 = u.split();
+ std::pair< num_type, num_type > v12 = v.split();
+
+ /* m11 = u1*v1
+ * m12 = u1*v2
+ * m21 = u2*v1
+ * m22 = u2*v2
+ */
+ num_type m11 = naif(u12.first, v12.first);
+ num_type m12 = naif(u12.first, v12.second);
+ num_type m21 = naif(u12.second, v12.first);
+ num_type m22 = naif(u12.second, v12.second);
+
+ /* 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
+ */
+ num_type res;
+ res = m22 << chunk_size;
+ res = res + ((m12 + m21) << (chunk_size / 2));
+ res = res + m11;
+ res.sign = sign;
+ return res;
+}
+
+
+/* Algoritmo de multiplicacion de Karatsuba-Ofman
+ * Ver los comentarios del algoritmo naif, es practicamente identico salvo en
+ * los calculos numericos que se especifican debajo.
+ */
+template < typename N, typename E >
+number < N, E > karatsuba(const number< N, E > &u, const number< N, E > &v)
+{
+ typedef number< N, E > num_type;
+
+ normalize_length(u, v);
+
+ typename num_type::size_type chunk_size = u.chunk.size();
+
+ sign_type sign;
+
+ if (u.sign == v.sign) {
+ sign = positive;
+ } else {
+ sign = negative;
+ }
+
+ if (chunk_size == 1) {
+ E tmp;
+ tmp = static_cast< E >(u.chunk[0]) * static_cast< E >(v.chunk[0]);
+ num_type tnum = num_type(reinterpret_cast< N* >(&tmp), 2, sign);
+ return tnum;
+ }
+
+ std::pair< num_type, num_type > u12 = u.split();
+ std::pair< num_type, num_type > v12 = v.split();
+
+ /* Aca esta la gracia de toda la cuestion:
+ * m = u1*v1
+ * d = u2*v2
+ * h = (u1+u2)*(v1+v2) = u1*u2+u1*v2+u2*v1+u2*v2
+ *
+ * h - d - m = u1*v2+u2*v1
+ * u1*v1 << base^N + u1*v2+u2*v1 << base^(N/2) + u2*v2
+ * m << base^N + (h - d - m) << base^(N/2) + d
+ */
+ num_type m = karatsuba(u12.first, v12.first);
+ num_type d = karatsuba(u12.second, v12.second);
+
+ num_type sumfst = u12.first + u12.second;
+ num_type sumsnd = v12.first + v12.second;
+ num_type h = karatsuba(sumfst, sumsnd);
+
+ num_type res, tmp;
+
+ /* tmp = h - d - m */
+ normalize_length(h, d);
+ tmp = h - d;
+ normalize_length(tmp, m);
+ tmp = tmp - m;
+
+ /* Resultado final */
+ res = d << chunk_size;
+ res += tmp << (chunk_size / 2);
+ res += m;
+ res.sign = sign;
+
+ return res;
+}
+
+
+/* Potenciacion usando multiplicaciones sucesivas.
+ * Toma dos parametros u y v, devuelve u^v; asume v positivo.
+ */
+template < typename N, typename E >
+number < N, E > pot_ko(number< N, E > &u, number< N, E > &v)
+{
+ assert(v.sign == positive);
+ number< N, E > res, i;
+
+ res = u;
+ res.sign = u.sign;
+
+ for (i = 1; i < v; i += 1) {
+ res = karatsuba(res, u);
+ }
+
+ return res;
+}
+
+/* Potenciacion usando división y conquista.
+ * Toma dos parametros u y v, devuelve u^v; asume v positivo.
+ *
+ * El pseudocódigo del algoritmo es:
+ * pot(x, y):
+ * if y == 1:
+ * return x
+ * res = pot(x, y/2)
+ * res = res * res
+ * if y es impar:
+ * res = res * x
+ * return res
+ *
+ * Es O(n) ya que la ecuación es T(n) = T(n/2) + O(1)
+ *
+ * El grafo que lo 'representa' (siendo los nodos el exponente y) algo como:
+ *
+ * 1 3
+ * _/ | \_
+ * _/ | \_
+ * / | \
+ * 6 1 6
+ * / \ / \
+ * / \ / \
+ * 3 3 3 3
+ * /|\ /|\ /|\ /|\
+ * 2 1 2 2 1 2 2 1 2 2 1 2
+ * / \ / \ / \ / \ / \ / \ / \ / \
+ * 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
+ *
+ */
+template < typename N, typename E >
+number< N, E > pot_dyc_n(const number< N, E > &x, const number< N, E > &y)
+{
+ assert(y.sign == positive);
+ if (y == number< N, E >(1))
+ {
+ return x;
+ }
+ number< N, E > res = pot_dyc_n(x, y.dividido_dos());
+ res = naif(res, res);
+ if (y.es_impar())
+ {
+ res = naif(res, x); // Multiplico por el x que falta
+ }
+ return res;
+}
+
+/* Idem que pot_dyc_n(), pero usa karatsuba() para las multiplicaciones. */
+template < typename N, typename E >
+number< N, E > pot_dyc_k(const number< N, E > &x, const number< N, E > &y)
+{
+ assert(y.sign == positive);
+ if (y == number< N, E >(1))
+ {
+ return x;
+ }
+ number< N, E > res = pot_dyc_k(x, y.dividido_dos());
+ res = karatsuba(res, res);
+ if (y.es_impar())
+ {
+ res = karatsuba(res, x);
+ }
+ return res;
+}
+
projects / z.facultad / 75.29 / dale.git / blobdiff