Binary division calculator

This binary division calculator divides two unsigned base-two integers and returns an exact binary quotient and remainder. It also exposes every shift, comparison, subtraction, and restoration decision made by the classic restoring-division algorithm used to explain arithmetic hardware. Enter strings made only from zeroes and ones, optionally prefixed with 0b, and the calculator normalizes leading zeroes before processing them. Because the implementation works directly on bit strings instead of converting through JavaScript numbers, large inputs remain exact.

How binary quotient and remainder are defined

Binary division follows the same integer identity as decimal long division: the dividend equals the divisor multiplied by the quotient, plus the remainder, and the remainder is always smaller than the divisor. Only the written digits and place values change. Each binary position represents a power of two, so the quotient can be assembled one bit at a time from the most significant dividend bit to the least significant bit.

A quotient bit of one means the divisor fits into the current partial remainder; a zero means it does not. After the final dividend bit has been consumed, the accumulated quotient and partial remainder are the answer. This calculator accepts unsigned integers only, which keeps the trace focused on the magnitude operation that a hardware divider performs beneath any separate sign handling.

Leading zeroes do not change an integer, so they are removed from normalized inputs and outputs. A zero dividend is valid and produces a zero quotient and remainder. A zero divisor is never valid because no quotient can satisfy the division identity, so it returns an invalid-input error rather than an invented result.

Inputs may include the familiar 0b prefix, but embedded spaces, decimal digits, signs, and fractional points are rejected to preserve an unambiguous bit-level contract.

Reading the restoring-division trace

The trace contains one cycle for every normalized dividend bit. At the start of a cycle, the current remainder is shifted left and the next dividend bit is brought into its least significant position. The algorithm then compares that shifted remainder with the divisor.

When the divisor fits, it subtracts the divisor, appends one to the quotient, and carries the difference into the next cycle. When the divisor does not fit, the attempted subtraction would be negative, so the hardware interpretation restores the previous nonnegative remainder and appends zero to the quotient. The mathematical outcome is identical.

Since subtraction is implemented on binary strings with an explicit borrow, the calculation does not pass through floating-point arithmetic and does not lose low bits on operands longer than a machine word.

Using the result for hardware study and testing

The returned object is designed to serve both human explanations and automated checks. The top-level dividend and divisor show the normalized operands, while quotient and remainder provide the compact result most programs need. Digital-design students can compare each cycle with registers in a datapath containing a remainder register, divisor register, subtractor, comparator, quotient register, and controller.

HDL authors can turn a successful response into an expected vector for a Verilog or VHDL testbench, checking not only the final quotient but also the invariant that the final remainder is less than the divisor. Firmware developers can use the same vectors when validating a bitwise divider on a processor without a native divide instruction. Each operand is limited to 1024 bits so the generated trace stays bounded and a single request cannot create unbounded work.

Signed division, fixed-point scaling, rounding modes, latency estimation, and non-restoring or SRT algorithms require different rules and are intentionally outside this capability.