Negative base

A negative base (or negative radix) may be used to construct a non-standard positional numeral system. Like other place-value systems, each position holds multiples of the appropriate power of the system's base; but that base is negative—that is to say, the base b is equal to −r for some natural number r (r ≥ 2).

Negative-base systems can accommodate all the same numbers as standard place-value systems, but both positive and negative numbers are represented without the use of a minus sign (or, in computer representation, a sign bit); this advantage is countered by an increased complexity of arithmetic operations. The need to store the information normally contained by a negative sign often results in a negative-base number being one digit longer than its positive-base equivalent.

The common names for negative-base positional numeral systems are formed by prefixing nega- to the name of the corresponding positive-base system; for example, negadecimal (base −10) corresponds to decimal (base 10), negabinary (base −2) to binary (base 2), and negaternary (base −3) to ternary (base 3).^[1][2]

Example

Consider what is meant by the representation 7004122430000000000♠12243 in the negadecimal system, whose base b is −10:

Since 10,000 + (−2,000) + 200 + (−40) + 3 = 7003816300000000000♠8,163, the representation 7004122430000000000♠12,243₋₁₀ in negadecimal notation is equivalent to 7003816300000000000♠8,163₁₀ in decimal notation, while 2996183700000000000♠−8,163₁₀ in decimal would be written 7003997700000000000♠9,977₋₁₀ in negadecimal.

History

Negative numerical bases were first considered by Vittorio Grünwald in his work Giornale di Matematiche di Battaglini, published in 1885.^[3] Grünwald gave algorithms for performing addition, subtraction, multiplication, division, root extraction, divisibility tests, and radix conversion. Negative bases were later independently rediscovered by A. J. Kempner in 1936^[4] and Zdzisław Pawlak and A. Wakulicz in 1959.^[5]

Negabinary was implemented in the early Polish computer BINEG (and UMC), built 1957–59, based on ideas by Z. Pawlak and A. Lazarkiewicz from the Mathematical Institute in Warsaw.^[6] Implementations since then have been rare.

Notation and use

Denoting the base as −r, every integer a can be written uniquely as

where each digit d_k is an integer from 0 to r - 1 and the leading digit d_n is > 0 (unless n=0). The base −r expansion of a is then given by the string d_nd_n-1…d₁d₀.

Negative-base systems may thus be compared to signed-digit representations, such as balanced ternary, where the radix is positive but the digits are taken from a partially negative range. (In the table below the digit of value −1 is written as the single character T.)

Some numbers have the same representation in base −r as in base r. For example, the numbers from 100 to 109 have the same representations in decimal and negadecimal. Similarly,

and is represented by 10001 in binary and 10001 in negabinary.

Some numbers with their expansions in a number of positive and corresponding negative bases are:

Note that the base −r expansions of negative integers have an even number of digits, while the base −r expansions of the non-negative integers have an odd number of digits.

Calculation

The base −r expansion of a number can be found by repeated division by −r, recording the non-negative remainders of , and concatenating those remainders, starting with the last. Note that if a / b = c, remainder d, then bc + d = a and therefore d = a - bc. To arrive at the correct conversion, the value for c must be chosen such that d is non-negative and minimal. This is exemplified in the fourth line of the following example wherein –5 ÷ –3 must be chosen to equal 2 remainder 1 instead of 1 remainder –2.

For example, to convert 146 in decimal to negaternary:

Reading the remainders backward we obtain the negaternary representation of 146₁₀: 21102_–3.

Proof: (((2·(–3)+1)·(–3)+1)·(–3)+0)·(–3)+2 = 146₁₀.

Note that in most programming languages, the result (in integer arithmetic) of dividing a negative number by a negative number is rounded towards 0, usually leaving a negative remainder. In such a case we have a = (−r)c + d = (−r)c + d − r + r = (−r)(c + 1) + (d + r). Because |d| < r, (d + r) is the positive remainder. Therefore, to get the correct result in such case, computer implementations of the above algorithm should add 1 and r to the quotient and remainder respectively.

