Before I embark on base three itself, let's start with a look at the smaller naturals and how they fare, as candidates for number base. Generally, the representation of numbers in positional notation involves picking a set of digits, each of which denotes one of the values modulo the number base; while these are typically the numbers from zero through one less than the number base, it's possible (with some limitations) to pick other values differing from each by multiples of the number base.

Base zero is silly: each integer is alone in its equivalence class mod 0, so you need infinitely many digits. All integers are equal mod 1, so we only get one digit. Any representation is then a sequence of instances of our one digit, each muliplied by power(position,1) = 1 and summed: so we get the digit times the representation's length as the number represented. Thus, using 1 as digit, we get the positive integers (if you can recognise when the empty string is present with this meaning, you can also represent the number zero to get the natural numbers). All things considered, neither of these number bases is much use.

Base two allows us the convenience of a non-empty representation of zero:
namely as a digit. If we'd used it as such in base one, all representations
would have been sequences of zeroes, representing zero: no others would have
been representable. However, in higher bases, it proves hugely useful –
it enables us to effectively skip a few positions in the digit-sequence used,
without the digit used as spacing interfering in the value. We have two
equivalence classes mod 2, and 0 is even, so the other digit must be odd. We'll
then be able to represent any multiple of that digit, so (again) we naturally
take 1 as our digit. This gives us the widely-used binary system: these digits
are known as bits. One complication is that you need some out-of-band way to
say when you want a negative value, and convention for representing them.
The two's complement

form is widely adopted for the latter, but the
system dealing with the data still needs the out-of-band sign to tell them to
read its data that way.

As in base two (and all higher), so also in base three, it's very convenient
to select 0 as one of our digits: we then need digits equivalent to 1 and 2. A
fairly conventional and easy solution is then to use {2,1,0} as digits. You
might enjoy playing with that for a while. While 1 makes a winning candidate
for its equivalence class, 2 is equivalent to −1 and there's some much
nicer symmetry to {1, 0, −1}. This has the nice property of making
truncation fair

: zeroing the last few digits of a number (or all those,
of a fraction's representation, past some point) changes as many numbers upwards
as downwards. Using {0,1,2}, that introduces a systematic bias (averaging one
in the first position discarded): but {1, 0, −1} avoids that bias. Base
three gets called ternary

and its digits (whether signed
or conventional) get called trits

, by analogy with
binary's bits

(binary digits).

Consider (in decimal) rounding 2.45 to the nearest .1 and to the nearest 1.
The latter gives 2: the former gives 2.5. Rounding this last to the nearest 1,
we get 3. If we'd started with 2.444445, with arbitrarily many 4s before the 5,
and rounded successively at each position, we'd get to 2.45 on the way, and
hence end at 3. This is, in fact, a general difficulty with an even base (even
if signed). On the other hand, in an even base, we can always truncate to one
digit short of where we want to round, and get the right result by rounding that
truncated form (because half

has a digit to represent it exactly): by
contrast, in base 9, 2.444445 is nearer to 3 than to 2 (since 3 −2.444445
is .444444), but if you truncate 2.444445 you'll lose the 5 and get a number
nearer to 2 than to 3. However, in an odd base we can use a 0-centered set of
digits, which will make truncation *be* rounding to nearest, which keeps
it free of the two defects discussed, one for odd natural bases the other for
even bases. Then again, representing 1/2 involves chosing which way you want it
rounded… but perhaps that's a sensible thing to require, after all.

Use −1, 0 and +1 as the digits for representing numbers, base three.
It may be worth doing experiments in base 9 with {−4, …, 0,
…, +4} as digits if you want to learn by playing with arithmetic –
and one might sensibly describe signed ternary, by bunching up the digits in
pairs, in this form (much as binary is commonly encoded as hexadecimal, bunching
up the bits in groups of four). However, for now, I'll use T for −1, 0
for zero and 1 for +1, and stick to ternary, as base three is known. This
signed form of it allows representation of arbitrary integers and reals, whether
positive or negative, without needing an out-of-band mechanism (such as a
leading sign-marker) to tell the reader the difference between positive and
negative values. We have T01 as minus eight and 10T as plus eight, without any
further complications, so that + and − only serve as binary operators, to
combine values, rather than having to also serve as unary operators

to
set or emphasise the sign.

Our rules for addition of single digits then have T +1 = 0, T+T = T1, 1 +1 =
1T and, as ever, adding 0 makes no difference. By judicious additions of 0 = T
+1 and recognition of trebling as shifting left, we can think of the two
doublings as: T +T = T +T +T +1 = T0 +1 = T1 and 1 +1 = 1 +1 +1 +T = 10 +T = 1T.
We deal with carrying

in the usual way, although it may take a little
practice to get used to it: 1T +T = 10 +T +T = 10 +T1 = 1, for example.

Multiplying can all be done by adding versions of one operand obtained by shifting and sometimes flipping based on the non-zero digits of the other; for each 1 in the latter, append a zero to the former for each digit after the 1; for each T do the same but flip 1 ↔ T in the other while shifting. Two is thus 1T (a three minus a one) and multiplying it by itself we get 1T0 (shifted left by one) added to T1 (flipped) to get 11 as four (three plus one); multiplying by the same again we get 1T0 +1T = 10T as eight (nine minus one). Multiplying 11 by itself we get 110 +11 = 1TT1 as sixteen (twenty-seven minus nine minus three plus 1); or multiplying 10T by 1T we get 10T0 +T01 = 1TT1, just the same. Roll-over when we have all digits the same and non-zero prepends one at the front and flips the rest, so thirteen plus one, 111 +1 = 1TTT, is twenty-seven minus thirteen, which is to say, fourteen. In particular, this happens at the transition from just below half a power of three to just above it, in contrast to a base using the digits from one up to one less than the base, where roll-over happens at one short of a power of the base.

That roll-over at half has another consequence: we can, of course, represent
numbers with fractional parts, approximated by sums of ± powers of a
third, that we necessarily separate from the whole number part of a number's
denotation by a fractional-part separtor, as we do in decimal (where the marker
gets the name decimal point

, so you could call the separator a ternary
point

if you like, even though many cultures will want to use something
other than a dot (or point

) for the purpose, but I prefer to call it what
it is: a separator for the fractional part).

Decimal has an endless tail of nines in the fractional part equivalent to bumping the digit before them all up by 1 (and, since it's not part of the endless tail of nines, it's not a nine, so we can do that without triggering a carry) and flipping those nines to zeros (which can duly be elided, as there's nothing non-zero after them). The corresponding effect in signed ternarry identifies an endless tail of ones in the fractional part with the result of replacing all those ones with minus-one digits (Ts, in my way of writing it) with the preceding digit increased (and, since it's not part of the endless tail of ones, this doesn't involve any carrying); likewise, an endless tail of Ts is equivalent to the result of flipping all those Ts to 1s and decreasing the preceding digit. Unlike the decimal roll-over, you'll notice this is entirely symmetric, reflecting the fact that those endless sequences represent ±half in the preceding digit and the choice between whether to end in endelss 1s or endless Ts is a decision about how you think that half-way value should be rounded by anyone that needs to work with finitely many trits.

Written by Eddy.