operator -=, borrow y el stdint.h para VC++

[z.facultad/75.29/dale.git] / src / number.h

diff --git a/src/number.h b/src/number.h
index 43ed0b9f28fdaa2a1d8ec037e30e1fc2dc1670b5..23e847f01c87b2dc96af31f56a99f8e96ea424ee 100644 (file)
--- a/src/number.h
+++ b/src/number.h
@@ -122,7 +122,24 @@ 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)
+       {
+               if (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
+                       }
+               }
+               //else ERROR, están haciendo a-b con a>b
+       }
 };
 
 template < typename N, typename E >
@@ -230,7 +247,48 @@ 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;
+       }
+
+       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
+
+       //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]))
+               {
+                       minuend.borrow(i);
+               }
+               
+               // resto el chunk i-ésimo
+               minuend.chunk[i] -= subtrahend.chunk[i];
+       }
+
+       //retorno el minuendo ya restado
+       *this = minuend;
        return *this;
 }