Revert "BigInt fixes and optimization (read comments)"

Apparently division *still* isn't being handled correctly.
This reverts commit 1dda12e4be.

libs/bigint/bigint.lua

@@ -451,17 +451,11 @@ function bigint.exponentiate(big, power)
     elseif (bigint.compare(exp, bigint.new(1), "==")) then
         return big
     else
-        local result = bigint.new(1)
+        local result = big:clone()
-        local base = big:clone()
 
-        while (bigint.compare(exp, bigint.new(0), ">")) do
+        while (bigint.compare(exp, bigint.new(1), ">")) do
-            if (bigint.compare(
+            result = bigint.multiply(result, big)
-                bigint.modulus(exp, bigint.new(2)), bigint.new(1), "=="
+            exp = bigint.subtract(exp, bigint.new(1))
-            )) then
-                result = bigint.multiply(result, base)
-            end
-            exp = bigint.divide(exp, bigint.new(2))
-            base = bigint.multiply(base, base)
         end
 
         return result
@@ -485,30 +479,54 @@ function bigint.divide_raw(big1, big2)
 
         local result = bigint.new()
 
-        local dividend = bigint.new() -- Dividend of a single operation
+        local dividend = bigint.new() -- Dividend of a single operation, not the
+                                      -- dividend of the overall function
+        local divisor = big2:clone()
+        local factor = 1
 
-        local neg_zero = bigint.new(0)
+        -- Walk left to right among digits in the dividend, like in long
-        neg_zero.sign = "-"
+        -- division
+        for _, digit in pairs(big1.digits) do
+            dividend.digits[#dividend.digits + 1] = digit
 
-        for i = 1, #big1.digits do
+            -- The dividend is smaller than the divisor, so a zero is appended
-            -- Fixes a negative zero bug
+            -- to the result and the loop ends
-            if (#dividend.digits ~= 0) and (bigint.compare(dividend, neg_zero, "==")) then
+            if (bigint.compare(dividend, divisor, "<")) then
-                dividend = bigint.new()
+                if (#result.digits > 0) then -- Don't add leading zeroes
+                    result.digits[#result.digits + 1] = 0
                 end
-
+            else
-            table.insert(dividend.digits, big1.digits[i])
+                -- Find the maximum number of divisors that fit into the
-            
+                -- dividend
-            local factor = 0
+                factor = 0
-            while bigint.compare(dividend, big2, ">=") do
+                while (bigint.compare(divisor, dividend, "<=")) do
-                dividend = bigint.subtract(dividend, big2)
+                    divisor = bigint.add(divisor, big2)
                     factor = factor + 1
                 end
 
-            if (factor ~= 0) or (factor == 0 and #result.digits ~= 0) then
+                -- Append the factor to the result
-                table.insert(result.digits, factor)
+                if (factor == 10) then
-            end
+                    -- Fixes a weird bug that introduces a new bug if fixed by
+                    -- changing the comparison in the while loop to "<="
+                    result.digits[#result.digits] = 1
+                    result.digits[#result.digits + 1] = 0
+                else
+                    result.digits[#result.digits + 1] = factor
                 end
 
+                -- Subtract the divisor from the dividend to obtain the
+                -- remainder, which is the new dividend for the next loop
+                dividend = bigint.subtract(dividend,
+                                           bigint.subtract(divisor, big2))
+
+                -- Reset the divisor
+                divisor = big2:clone()
+            end
+
+        end
+
+        -- The remainder of the final loop is returned as the function's
+        -- overall remainder
         return result, dividend
     end
 end