Merge pull request #77 from saxbophone/josh/76-inc-bug

Fix increment bug

Author: saxbophone

arby/include/arby/Nat.hpp

@@ -260,23 +260,18 @@ namespace com::saxbophone::arby {
          * @returns new value of Nat object after incrementing
          */
         constexpr Nat& operator++() {
-            // empty digits vector (means value is zero) is a special case
-            if (_digits.size() == 0) {
-                _digits.push_back(1);
-            } else {
-                // increment least significant digit
-                auto it = _digits.rbegin();
-                (*it)++;
-                // increment remaining digits (rollover) as needed
-                while (it != _digits.rend() and *it == 0) { // last digit overflowed to zero
-                    ++it; // increment index
-                    (*it)++; // increment digit
-                }
-                // if last digit is zero, we need another one
-                if (_digits.front() == 0) {
-                    _digits.push_front(1);
+            // increment least significant digit then rollover remaining digits as needed
+            for (auto it = _digits.rbegin(); it != _digits.rend(); ++it) {
+                // only contine to next digit if incrementing this one rolls over
+                if (++(*it) != 0) {
+                    break;
                 }
             }
+            // if last digit is zero, we need another one
+            if (_digits.empty() or _digits.front() == 0) {
+                _digits.push_front(1);
+            }
+            _trap_leading_zero();
             return *this; // return new value by reference
         }
         /**
@@ -298,13 +293,12 @@ namespace com::saxbophone::arby {
             if (_digits.size() == 0) {
                 throw std::underflow_error("arithmetic underflow: can't decrement unsigned zero");
             } else {
-                // decrement least significant digit
-                auto it = _digits.rbegin();
-                (*it)--;
-                // decrement remaining digits (borrow) as needed
-                while (it != _digits.rend() and *it == std::numeric_limits<StorageType>::max()) { // last digit overflowed to zero
-                    ++it; // increment index
-                    (*it)--; // decrement digit
+                // decrement least significant digit then borrow from remaining digits as needed
+                for (auto it = _digits.rbegin(); it != _digits.rend(); ++it) {
+                    // only continue to next digit if decrementing this one rolls over
+                    if (--(*it) != std::numeric_limits<StorageType>::max()) {
+                        break;
+                    }
                 }
                 // if last digit is zero, remove it
                 if (_digits.front() == 0) {

arby/include/arby/codlili.hpp

@@ -111,6 +111,7 @@ namespace com::saxbophone::arby::PRIVATE::codlili {
             return *this;
         }
         /* element access */
+        // TODO: make these trap when accessed on an empty List
         // get reference to first element
         constexpr reference front() { return this->_front->value; }
         // get read-only reference to first element

tests/basic_arithmetic.cpp

@@ -79,6 +79,22 @@ TEST_CASE("constexpr arby::Nat", "[constexpr]") {
     WARN("No constexpr tests written yet");
 }
 
+TEST_CASE("arby::Nat prefix increment 0", "[basic-arithmetic]") {
+    arby::Nat original;
+    arby::Nat changed = ++original;
+
+    CHECK((uintmax_t)original == 1);
+    CHECK((uintmax_t)changed == 1);
+}
+
+TEST_CASE("arby::Nat postfix increment 0", "[basic-arithmetic]") {
+    arby::Nat original;
+    arby::Nat previous = original++;
+
+    CHECK((uintmax_t)original == 1);
+    CHECK((uintmax_t)previous == 0);
+}
+
 TEST_CASE("arby::Nat prefix increment", "[basic-arithmetic]") {
     uintmax_t input = GENERATE(take(1000, random((uintmax_t)0, std::numeric_limits<uintmax_t>::max() - 1)));
 
@@ -99,6 +115,24 @@ TEST_CASE("arby::Nat postfix increment", "[basic-arithmetic]") {
     CHECK((uintmax_t)previous == input);
 }
 
+TEST_CASE("arby::Nat prefix increment requiring additional digits", "[basic-arithmetic]") {
+    // setting input value to BASE-1 means an increment will add another digit
+    arby::Nat original = arby::Nat::BASE - 1;
+    arby::Nat changed = ++original;
+
+    CHECK((uintmax_t)original == arby::Nat::BASE);
+    CHECK((uintmax_t)changed == arby::Nat::BASE);
+}
+
+TEST_CASE("arby::Nat postfix increment requiring additional digits", "[basic-arithmetic]") {
+    // setting input value to BASE-1 means an increment will add another digit
+    arby::Nat original = arby::Nat::BASE - 1;
+    arby::Nat previous = original++;
+
+    CHECK((uintmax_t)original == arby::Nat::BASE);
+    CHECK((uintmax_t)previous == arby::Nat::BASE - 1);
+}
+
 TEST_CASE("arby::Nat prefix decrement", "[basic-arithmetic]") {
     uintmax_t input = GENERATE(take(1000, random((uintmax_t)1, std::numeric_limits<uintmax_t>::max())));
 
@@ -119,6 +153,24 @@ TEST_CASE("arby::Nat postfix decrement", "[basic-arithmetic]") {
     CHECK((uintmax_t)previous == input);
 }
 
+TEST_CASE("arby::Nat prefix decrement requiring digit removal", "[basic-arithmetic]") {
+    // setting input value to BASE means a decrement will remove a digit
+    arby::Nat original = arby::Nat::BASE;
+    arby::Nat changed = --original;
+
+    CHECK((uintmax_t)original == arby::Nat::BASE - 1);
+    CHECK((uintmax_t)changed == arby::Nat::BASE - 1);
+}
+
+TEST_CASE("arby::Nat postfix decrement requiring digit removal", "[basic-arithmetic]") {
+    // setting input value to BASE means a decrement will remove a digit
+    arby::Nat original = arby::Nat::BASE;
+    arby::Nat previous = original--;
+
+    CHECK((uintmax_t)original == arby::Nat::BASE - 1);
+    CHECK((uintmax_t)previous == arby::Nat::BASE);
+}
+
 // NOTE: no need for increment overflow tests as Nat doesn't overflow --it expands as necessary
 // TODO: consider writing a test case that applies very large size-increasing operations (maybe exponents)
 // on Nat to force a failure condition when memory runs out an an exception is thrown.