X-Git-Url: https://git.llucax.com/z.facultad/75.29/dale.git/blobdiff_plain/cbfd67d82e0913165b67283f702b00b781e7b3ae..78a013aaa517a642f1957f93dca833ff64f16d98:/src/number.h?ds=sidebyside diff --git a/src/number.h b/src/number.h index 2c2d281..27d19a8 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). @@ -122,6 +128,46 @@ struct number else chunk.push_back(1); } + // Propaga borrow a partir del 'átomo' i (resta 1 al 'átomo' i propagando + // borrow) + void borrow(size_type i) + { + // para poder pedir prestado debo tener uno a la izquierda + assert (chunk.size() >= i); + + if (chunk[i] == 0) + { + borrow(i+1); // Overflow, pido prestado + chunk[i] = ~((N)0); //quedo con el valor máximo + } + else + { + --chunk[i]; //tengo para dar, pero pierdo uno yo + } + } + // 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; + } }; @@ -155,6 +201,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()); @@ -230,7 +293,53 @@ number< N, E > operator+ (const number< N, E >& n1, const number< N, E >& n2) template < typename N, typename E > number< N, E >& number< N, E >::operator-= (const number< N, E >& n) { - //TODO IMPLEMENTAR + // minuendo - substraendo + number< N, E > minuend; + number< N, E > subtrahend; + + // voy a hacer siempre el mayor menos el menor + if (*this < n) + { + minuend = n; + subtrahend = *this; + //minuendo < sustraendo => resultado negativo + minuend.sign = negative; + } + else + { + minuend = *this; + subtrahend = n; + //minuendo > sustraendo => resultado positivo + minuend.sign = positive; + } + + 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 + + //estoy seguro de que minuend > subtrahend, con lo cual itero hasta el size del + //menor de los dos. Si el otro es más grande, puede ser que esté lleno de 0's pero + //no puede ser realmente mayor como cifra + for (i = ini; i < fin; ++i) + { + // si no alcanza para restar pido prestado + if ((minuend.chunk[i] < subtrahend.chunk[i])) + { + // no puedo pedir si soy el más significativo ... + assert (i != fin); + + // le pido uno al que me sigue + minuend.borrow(i+1); + } + + // es como hacer 24-5: el 4 pide prestado al 2 (borrow(i+1)) y después + // se hace 4 + (9-5) + 1 + + minuend.chunk[i] += (~((N)0) - subtrahend.chunk[i]) + 1; + } + + //retorno el minuendo ya restado + *this = minuend; return *this; } @@ -293,17 +402,77 @@ number< N, E > operator<< (const number< N, E >& n, typename number< N, E >::siz return tmp; } -template < typename N, typename E > -std::ostream& operator<< (std::ostream& os, const number< N, E >& n) +template < typename NN, typename EE > +std::ostream& operator<< (std::ostream& os, const number< NN, EE >& n) { // FIXME sacar una salida bonita en ASCII =) - for (typename number< N, E >::const_iterator i = n.chunk.begin(); - i != n.chunk.end(); ++i) - os << std::setfill('0') << std::setw(sizeof(N) * 2) << std::hex + if (n.sign == positive) + os << "+ "; + else + os << "- "; + for (typename number< NN, EE >::const_reverse_iterator i = n.chunk.rbegin(); + i != n.chunk.rend(); ++i) + os << std::setfill('0') << std::setw(sizeof(NN) * 2) << std::hex << *i << " "; 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) { @@ -392,8 +561,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; @@ -460,4 +628,126 @@ number < N, E > naif(const number< N, E > &u, const number< N, E > &v) } +/* 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 == 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(); + + // 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) +{ + assert(v.sign == positive); + number< N, E > res, i; + + res = u; + res.sign = u.sign; + + for (i = 1; i < v; i += 1) { + 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(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; +}