X-Git-Url: https://git.llucax.com/z.facultad/75.29/dale.git/blobdiff_plain/5170f9449ea46e4d5cdf885091634cb8c016e1fe..61abbf04181d2bbddb6912b15b9a9ca0537773fa:/src/number.h diff --git a/src/number.h b/src/number.h index 23e847f..71705cc 100644 --- a/src/number.h +++ b/src/number.h @@ -4,10 +4,15 @@ #define max _cpp_max #endif +#ifdef DEBUG +#include +#endif + #include #include #include #include +#include #ifdef _WIN32 // VC++ no tiene la stdint.h, se agrega a mano @@ -45,21 +50,21 @@ struct number // Constructores (después de construído, el chunk siempre tiene al // menos un elemento). // Constructor default (1 'átomo con valor 0) - number(): chunk(1, 0) {} + number(): chunk(1, 0), sign(positive) {} // Constructor a partir de buffer (de 'átomos') y tamaño // Copia cada elemento del buffer como un 'átomo' del chunk // (el átomo menos significativo es el chunk[0] == buf[0]) - number(native_type* buf, size_type len, sign_type sign = positive): - chunk(buf, buf + len), sign(sign) + number(native_type* buf, size_type len, sign_type s = positive): + chunk(buf, buf + len), sign(s) { fix_empty(); } // Constructor a partir de un 'átomo' (lo asigna como único elemento // del chunk). Copia una vez N en el vector. - number(native_type n, sign_type sign = positive): - chunk(1, n), sign(sign) {} + number(native_type n, sign_type s = positive): + chunk(1, n), sign(s) {} number(const std::string& str); @@ -75,6 +80,7 @@ struct number number& operator<<= (const size_type n); number& operator-= (const number& n); bool operator< (const number& n); + bool operator==(const number& n) const; // Devuelve referencia a 'átomo' i del chunk (no debería ser necesario // si la multiplicación es un método de este objeto). @@ -140,6 +146,30 @@ struct number } //else ERROR, están haciendo a-b con a>b } + // Verifica si es un número par + bool es_impar() const + { + return chunk[0] & 1; // Bit menos significativo + } + // Divide por 2. + number dividido_dos() const + { + number n = *this; + bool lsb = 0; // bit menos significativo + bool msb = 0; // bit más significativo + for (typename chunk_type::reverse_iterator i = n.chunk.rbegin(); + i != n.chunk.rend(); ++i) + { + lsb = *i & 1; // bit menos significativo + *i >>= 1; // shift + // seteo bit más significativo de ser necesario + if (msb) + *i |= 1 << (sizeof(native_type) * 8 - 1); + msb = lsb; + } + return n; + } + }; template < typename N, typename E > @@ -172,6 +202,23 @@ number< N, E >::number(const std::string& origen) template < typename N, typename E > number< N, E >& number< N, E >::operator+= (const number< N, E >& n) { + // Si tienen distinto signo, restamos... + if (sign != n.sign) + { + if (sign == positive) // n es negativo + { + number< N, E > tmp = n; + tmp.sign = positive; + *this -= tmp; + } + else // n es positivo, yo negativo + { + sign = positive; + *this = n - *this; + } + return *this; + } + native_type c = 0; size_type ini = 0; size_type fin = std::min(chunk.size(), n.chunk.size()); @@ -267,7 +314,6 @@ number< N, E >& number< N, E >::operator-= (const number< N, E >& n) minuend.sign = positive; } - native_type c = 0; size_type ini = 0; size_type fin = std::min(minuend.chunk.size(), subtrahend.chunk.size()); size_type i; //problema de VC++, da error de redefinición @@ -366,6 +412,62 @@ std::ostream& operator<< (std::ostream& os, const number< N, E >& n) return os; } +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(); + } + if (chunk_grande) // Si tienen tamaños distintos, vemos que el resto sea cero. + { + 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) { @@ -454,8 +556,7 @@ number < N, E > naif(const number< N, E > &u, const number< N, E > &v) sign_type sign; - if ( (u.sign == positive && v.sign == positive) || - (u.sign == negative && v.sign == negative) ) { + if (u.sign == v.sign) { sign = positive; } else { sign = negative; @@ -535,8 +636,7 @@ number < N, E > karatsuba(const number< N, E > &u, const number< N, E > &v) sign_type sign; - if ( (u.sign == positive && v.sign == positive) || - (u.sign == negative && v.sign == negative) ) { + if (u.sign == v.sign) { sign = positive; } else { sign = negative; @@ -545,7 +645,7 @@ number < N, E > karatsuba(const number< N, E > &u, const number< N, E > &v) 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); + num_type tnum = num_type(reinterpret_cast< N* >(&tmp), 2, sign); return tnum; } @@ -577,6 +677,7 @@ number < N, E > karatsuba(const number< N, E > &u, const number< N, E > &v) template < typename N, typename E > number < N, E > pot_ko(const number< N, E > &u, const number< N, E > &v) { + assert(v.sign == positive); number< N, E > res, i; res = u; @@ -589,3 +690,59 @@ number < N, E > pot_ko(const number< N, E > &u, const number< N, E > &v) 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(const number< N, E > &x, const number< N, E > &y) +{ + assert(y.sign == positive); + //std::cout << "pot(" << x << ", " << y << ")\n"; + if (y == number< N, E >(1)) + { + std::cout << "y es 1 => FIN pot(" << x << ", " << y << ")\n"; + return x; + } + number< N, E > res = pot_dyc(x, y.dividido_dos()); + //std::cout << "y.dividido_dos() = " << y.dividido_dos() << "\n"; + //std::cout << "res = " << res << "\n"; + res *= res; + //std::cout << "res = " << res << "\n"; + if (y.es_impar()) + { + //std::cout << y << " es IMPAR => "; + res *= x; // Multiplico por el x que falta + //std::cout << "res = " << res << "\n"; + } + //std::cout << "FIN pot(" << x << ", " << y << ")\n\n"; + return res; +} +