one of my interests is alternate numbering systems.
I’ve talked about them in a few videos, but one thing I haven’t really talked about
in a video yet is my original method for giving names to numbering systems.
there’s a full description of this system that’s been on my website for years at this
point, but given that I’m currently simultaneously working on like five distinct video projects
and I don’t think I’ll get any of them done in time to be the big video I put out
for this month, I figured I might as well make a quick little video about this, and
maybe some of you will find it interesting.
almost everyone uses base ten to count things.
that’s usually written like that, “base one-zero”. and if you’re used to seeing
numbers written in base ten, writing “base ten” like “base one-zero” is completely
normal and understandable.
but the thing is, every base is “base one-zero”. by definition, in any given base, one-zero
is the way you write the base itself.
what it means to be base six is that one-zero means six.
when you’re talking about different numbering systems, the fact that every base is base
one-zero makes this way of referring to bases extremely ambiguous.
you need to specify what base you’re using to talk about a given base.
but since the base you’re using is also base one-zero, you need to specify what base
you’re using to talk about that base.
there’s easy boring solutions to this.
you could just write out the English name of the number in full, or just have everyone
agree that base ten is the default.
but that’s not ideal, especially in the context where people are talking about using
other bases as alternatives to base ten.
what you’d like is a way of talking about bases in a way that is itself base-neutral.
and so, bases are given names.
Latin-derived names, typically.
there’s binary, ternary, quaternary, quinary, senary, septenary, octal, nonary, decimal,
undecimal, duodecimal, and so on.
these names are well-established and commonly used.
but the thing is, this still isn’t really base-neutral, at least not any more base-neutral
than just using English words for numbers.
like English, Latin uses base ten, and Latin names for numbers are rather decimal-centric.
for example, base twelve, duodecimal, is a rather popular numbering system, and many
people who like base twelve specifically dislike the name “duodecimal”, since it represents
twelve as “two plus ten”. if you’re trying to promote a numbering system where
twelve is written as one-zero, calling twelve two plus ten doesn’t feel right.
for this exact reason, the name “dozenal” is commonly used instead, and it’s a very
good name.
while etymologically it is technically still from something that at one point meant “two
plus ten”, it’s a much more fitting name for base twelve than duodecimal.
so, that’s the reason I came up with my own system for naming bases a few years ago.
I wanted to create a truly base-neutral method for referring to different numbering systems.
it’s a little bit quirky, and not exactly the most elegant possible system, but I’m
still happy with it, and I think it’s a lot of fun.
for bases where the existing Latin name isn’t super explicitly decimal, their names can
just still be from Latin.
this includes all the bases up to ten, plus vigesimal for base twenty and centesimal for
base one hundred.
there’s also a few where instead of the more traditional Latin name I went with an
alternative that I think is easier to understand, specifically trinary instead of ternary for
base three, and seximal and septimal instead of senary and septenary for bases six and
seven.
seximal for base six in particular is one that I feel very strongly about.
as you may know, base six is my personal favorite numbering system, and I really don’t like
the name “senary” for it.
unless you’re already familiar with the intricacies of Latin number words, “senary”
just doesn’t sound like it has much to do with the number six, nor does it really sound
like it’s the same type of word as “binary” or “decimal”.
what it sounds like is “scenery”, a completely unrelated word that just happens to be spelled
kinda similarly. and like, the last thing I want is for people to hear me talking about
base six and think I’m actually talking about something completely unrelated.
so that’s why I call it “seximal” instead.
on top of that set of Latiny names, this system also incorporates a couple names for bases
that are already well-known, namely dozenal for base twelve, and hex for base sixteen.
“hex” is short for “hexadecimal”, a mixed Greek-Latin name that’s very base
ten, but the shorter name “hex” is a commonly used alternative that’s just base-neutral
enough to fit in with this system.
I also incorporated the name niftimal for base thirty-six.
this is from the Ndom word “nif”, meaning thirty-six, which is also used in my English-language
implementation of seximal as the word for thirty-six.
“niftimal” also happens to sound a bit like the word “nifty”, which is very fun.
as I’ll talk about soon, the core of this base-naming system uses factorization, and
as such prime numbers are pretty important to it, so the final set of root names are
used specifically for prime numbered bases.
base eleven is elevenary, obviously from the English word “eleven”. base thirteen is
baker’s dozenal, as in a baker’s dozen. and finally, base seventeen, a base which
would be very impractical to use, is called suboptimal.
some people have pointed out that this name kinda sounds like it’s saying that base
eighteen is the optimal base, which isn’t the intention, but oh well.
anyway, as I was saying, outside of these ones that get their own simple root names,
bases are named according to factorization.
naming numbering systems according to factorization is really useful, because what factors a base
has can tell you a lot about its properties.
like, two and five are easy numbers to deal with in decimal, because ten is divisible
by two and five.
so uh, the first one that doesn’t get its own root name is base fourteen, right after
baker’s dozenal.
fourteen is two times seven, so it’s called biseptimal.
you use the prefix bi- to multiply a base by two.
then base fifteen, three times five, is triquinary, with tri- meaning times three.
great, so then there’s hex, then suboptimal, then base eighteen.
so, eighteen is two times three times three, so you could call it bitritrinary, or you
could call it two times nine, binonary.
so, since numbers can be factorized in multiple ways, there needs to be some way of figuring
out which way you’re supposed to do it.
the solution I came up with is that you want to factorize the number into whatever factors
are closest together, and put the smaller one first.
so, for eighteen, that’s three times six, so it’s triseximal.
next is base nineteen, which is a prime base.
all smaller prime bases got their own roots, but there needs to be some way of deriving
names for prime bases that are arbitrarily large.
so, what you do is you take the base one below it, and add the prefix un- to mean “plus
one”. so, base nineteen is untriseximal.
this might seem like a pretty arbitrary way to do it, and of course it is, all of this
is arbitrary.
but the benefit of naming prime bases after the factorization of the number one below
them is that just like how a base’s factors determine some of their properties, the factors
of the number right below a base also determine some of the base’s properties.
for example, in decimal, while two and five are the most convenient numbers to deal with,
three is also pretty convenient, and that’s because it’s a factor of nine, one less
than ten.
next is twenty, vigesimal, gets its own root; then there’s twenty-one, triseptimal, three
times seven; twenty-two, bielevenary, two times eleven; twenty-three, unbielevenary,
prime base so it’s one plus two times eleven; then twenty-four can be factored a few different
ways but the one with the factors closest together is four times six, so it’s tetraseximal,
with tetra- for times four.
now’s a good time I think to talk about the rest of the multiplicative prefixes, since
I think you get the point.
so, every root name also has a corresponding prefix. in general, these prefixes are from
Ancient Greek, like how “hexadecimal” combines both Greek and Latin number words
together.
some of them aren’t though, like bi- for two is a Latin thing.
but yeah, bi- is two, tri- is three, tetra- is four, penta- is five, hexa- is six, hepta-
is seven, octo- is eight, enna- is nine, deca- is ten, leva- is eleven, doza- is twelve,
baker- is thirteen, tesser- is sixteen, mal- is seventeen, icosi- is twenty, feta- is thirty-six,
and hecto- is one hundred.
another thing that makes naming bases according to their factors a useful thing to do is that
when you’re dealing with a really large base, it’s somewhat impractical to actually
have unique symbols and names for every single digit.
I talked about this in one of the videos I did with Artifexian about number systems,
but one solution to this problem is mixed radix. this means that the factor that determines
the value of each position in a positional notation relative to adjacent positions isn’t
always the same.
the go-to example for how this works is a digital clock, where some digits are ten times
the value of the digit to the right, but others are six times the value of the digit to the
right.
this is using base six and base ten together as an intuitive way to use base sixty without
actually needing sixty distinct digits.
and, since in my system bases are named according to their factorization, the name itself tells
you which radices you can mix together.
following the algorithm, the canonical factorization for sixty is six times ten, the exact pair
of radices used by digital clocks.
so, we just take base ten, decimal, and add the multiplicative prefix for six, hexa-,
and we get the name “hexadecimal”.
wait.
okay, so, the problem we’ve just run into is that if you add a multiplicative prefix
to “decimal”, it’ll sound like you’re using the traditional base-naming system to
talk about a completely different base.
that’s pretty confusing.
so to avoid that, when you put a prefix before “decimal”, it becomes -gesimal instead,
so base sixty is hexagesimal, not hexadecimal.
the other base that’s different when there’s a prefix before it is “baker’s dozenal”.
while this is a very good name that I like a lot, it can be a bit cumbersome and awkward
to add a prefix to it.
so, when there’s a prefix, “baker’s dozenal” gets shortened to just -ker’s
dozenal.
so, for example, the Excel column numbering system, base twenty-six, two baker’s dozen,
is called biker’s dozenal.
now for prime numbers.
as before, these multiplicative prefixes are derived from the factorization of the number
one less than the given prime number.
instead of un-, you use the Greek-derived hen- to mean “plus one”. so, the multiplicative
prefix form of untriseximal is hentrihexa-.
however, this has the risk of being ambiguous.
for instance, what would base 646 be called? it factorizes as nineteen times thirty-four.
thirty-four is itself two times seventeen, so base thirty-four is bisuboptimal.
adding the multiplicative prefix for nineteen, hentrihexa-, we get hentrihexabisuboptimal.
but while we know that the hen means to add one to some portion of the prefix before suboptimal,
it’s unclear exactly which part.
while you could figure it out by looking at the different possibilities and seeing that
only one of them follows all of the rules of this system, you shouldn’t have to do
that.
you could rearrange the roots of this name to make something easier to understand, as
in bihentrihexasuboptimal, but there’s no guarantee that you’d always be able to do
that, and it’s an inelegant solution either way.
so what you actually do is you add something to the end of a big prime multiplicative prefix.
having spoken parentheses like this is a kinda unnatural thing to do, so to make it as painless
as possible, the close-bracket particle is -sna-, which is very fun to say.
so, the prefix for nineteen is hentrihexasna-. you could in theory have a system for working
out when this close-bracket particle is actually necessary, but I think just always using it
no matter what is fine.
and that’s almost everything.
there’s just a couple more minor rules for optimizing stuff.
as I said before, what you do when you’re factorizing a number is you go with whatever
two factors are closest together.
usually, those factors will themselves need to be broken down, and you just do that recursively.
so like, ninety-eight is two times seven times seven, but it’s factorized as seven times
fourteen, and then fourteen is two times seven, so base ninety-eight is heptabiseptimal.
okay, but now let’s say you wanted to use something like base six hundred.
six hundred is twenty four times twenty five.
twenty four is four times six, tetraseximal, and twenty five is five times five, pentaquinary,
so base six hundred should be tetrahexapentaquinary.
but the thing is, that name is way longer than it really needs to be.
why bother calling it four times six times five times five when this system has a specific
root word for four times five times five? just call it six times one hundred, hexacentesimal.
so, what you actually do when selecting how to factorize a number is first try to minimize
the number of roots you need to use, then pick the factors that are closest together.
so, even though twenty four and twenty five are right next to each other, the fact that
six and one hundred both can be expressed with single roots in this system means that
that’s prioritized.
uh, there’s also some rules for dealing with vowel sequences that show up when one
root that ends with a vowel is followed by another root that starts with a vowel.
here’s the whole table for what to do with those.
all of this stuff is designed so that in theory you could for any given number work out its
name in this system by hand, but I also have made stuff that automatically figures out
these names.
outside of this set of roots, there’s a few extra ones that extend the range of this
system to include more types of number.
while the smallest base that’s really functional is binary, base one still kinda works, and
it’s called unary.
base zero can also be described in theoretical terms, but it would be literally impossible
to use in any capacity.
nevertheless, it’s called “nullary” by this system.
this extends the range of numbers that work in this system to include all natural numbers.
negative bases can also sometimes be useful, so they have names generated using the prefix
nega-, following the established convention of negabinary and negadecimal for bases negative
two and negative ten. this extends the range of numbers that work in this system to include
all integers.
now, outside of the domain of bases that are sometimes useful, there’s non-integer bases.
these are incorporated using the prefix vot-.
vot- is used for the reciprocal of any integer base. for example, votdecimal is base one
tenth. as you might have guessed, this is a reference to the language Vötgil. in Vötgil,
numbers are represented in decimal, but with their digits read backwards.
this could be interpreted as Vötgil using base on tenth, hence votdecimal.
these vot- bases can then have the usual multiplicative prefixes added to them to represent any rational
number base.
so like, base two thirds is bivottrinary.
finally, there are the suffixes -nary and -imal. these suffixes can be added to the
names of any number, with -nary used for numbers less than six and -imal used for numbers greater
than six, which makes it so that this system can work with any number which can be named.
and that is the full system.
there’s definitely some parts that are kinda awkward to use, and it’s not exactly the
most mathematically elegant notation, but I still kinda like it.
there’s definitely some things I think I would change if I were to go back and remake
this system from the ground up now, but I’m still happy with it.
now, one thing you’ve definitely noticed is just how long these names can get.
the reason people who commonly use base sixteen call it hex isn’t so it can have its own
base-neutral name, it’s because “hexadecimal” is just too long to say every time.
so, to go along with this base-naming system, I’ve also come up with a system for abbreviating
these base names.
unlike the base-naming system itself, this is not designed to be an algorithm a human
could do by hand.
I haven’t really described anywhere how exactly this thing works, so to close out
this video I’ll do that here.
broadly speaking, this algorithm cycles through every possible abbreviation for the given
base, and picks whichever one it encounters first that doesn’t conflict with the abbreviation
for any smaller base. and uh, here’s exactly how it does that.
first, it checks if the number it’s given is a positive integer.
anything else is outside of the scope of what this algorithm is supposed to work with, so
if it’s not a positive integer it just stops here.
if it is a positive integer, it then looks up if the abbreviation for this particular
base has already been saved to memory, since it would be a waste of time to calculate it
again.
next, it figures out the given base’s name using the process I’ve been describing throughout
this video.
it then rewrites that to be in all caps, and removes any spaces or apostrophes, specifically
so that baker’s dozenal and the like don’t get abbreviations that include non-letter
characters.
next, it removes any vowels that appear in the name outside of the first three letters.
the letter Y at the end of many base names is not removed at this step, even though it’s
a vowel.
the reason for doing this is that vowels that appear later in these base names aren’t
that distinctive, and including them in an abbreviation wouldn’t result in the most
intuitive abbreviations.
the string which will be the final abbreviation is created, by default being just the first
three letters of the base name, which we already had to figure out in that initial vowel removal
process.
also, an integer k is initialized to zero here.
one more number to start keeping track of is the current target length for the abbreviation,
“abbvLen”, which is set to three.
we are now ready for the main loop of the algorithm.
first, check if the current abbreviation is used by any smaller base.
if it’s not, we’re done and can move on.
otherwise, keep going.
now, we take that number k and convert it to binary. we can now use this binary number
and our trimmed base name to generate an abbreviation.
you take the binary number with its bits ordered from least to most significant, and line them
up with the string you’re abbreviating, with that least significant bit lined up with
the second character in the string.
then, for each bit, if that bit is one, you include the corresponding character in the
abbreviation. for the first character, the one that doesn’t line up with any bit, that
one is just always included.
next, we take that abbreviation and check if its length is “abbvLen”, the length
we currently want the abbreviation to be.
yeah, this part is pretty inefficient.
what I should have done when I made this all those years ago is have it check if it’ll
be the right length before doing all that working out and actually generating the abbreviation.
this wastes a lot of time.
oh, right, one more case to worry about.
if it turns out that k is too big for that process of lining up the binary number with
the string you’re abbreviating to work, then we add one to abbvLen and reset k to
zero.
for some reason, which might have just been a mistake, the way it checks if k is too big
for this actually says that it’s too big if there’s a one corresponding to the final
character in the string? so, because of that, these abbreviations just never include the
final letter of a base name.
I legitimately don’t remember if that’s intentional or not.
it probably wasn’t.
anyway, now that we have our abbreviation, we add one to k, then go back to the top of
the loop. is this abbreviation used by any smaller base? if not, we’ve found the abbreviation,
but if it is, we now find the abbreviation corresponding to the new value of k.
once we finally have our abbreviation and exit the loop, we store it into that hash
map so we can look it up later, and then return it.
so, that’s how abbreviations are generated using this pretty messy code I wrote a long
time ago.
I went through and checked for every base up to base ten thousand, hectocentesimal,
just to get some stats on how short these abbreviations are.
of those, 29.55% were three letters long, 68.49% were four letters long, and the remaining
1.96% were five letters long, which I think is a pretty good result.
and also, even though the majority in that particular range were four letters long, the
smallest base that needs four letters is bakerpentanonary, base 585, abbreviated as BAKR. the bases people
would actually consider using are way smaller than that, and they all get nice three letter
abbreviations.
and also, bases that do get three-letter abbreviations are found throughout the whole range of numbers
I checked, all the way up to EVC for ennalevuncentesimal, base 9999, and there’s three letter abbreviations
for names as long as the thirty-five-letter long henbihenbilevasnasnaheptatriquinary for
base 4935, which gets comfortably abbreviated as HVQ.
HVQ is the most efficient abbreviation in the range I checked, but the least efficient
is base sixteen, hex. since “hex” is already three letters long, and since these abbreviations
can’t be shorter than three letters, its abbreviation is the only one which isn’t
any shorter than the thing it’s abbreviating. if you exclude three-letter abbreviations,
no abbreviation within the range was any worse than one third the length of the full name
for the base, seen with FETN for base 6948, fetundozahex, and HECTC for base 10,000, hectocentesimal.
while this system for generating abbreviations is very fun, and does in fact create effective
shorthand names for different bases, a major issue with it is that there’s no way of
working out what base a given abbreviation refers to.
the other thing is that my code for this is just really inefficient, and has lots of room
for optimization.
it has a tendency to get stuck for a really long time whenever it has to do an abbreviation
that’s more than four letters long.
anyway, that’s pretty much it.
I wasn’t kidding before when I said I was working on like five other videos right now,
so look forward to at least one of those in the coming weeks.