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;
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;
std::ostream& operator<< (std::ostream& os, const number< N, E >& n)
{
// FIXME sacar una salida bonita en ASCII =)
- for (typename number< N, E >::const_iterator i = n.chunk.begin();
- i != n.chunk.end(); ++i)
+ if (n.sign == positive)
+ os << "+ ";
+ else
+ os << "- ";
+ for (typename number< N, E >::const_reverse_iterator i = n.chunk.rbegin();
+ i != n.chunk.rend(); ++i)
os << std::setfill('0') << std::setw(sizeof(N) * 2) << std::hex
<< *i << " ";
return os;
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
{
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;
}
/* 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;
}
+/* 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;
+
+ typename num_type::size_type chunk_size = u.chunk.size();
+
+ sign_type sign;
+
+ if ( (u.sign == positive && v.sign == positive) ||
+ (u.sign == negative && v.sign == negative) ) {
+ 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(static_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();
+
+ // 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.second, v12.second);
+ num_type d = karastuba(u12.first, v12.first);
+ num_type h = karastuba(u12.second + v12.second,
+ u12.first + v12.first);
+
+ // 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
+ num_type res;
+ res = (m << chunk_size) + ((h - d - m) << (chunk_size / 2) ) + h;
+ 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(const number< N, E > &u, const number< N, E > &v)
+{
+ number< N, E > res, i;
+
+ res = u;
+ res.sign = u.sign;
+
+ for (i = 1; i < v; i += 1) {
+ res *= u;
+ }
+
+ return res;
+}
projects / z.facultad / 75.29 / dale.git / blobdiff