Acomodar loop de menorEnModuloQue().

diff --git a/src/number.h b/src/number.h
index 8fd7efc0003f60c3c2e3f2b4b28e1cc9f981d3a5..3a2848b14111cf10d6e0df7d4c971adae1d57d65 100644 (file)
--- a/src/number.h
+++ b/src/number.h
@@ -75,12 +75,12 @@ struct number
                return *this;
        }
 
-       number& operator+= (const number& n);
-       number& operator*= (const number& n);
+       number& operator+=  (const number& n);
+       number& operator*=  (const number& n);
        number& operator<<= (const size_type n);
-       number& operator-= (const number& n);
-       bool    operator< (const number& n);
-       bool    operator==(const number& n) const;
+       number& operator-=  (const number& n);
+       bool    operator<   (const number& n) const;
+       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).
@@ -353,33 +353,58 @@ number< N, E > operator- (const number< N, E >& n1, const number< N, E >& n2)
 
 
 template < typename N, typename E >
-bool number< N, E >::operator< (const number< N, E >& n)
+bool number< N, E >::operator< (const number< N, E >& n) const
 {
-       number< N, E > n1 = *this;
-       number< N, E > n2 = n;
-
-       // igualo los largos
-       normalize_length(n1, n2);
+       if (sign != n.sign)
+       {
+               if (sign == positive) // yo positivo, n negativo
+                       return false; // yo soy más grande
+               else // yo negagivo, n positivo
+                       return true; // n es más grande
+       }
 
-       // obtengo el largo
-       size_type length = n1.chunk.size();
-       size_type i = length - 1;
+       size_type i; //problema de VC++, da error de redefinición
 
-       // me voy fijando desde "la cifra" más significativa si alguno es menor que el otro
-       // sigo iterando si son iguales hasta recorrer todo el número hasta la parte menos significativa
-       while (i > 0)
+       if (chunk.size() > n.chunk.size()) // yo tengo más elementos
+       {
+               // Recorro los bytes más significativos (que tengo sólo yo)
+               for (i = n.chunk.size(); i < chunk.size(); ++i)
+               {
+                       if (chunk[i] != 0) // Si tengo algo distinto a 0
+                       {
+                               return false; // Entonces soy más grande
+                       }
+               }
+       }
+       else if (chunk.size() < n.chunk.size()) // n tiene más elementos
        {
-               if (n1[i]<n2[i])
+               // Recorro los bytes más significativos (que tiene sólo n)
+               for (i = chunk.size(); i < n.chunk.size(); ++i)
+               {
+                       if (chunk[i] != 0) // Si n tiene algo distinto a 0
+                       {
+                               return true; // Entonces soy más chico
+                       }
+               }
+       }
+       // sigo con la intersección de ambos
+       size_type fin = std::min(chunk.size(), n.chunk.size());
+       i = fin;
+       while (i != 0) {
+               --i;
+
+               if (chunk[i] < n.chunk[i]) // Si es menor
+               {
                        return true;
-               if (n1[i]>n2[i])
+               }
+               else if (chunk[i] > n.chunk[i]) // Si es mayor
+               {
                        return false;
-
-               i--;
+               }
+               // Si es igual tengo que seguir viendo
        }
 
-       // si llegué hasta acá es porque son iguales, por lo tanto no es menor estricto
-       return false;
-
+       return false; // Son iguales
 }
 
 // efectúa un shifteo a izquierda del chunk, agregando 0s en los casilleros menos significativos