About

Negabinary (base −2) is a non-standard positional numeral system that represents every integer - positive, negative, and zero - without a sign symbol. This property makes it relevant in certain digital circuit designs and theoretical computer science. A miscalculation in radix conversion propagates through every downstream operation: arithmetic, checksums, protocol encoding. This tool converts between standard binary (base 2) and negabinary (base −2) using exact BigInt arithmetic, eliminating overflow errors that occur with naive 32-bit implementations. An intermediate decimal value is shown so you can verify each conversion step independently.

The conversion algorithm follows the Schroeppel method for negative-base encoding: repeated division by −2 with remainder correction. Note: both binary and negabinary use only digits 0 and 1, so the string representation alone cannot tell you which system it belongs to - context is everything. The tool assumes unsigned binary input (no two's complement). Pro tip: negabinary addition requires a specialized carry rule where a carry of 1 into position k produces −1 at position k+1, not +1.

Formulas

In standard binary (base 2), a digit string d_nd_n−1…d₀ represents the value:

N = n∑i=0 d_i ⋅ 2ⁱ

In negabinary (base −2), the same digit string uses a negative base:

N = n∑i=0 d_i ⋅ (−2)ⁱ

To convert a decimal integer N to negabinary, apply the Schroeppel division algorithm:

{

r = N mod 2N = (N − r) ÷ (−2)

The remainder r is always forced to 0 or 1. When the standard modulo yields a negative remainder, add 2 to r and increment the quotient by 1. Digits are collected from least significant to most significant. The process terminates when N = 0.

Where: N = decimal integer value, d_i = digit at position i (either 0 or 1), r = remainder after division, i = bit position index (starting from 0).

Reference Data

Decimal	Binary (base 2)	Negabinary (base −2)	Positional Weights (base −2)
0	0	0	0
1	1	1	1
2	10	110	4 + (−2) + 0
3	11	111	4 + (−2) + 1
4	100	100	4
5	101	101	4 + 0 + 1
6	110	11010	16 + (−8) + 0 + (−2) + 0
7	111	11011	16 + (−8) + 0 + (−2) + 1
8	1000	11000	16 + (−8)
9	1001	11001	16 + (−8) + 1
10	1010	11110	16 + (−8) + 4 + (−2)
−1	N/A (unsigned)	11	(−2) + 1
−2	N/A (unsigned)	10	−2
−3	N/A (unsigned)	1101	(−8) + 4 + 0 + 1
−4	N/A (unsigned)	1100	(−8) + 4
−5	N/A (unsigned)	1111	(−8) + 4 + (−2) + 1
−6	N/A (unsigned)	1110	(−8) + 4 + (−2)
−10	N/A (unsigned)	10110	16 + 0 + 4 + (−2) + 0
15	1111	10001	16 + 0 + 0 + 0 + 1
16	10000	10000	16
20	10100	10100	16 + 0 + 4
32	100000	1100000	64 + (−32)
42	101010	1110110	64 + (−32) + 16 + 0 + 4 + (−2) + 0
100	1100100	110100100	256 + (−128) + 0 + 32 + 0 + 0 + 4 + 0 + 0
255	11111111	100000011	256 + 0 + … + (−2) + 1

Frequently Asked Questions

In base −2, odd-positioned bits carry negative positional weights (−2, −8, −32, …). By combining positive-weight and negative-weight positions, every integer - positive, negative, or zero - has a unique unsigned representation. No separate sign bit or two's complement encoding is needed.

Yes. For example, the string 110 in binary (base 2) equals 4 + 2 = 6, but in negabinary (base −2) it equals 4 + (−2) + 0 = 2. The digits are identical; only the positional weights differ. Context determines interpretation.

The maximum is the sum of all positive-weight positions set to 1. For even bit count n, this equals (2^n − 1) / 3 rounded appropriately. In general, the range for n digits spans from (−2^n + 1) / 3 to (2^n − 1) / 3 approximately. The exact bounds depend on parity of n.

Addition in negabinary uses a non-standard carry rule. A carry of 1 into column k effectively subtracts 2 from that column's contribution (because the base is −2). This means a carry generates a +1 carry into position k+1, which then has the opposite sign weight. Dedicated carry-propagation logic is required; standard binary adders produce incorrect results.

Yes. The tool uses JavaScript BigInt internally, so there is no 32-bit or 64-bit overflow limit. You can input binary strings hundreds of digits long and receive exact negabinary output. Performance remains interactive for inputs up to several thousand digits.

Negabinary eliminates the need for separate subtraction circuits in certain ALU designs because subtraction is inherently embedded in the positional weights. Historical implementations include the Polish BINEG computer (1950s). Modern use is rare but it remains a subject in coding theory and balanced number system research.