FreeBSD Manual Pages

BIN_DEC_HEX(1)			    rrdtool			BIN_DEC_HEX(1)

NAME
bin_dec_hex - How to use	binary,	decimal, and hexadecimal notation.

DESCRIPTION
Most people use the decimal numbering system. This system uses ten sym-
bols to represent numbers. When those ten symbols are used up, they
start all over again and	increment the position to the left. The	digit
0 is only shown if it is	the only symbol	in the sequence, or if it is
not the first one.

If this sounds cryptic to you, this is what I've	just said in numbers:

0
1
2
3
4
5
6
7
8
9
10
11
12
13

and so on.

Each time the digit nine	is incremented,	it is reset to 0 and the posi-
tion before (to the left) is incremented	(from 0	to 1). Then number 9
can be seen as "00009" and when we should increment 9, we reset it to
zero and	increment the digit just before	the 9 so the number becomes
"00010".	Leading	zeros we don't write except if it is the only digit
(number 0). And of course, we write zeros if they occur anywhere	inside
or at the end of	a number:

"00010"	-> " 0010" -> "	010" ->	"  10",	but not	"  1 ".

This was	pretty basic, you already knew this. Why did I tell it?	 Well,
computers usually do not	represent numbers with 10 different digits.
They only use two different symbols, namely "0" and "1".	Apply the same
rules to	this set of digits and you get the binary numbering system:

0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101

and so on.

If you count the	number of rows,	you'll see that	these are again	14
different numbers. The numbers are the same and mean the	same as	in the
first list, we just used	a different representation. This means that
you have	to know	the representation used, or as it is called the	num-
bering system or	base.  Normally, if we do not explicitly specify the
numbering system	used, we implicitly use	the decimal system. If we want
to use any other	numbering system, we'll	have to	make that clear. There
are a few widely	adopted	methods	to do so. One common form is to	write
1010(2) which means that	you wrote down a number	in its binary repre-
sentation. It is	the number ten.	If you would write 1010	without	speci-
fying the base, the number is interpreted as one	thousand and ten using
base 10.

In books, another form is common. It uses subscripts (little charac-
ters, more or less in between two rows).	You can	leave out the paren-
theses in that case and write down the number in	normal characters fol-
lowed by	a little two just behind it.

As the numbering	system used is also called the base, we	talk of	the
number 1100 base	2, the number 12 base 10.

Within the binary system, it is common to write leading zeros. The num-
bers are	written	down in	series of four,	eight or sixteen depending on
the context.

We can use the binary form when talking to computers (...program-
ming...), but the numbers will have large representations. The number
65'535 (often in	the decimal system a ' is used to separate blocks of
three digits for	readability) would be written down as
1111111111111111(2) which is 16 times the digit 1.  This	is difficult
and prone to errors. Therefore, we usually would	use another base,
called hexadecimal. It uses 16 different	symbols. First the symbols
from the	decimal	system are used, thereafter we continue	with alpha-
betic characters. We get	0, 1, 2, 3, 4, 5, 6, 7,	8, 9, A, B, C, D, E
and F. This system is chosen because the	hexadecimal form can be	con-
verted into the binary system very easily (and back).

There is	yet another system in use, called the octal system. This was
more common in the old days, but	is not used very often anymore.	As you
might find it in	use sometimes, you should get used to it and we'll
show it below. It's the same story as with the other representations,
but with	eight different	symbols.

Binary	    (2)
Octal	    (8)
Decimal	    (10)
Hexadecimal (16)

(2)    (8) (10)	(16)
00000	0    0	  0
00001	1    1	  1
00010	2    2	  2
00011	3    3	  3
00100	4    4	  4
00101	5    5	  5
00110	6    6	  6
00111	7    7	  7
01000  10    8	  8
01001  11    9	  9
01010  12   10	  A
01011  13   11	  B
01100  14   12	  C
01101  15   13	  D
01110  16   14	  E
01111  17   15	  F
10000  20   16	 10
10001  21   17	 11
10010  22   18	 12
10011  23   19	 13
10100  24   20	 14
10101  25   21	 15

Most computers used nowadays are	using bytes of eight bits. This	means
that they store eight bits at a time. You can see why the octal system
is not the most practical for that: You'd need three digits to repre-
sent the	eight bits and this means that you'd have to use one complete
digit to	represent only two bits	(2+3+3=8). This	is a waste. For	hexa-
decimal digits, you need	only two digits	which are used completely:

