Consistently use unsigned in big-int

Author: tautschnig

src/big-int/bigint.cc

@@ -58,13 +58,13 @@ adjust_size (unsigned size)
 inline int
 digit_cmp (onedig_t const *a, onedig_t const *b, unsigned n)
 {
-  for (int i = n; --i >= 0; )
-    {
-      if (a[i] < b[i])
-	return -1;
-      else if (a[i] > b[i])
-	return 1;
-    }
+  for(unsigned i = n; i > 0; --i)
+  {
+    if(a[i - 1] < b[i - 1])
+      return -1;
+    else if(a[i - 1] > b[i - 1])
+      return 1;
+  }
   return 0;
 }
 
@@ -136,12 +136,12 @@ static _fast onedig_t
 digit_mul (onedig_t *b, unsigned l, onedig_t d)
 {
   twodig_t p = 0;
-  for (int i = l; --i >= 0; )
-    {
-      p += twodig_t (d) * twodig_t (*b);
-      *b++ = onedig_t (p);
-      p >>= single_bits;
-    }
+  for(unsigned i = l; i > 0; --i)
+  {
+    p += twodig_t(d) * twodig_t(*b);
+    *b++ = onedig_t(p);
+    p >>= single_bits;
+  }
   return onedig_t (p);
 }
 
@@ -177,13 +177,13 @@ static _fast onedig_t
 digit_div (onedig_t *b, unsigned l, onedig_t d)
 {
   twodig_t r = 0;
-  for (int i = l; --i >= 0; )
-    {
-      r <<= single_bits;
-      r |= b[i];
-      b[i] = onedig_t (r / d);
-      r %= d;
-    }
+  for(unsigned i = l; i > 0; --i)
+  {
+    r <<= single_bits;
+    r |= b[i - 1];
+    b[i - 1] = onedig_t(r / d);
+    r %= d;
+  }
   return onedig_t (r);
 }
 
@@ -259,17 +259,18 @@ static _fast void
 digit_div (onedig_t *r, const onedig_t *y, unsigned yl, onedig_t *q, unsigned ql)
 {
   r += ql;
-  for (int i = ql; --r, --i >= 0; )
+  --r;
+  for(unsigned i = ql; i > 0; --r, --i)
+  {
+    onedig_t qh = guess_q(r + yl, y + yl - 1);
+    if(multiply_and_subtract(r, y, yl, qh) == 0)
     {
-      onedig_t qh = guess_q (r + yl, y + yl - 1);
-      if (multiply_and_subtract (r, y, yl, qh) == 0)
-	{
-	  --qh;
-	  add_back (r, y, yl);
-	}
-      if (q != 0)
-	q[i] = qh;
+      --qh;
+      add_back(r, y, yl);
     }
+    if(q != 0)
+      q[i - 1] = qh;
+  }
 }
 
 
@@ -502,16 +503,16 @@ BigInt::scan_on (char const *s, onedig_t b)
   for (char c = *s; c; c = *++s)
     {
       // Convert digit. Use 0..9A..Z for singles up to 36. Ignoring case.
-      c = toupper (c);
+      c = (char)toupper(c);
       onedig_t dig;
       if (c < '0')
 	return s;
       else if (c <= '9')
-	dig = c - '0';
+        dig = (onedig_t)(c - '0');
       else if (c < 'A')
 	return s;
       else if (c <= 'Z')
-	dig = c - 'A' + 10;
+        dig = (onedig_t)(c - 'A' + 10);
       else
 	return s;
       if (dig >= b)
@@ -585,7 +586,7 @@ BigInt::as_string (char *p, unsigned l, onedig_t b) const
       if (l == 0)
 	return 0;
       onedig_t r = digit_div (dig, len, b);
-      p[--l] = r < 10 ? r + '0' : 'A' + r - 10;
+      p[--l] = (char)(r < 10 ? r + '0' : 'A' + r - 10);
       if (dig[len-1] == 0)
 	--len;
     }
@@ -632,7 +633,7 @@ BigInt::dump (unsigned char *p, unsigned n)
   for (;;)
     {
       while (i--)
-	*p++ = d >> i * CHAR_BIT;
+        *p++ = (unsigned char)(d >> i * CHAR_BIT);
       if (t <= digit)
 	break;
       d = *--t;
@@ -683,27 +684,27 @@ BigInt::is_long() const
     return false;
   // There is exactly one good signed number n with abs (n) having the
   // topmost bit set: The most negative number.
-  for (int l = length - 1; --l >= 0; )
-    if (digit[l] != 0)
+  for(unsigned l = length - 1; l > 0; --l)
+    if(digit[l - 1] != 0)
       return false;
   return true;
 }
 
 ullong_t BigInt::to_ulong() const
 {
   ullong_t ul = 0;
-  for (int i = length; --i >= 0; )
-    {
-      ul <<= single_bits;
-      ul |= digit[i];
-    }
+  for(unsigned i = length; i > 0; --i)
+  {
+    ul <<= single_bits;
+    ul |= digit[i - 1];
+  }
   return ul;
 }
 
 llong_t BigInt::to_long() const
 {
-  ullong_t ul = to_ulong();
-  return positive ? ul : -llong_t (ul);
+  llong_t l = llong_t(to_ulong());
+  return positive ? l : -l;
 }
 
 