static string ToNegabinary(int value)
{
	string result = string.Empty;

	while (value != 0)
	{
		int remainder = value % -2;
		value = value / -2;

		if (remainder < 0)
		{
			remainder += 2;
			value += 1;
		}

		result = remainder.ToString() + result;
	}

	return result;
}

static string negaternary(int value)
{
	string result = string.Empty;

	while (value != 0)
	{
		int remainder = value % -3;
		value = value / -3;

		if (remainder < 0)
		{
			remainder += 3;
			value += 1;
		}

		result = remainder.ToString() + result;
	}

	return result;
}

Private Shared Function ToNegaternary(value As Integer) As String
	Dim result As String = String.Empty

	While value <> 0
		Dim remainder As Integer = value Mod -3
		value /= -3

		If remainder < 0 Then
			remainder += 3
			value += 1
		End If

		result = remainder.ToString() & result
	End While

	Return result
End Function

def negaternary(i):
    if i == 0:
        digits = ['0']
    else:
        digits = []
        while i != 0:
            i, remainder = divmod(i, -3)
            if remainder < 0:
                i, remainder = i + 1, remainder + 3
            digits.append(str(remainder))
    return ''.join(digits[::-1])

(defun negaternary (i)
  (if (zerop i)
      "0"
      (let ((digits "")
	    (rem 0))
	(loop while (not (zerop i)) do
	     (progn
	       (multiple-value-setq (i rem) (truncate i -3))
	       (when (minusp rem)
	         (incf i)
	         (incf rem 3))
	       (setf digits (concatenate 'string (write-to-string rem) digits))))
	digits)))

    public List<Integer> negativeBase(int integer, int base) {
        List<Integer> digits = new ArrayList<>();
        while (integer != 0) {
            int i = integer % base;
            integer /= base;
            if(i < 0) {
                i += Math.abs(base);
                integer++;
            }
            digits.add(0, i);
        }
        return digits;
    }

(defun negabase (num baz / dig rst)
;;num=any number in base 10.
;;If num is a decimal one, it will be considered integer.
;;14.25 will be considered 14; -123456789.87 will be considered -123456789.
;;baz=any number from [-10 -2] interval.
;;If baz is a decimal one, it will be considered integer.
    (if
        (and (numberp num)(numberp baz)(<= (fix baz) -2)(> (fix baz) -11))
        (progn
            (setq
                baz (float (fix baz))
                num (float (fix num))
                dig (if (= num 0) "0" "")
            )
            (while (/= num 0)
                (setq rst (- num (* baz (setq num (fix (/ num baz))))))
                (if
                    (minusp rst)
                    (setq
                        num (1+ num)
                        rst (- rst baz)
                    )
                )
                (setq dig (strcat (itoa (fix rst)) dig))
            )
            dig
        )
        (progn
            (prompt
                (cond
                    ((and (not (numberp num))(not (numberp baz)))   "\nWrong number and negabase.")
                    ((not (numberp num))                            "\nWrong number.")
                    ((not (numberp baz))                            "\nWrong negabase.")
                    (T                                              "\nNegabase must be inside [-10 -2] interval.")
                )
            )
            (princ)
        )
    )
)

function toNegativeBase($no, $base)
{
	$digits = array();
	$base = intval($base);
	while ($no != 0) {
		$temp_no = $no;
		$no = intval($temp_no / $base);
		$remainder = ($temp_no % $base);
 
		if ($remainder < 0) {
			$remainder += abs($base);
			$no++;
		}
 
		array_unshift($digits, $remainder);
	}
 
	return $digits;
}

Function toNegativeBase(Number As Integer , base As Integer) As System.Collections.Generic.List(Of Integer)

	Dim digits As New System.Collections.Generic.List(Of Integer)
	while Number <> 0
		Dim remainder As Integer= Number Mod base
		Number = CInt(Number / base)
 
		if remainder < 0 then
			remainder += system.math.abs(base)
			Number+=1
		end if
 
		digits.Insert(0, remainder)
	end while
 
	return digits
end function

unsigned int toNegaBinary(unsigned int value) // input in standard binary
{
	unsigned int Schroeppel2 = 0xAAAAAAAA; // = 2/3*((2*2)^16-1) = ...1010
	return (value + Schroeppel2) ^ Schroeppel2; // eXclusive OR
	// resulting unsigned int to be interpreted as string of elements ε {0,1} (bits)
}

function toNegaBinary( number ) {
    var Schroeppel2 = 0xAAAAAAAA;
    // Convert to NegaBinary String
    return ( ( number + Schroeppel2 ) ^ Schroeppel2 ).toString(2);
}

unsigned int toNegaQuaternary(unsigned int value) // input in standard binary
{
	unsigned int Schroeppel4 = 0xCCCCCCCC; // = 4/5*((2*4)^8-1) = ...11001100 = ...3030
	return (value + Schroeppel4) ^ Schroeppel4; // eXclusive OR
	// resulting unsigned int to be interpreted as string of elements ε {0,1,2,3} (pairs of bits)
}

function toNegaQuaternary( number ) {
    var Schroeppel4 = 0xCCCCCCCC;
    // Convert to NegaQuaternary String
    return ( ( number + Schroeppel4 ) ^ Schroeppel4 ).toString(4);
}

Arithmetic operations

The following describes the arithmetic operations for negabinary; calculations in larger bases are similar.

Carry:          1 −1  0 −1  1 −1  0  0  0
First addend:         1  0  1  0  1  0  1
Second addend:        1  1  1  0  1  0  0 +
               --------------------------
Number:         1 −1  2  0  3 −1  2  0  1
Bit (result):   1  1  0  0  1  1  0  0  1
Carry:          0  1 −1  0 −1  1 −1  0  0

Extra carry:       1  1  0  1  0  0  0     
Carry:          1  0  1  1  0  1  0  0  0
First addend:         1  0  1  0  1  0  1
Second addend:        1  1  1  0  1  0  0 +
               --------------------------
Answer:         1  1  0  0  1  1  0  0  1

Carry:          0  1 −1  1  0  0  0
First number:   1  1  0  1  0  0  1
Second number: −1 −1 −1  0 −1  0  0 +
               --------------------
Number:         0  1 −2  2 −1  0  1
Bit (result):   0  1  0  0  1  0  1
Carry:          0  0  1 −1  1  0  0

First number:                   1  1  1  0  1  1  0
Second number:                  1  0  1  1  0  1  1 ×
              -------------------------------------
                                1  1  1  0  1  1  0
                             1  1  1  0  1  1  0

                       1  1  1  0  1  1  0
                    1  1  1  0  1  1  0

              1  1  1  0  1  1  0                   +
              -------------------------------------
Carry:        0 −1  0 −1 −1 −1 −1 −1  0 −1  0  0
Number:       1  0  2  1  2  2  2  3  2  0  2  1  0
Bit (result): 1  0  0  1  0  0  0  1  0  0  0  1  0
Carry:           0 −1  0 −1 −1 −1 −1 −1  0 −1  0  0

Fractional numbers

Base −r representation may of course be carried beyond the radix point, allowing the representation of non-integral numbers.

As with positive-base systems, terminating representations correspond to fractions where the denominator is a power of the base; repeating representations correspond to other rationals, and for the same reason.

Imaginary base

Just as using a negative base allows the representation of negative numbers without an explicit negative sign, using an imaginary base allows the representation of Gaussian integers. Donald Knuth proposed the quater-imaginary base (base 2i) in 1955.^[11]

See also

• Quater-imaginary base
• Binary
• Balanced ternary
• Quaternary numeral system
• Numeral systems

References

Further reading

• Warren Jr., Henry S. (2013) [2002]. Hacker's Delight (2 ed.). Addison Wesley - Pearson Education, Inc. ISBN 978-0-321-84268-8. 0-321-84268-5.

External links

• Weisstein, Eric W. "Negabinary". MathWorld.
• Weisstein, Eric W. "Negadecimal". MathWorld.