(2)	 (8)  (10) (16)
11111111 377  255   FF

You can see why binary and hexadecimal can be converted quickly:	For
each hexadecimal	digit there are	exactly	four binary digits.  Take a
binary number: take four	digits from the	right and make a hexadecimal
digit from it (see the table above). Repeat this	until there are	no
more digits. And	the other way around: Take a hexadecimal number. For
each digit, write down its binary equivalent.

Computers (or rather the	parsers	running	on them) would have a hard
time converting a number	like 1234(16). Therefore hexadecimal numbers
are specified with a prefix. This prefix	depends	on the language	you're
writing in. Some	of the prefixes	are "0x" for C,	"\$" for	Pascal,	"#"
for HTML.  It is	common to assume that if a number starts with a	zero,
it is octal. It does not	matter what is used as long as you know	what
it is. I	will use "0x" for hexadecimal, "%" for binary and "0" for oc-
tal.  The following numbers are all the same, just their	represenata-
tion (base) is different: 021 0x11 17 %00010001

To do arithmetics and conversions you need to understand	one more
thing.  It is something you already know	but perhaps you	do not "see"
it yet:

If you write down 1234, (no prefix, so it is decimal) you are talking
about the number	one thousand, two hundred and thirty four. In sort of
a formula:

1 * 1000 = 1000
2 *  100 =  200
3 *   10 =   30
4 *    1 =    4

This can	also be	written	as:

1 * 10^3
2 * 10^2
3 * 10^1
4 * 10^0

where ^ means "to the power of".

We are using the	base 10, and the positions 0,1,2 and 3.	 The right-
most position should NOT	be multiplied with 10. The second from the
right should be multiplied one time with	10. The	third from the right
is multiplied with 10 two times.	This continues for whatever positions
are used.

It is the same in all other representations:

0x1234 will be

1 * 16^3
2 * 16^2
3 * 16^1
4 * 16^0

01234 would be

1 * 8^3
2 * 8^2
3 * 8^1
4 * 8^0

This example can	not be done for	binary as that system only uses	two
symbols.	Another	example:

%1010 would be

1 * 2^3
0 * 2^2
1 * 2^1
0 * 2^0

It would	have been easier to convert it to its hexadecimal form and
just translate %1010 into 0xA. After a while you	get used to it.	You
will not	need to	do any calculations anymore, but just know that	0xA
means 10.

To convert a decimal number into	a hexadecimal you could	use the	next
method. It will take some time to be able to do the estimates, but it
will be easier when you use the system more frequently. We'll look at
yet another way afterwards.

First you need to know how many positions will be used in the other
system. To do so, you need to know the maximum numbers you'll be	using.
Well, that's not	as hard	as it looks. In	decimal, the maximum number
that you	can form with two digits is "99". The maximum for three:
"999". The next number would need an extra position. Reverse this idea
and you will see	that the number	can be found by	taking 10^3 (10*10*10
is 1000)	minus 1	or 10^2	minus one.

This can	be done	for hexadecimal	as well:

16^4 = 0x10000 = 65536
16^3 =	0x1000 =  4096
16^2 =	 0x100 =   256
16^1 =	  0x10 =    16

If a number is smaller than 65'536 it will fit in four positions.  If
the number is bigger than 4'095,	you must use position 4.  How many
times you can subtract 4'096 from the number without going below	zero
is the first digit you write down. This will always be a	number from 1
to 15 (0x1 to 0xF). Do the same for the other positions.

Let's try with 41'029. It is smaller than 16^4 but bigger than 16^3-1.
This means that we have to use four positions.  We can subtract 16^3
from 41'029 ten times without going below zero.	The left-most digit
will therefore be "A", so we have 0xA????.  The number is reduced to
41'029 -	10*4'096 = 41'029-40'960 = 69.	69 is smaller than 16^3	but
not bigger than 16^2-1. The second digit	is therefore "0" and we	now
have 0xA0??.  69	is smaller than	16^2 and bigger	than 16^1-1. We	can
subtract	16^1 (which is just plain 16) four times and write down	"4" to
get 0xA04?.  Subtract 64	from 69	(69 - 4*16) and	the last digit is 5
--> 0xA045.

The other method	builds ub the number from the right. Let's try 41'029
again.  Divide by 16 and	do not use fractions (only whole numbers).