@@ -753,7 +754,7 @@ BigInt::compare (llong_t b) const
 
   onedig_t dig[small];
   unsigned len;
-  digit_set (-b, dig, len);
+  digit_set(ullong_t(-b), dig, len);
   if (length < len)
     return 1;
   if (length > len)
@@ -905,7 +906,7 @@ BigInt &
 BigInt::operator+= (llong_t y)
 {
   bool pos = y > 0;
-  ullong_t uy = pos ? y : -y;
+  ullong_t uy = pos ? ullong_t(y) : ullong_t(-y);
   onedig_t yb[small];
   unsigned yl;
   digit_set (uy, yb, yl);
@@ -917,7 +918,7 @@ BigInt &
 BigInt::operator-= (llong_t y)
 {
   bool pos = y > 0;
-  ullong_t uy = pos ? y : -y;
+  ullong_t uy = pos ? ullong_t(y) : ullong_t(-y);
   onedig_t yb[small];
   unsigned yl;
   digit_set (uy, yb, yl);
@@ -929,7 +930,7 @@ BigInt &
 BigInt::operator*= (llong_t y)
 {
   bool pos = y > 0;
-  ullong_t uy = pos ? y : -y;
+  ullong_t uy = pos ? ullong_t(y) : ullong_t(-y);
   onedig_t yb[small];
   unsigned yl;
   digit_set (uy, yb, yl);
@@ -941,7 +942,7 @@ BigInt &
 BigInt::operator/= (llong_t y)
 {
   bool pos = y > 0;
-  ullong_t uy = pos ? y : -y;
+  ullong_t uy = pos ? ullong_t(y) : ullong_t(-y);
   onedig_t yb[small];
   unsigned yl;
   digit_set (uy, yb, yl);
@@ -952,7 +953,7 @@ BigInt &
 BigInt::operator%= (llong_t y)
 {
   bool pos = y > 0;
-  ullong_t uy = pos ? y : -y;
+  ullong_t uy = pos ? ullong_t(y) : ullong_t(-y);
   onedig_t yb[small];
   unsigned yl;
   digit_set (uy, yb, yl);
@@ -1078,7 +1079,7 @@ BigInt::div (BigInt const &x, BigInt const &y, BigInt &q, BigInt &r)
       // This digit_div() transforms the dividend into the quotient.
       q = y;
       r.digit[0] = digit_div (q.digit, q.length, y.digit[0]);
-      r.length = r.digit[0] ? 1 : 0;
+      r.length = r.digit[0] ? 1u : 0u;
     }
   else
     {
@@ -1269,22 +1270,25 @@ BigInt::operator%= (BigInt const &y)
 unsigned
 BigInt::floorPow2 () const
 {
-  int i = length - 1;    // Start on the last value
-  while (i >= 0 && digit[i] == 0) {
+  unsigned i = length; // Start on the last value
+  while(i > 0 && digit[i - 1] == 0)
+  {
     --i;               // Skip zeros
   }
-  if (i < 0) {
+  if(i == 0)
+  {
     return 0;          // Special case
   }
 
   twodig_t power = 1;
-  int count = 0;
+  unsigned count = 0;
 
-  while ((power << 1) <= (twodig_t)digit[i]) {
+  while((power << 1) <= (twodig_t)digit[i - 1])
+  {
     ++count, power <<= 1;
   }
 
-  return (single_bits * i) + count;
+  return (single_bits * (i - 1)) + count;
 }
 
 // Not part of original BigInt.

unit/big-int/big-int.cpp

@@ -245,12 +245,12 @@ TEST_CASE("arbitrary precision integers", "[core][big-int][bigint]")
 
     REQUIRE(N == M);
 
-    REQUIRE(N.floorPow2() == 0);
+    REQUIRE(N.floorPow2() == 0U);
 
     N -= 1; // 0
-    REQUIRE(N.floorPow2() == 0);
+    REQUIRE(N.floorPow2() == 0U);
 
     N += 2; // 2
-    REQUIRE(N.floorPow2() == 1);
+    REQUIRE(N.floorPow2() == 1U);
   }
 }