41'029 / 16 is 2'564 with a remainder of 5. Write down 5.
2'564 /	16 is 160 with a remainder of 4. Write the 4 before the	5.
160 / 16 is 10 with no remainder. Prepend 45 with 0.
10 / 16	is below one. End here and prepend 0xA.	End up with 0xA045.

Which method to use is up to you. Use whatever works for	you.  I	use
them both without being able to tell what method	I use in each case, it
just depends on the number, I think. Fact is, some numbers will occur
frequently while	programming. If	the number is close to one I am	famil-
iar with, then I	will use the first method (like	32'770 which is	into
32'768 +	2 and I	just know that it is 0x8000 + 0x2 = 0x8002).

For binary the same approach can	be used. The base is 2 and not 16, and
the number of positions will grow rapidly. Using	the second method has
the advantage that you can see very easily if you should	write down a
zero or a one: if you divide by two the remainder will be zero if it is
an even number and one if it is an odd number:

41029 /	2 = 20514 remainder 1
20514 /	2 = 10257 remainder 0
10257 /	2 =  5128 remainder 1
5128 /	2 =  2564 remainder 0
2564 /	2 =  1282 remainder 0
1282 /	2 =   641 remainder 0
641 /	2 =   320 remainder 1
320 /	2 =   160 remainder 0
160 /	2 =    80 remainder 0
80 /	2 =    40 remainder 0
40 /	2 =    20 remainder 0
20 /	2 =    10 remainder 0
10 /	2 =	5 remainder 0
5 /	2 =	2 remainder 1
2 /	2 =	1 remainder 0
1 /	2 below	0 remainder 1

Write down the results from right to left: %1010000001000101

Group by	four:

%1010000001000101
%101000000100 0101
%10100000 0100 0101
%1010 0000 0100	0101

Convert into hexadecimal: 0xA045

Group %1010000001000101 by three	and convert into octal:

%1010000001000101
%1010000001000 101
%1010000001 000	101
%1010000 001 000 101
%1010 000 001 000 101
%1 010 000 001 000 101
%001 010 000 001 000 101
1   2   0   1   0   5 --> 0120105

So: %1010000001000101 =	0120105	= 0xA045 = 41029
Or: 1010000001000101(2)	= 120105(8) = A045(16) = 41029(10)
Or: 1010000001000101(2)	= 120105(8) = A045(16) = 41029

At first	while adding numbers, you'll convert them to their decimal
form and	then back into their original form after doing the addition.
If you use the other numbering system often, you	will see that you'll
be able to do arithmetics directly in the base that is used.  In	any
representation it is the	same, add the numbers on the right, write down
the right-most digit from the result, remember the other	digits and use
them in the next	round. Continue	with the second	digit from the right
and so on:

%1010 + %0111 --> 10	+ 7 -->	17 --> %00010001

will become

%1010
%0111 +
||||
|||+-- add 0 + 1, result is	1, nothing to remember
||+--- add 1 + 1, result is	%10, write down	0 and remember 1
|+---- add 0 + 1 + 1(remembered), result = 0, remember 1
+----- add 1 + 0 + 1(remembered), result = 0, remember 1
nothing to add, 1 remembered, result	= 1
--------
%10001 is the	result,	I like to write	it as %00010001

For low values, try to do the calculations yourself, then check them
with a calculator. The more you do the calculations yourself, the more
you'll find that	you didn't make	mistakes. In the end, you'll do	cal-
culi in other bases as easily as	you do them in decimal.

When the	numbers	get bigger, you'll have	to realize that	a computer is
not called a computer just to have a nice name. There are many differ-
ent calculators available, use them. For	Unix you could use "bc"	which
is short	for Binary Calculator. It calculates not only in decimal, but
in all bases you'll ever	want to	use (among them	Binary).

For people on Windows: Start the	calculator (start->programs->acces-
sories->calculator) and if necessary click view->scientific. You	now
have a scientific calculator and	can compute in binary or hexadecimal.

AUTHOR
I hope you enjoyed the examples and their descriptions. If you do, help
other people by pointing	them to	this document when they	are asking ba-
sic questions. They will	not only get their answer, but at the same
time learn a whole lot more.

Alex van	den Bogaerdt  <alex@ergens.op.het.net>

1.2.30				  2009-01-19			BIN_DEC_HEX(1)

NAME | DESCRIPTION | AUTHOR

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=bin_dec_hex&sektion=1&manpath=FreeBSD+13.0-RELEASE+and+Ports>