Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"
GetNetWise: You
e One Click Away

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Glossary
MoreInfo
Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
FAQ
Copyright Info
Terms of Use
Privacy Info
Disclaimer
WorkBoard
Thanks
Donations
Advertising
Masthead / Impressum
Your Account

Communication
Feedback
Forums
Private Messages
Surveys

Features
HOWTOs
News Archive
Submit News
Topics
User Articles
Web Links

Google
Google


The Web
linux-tutorial.info

Who's Online
There are currently, 192 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here

  

bin_dec_hex



DESCRIPTION

       Most people use the decimal numbering system. This system
       uses ten symbols to represent numbers. When those ten sym­
       bols are used up, they start all over again and increment
       the position just before this. 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 as crypto to you, this is what I've 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 should be incremented, it is
       reset to 0 and the position before is incremented. Then
       number 9 can be seen as "00009" and when we should incre­
       ment 9, we reset it to zero and increment the digit just
       before the 9 so the number becomes "00010". For zero's we
       write a space if it is not the only digit (so: number 0)
       and if it is the first digit: "00010" -> " 0010" -> "
       010" -> "   10". It is not "   1 ".

       This was pretty basic, you already knew this. Why did I
       tell it ?  Well, computers do not represent numbers with
       10 different digits. They know of only two different sym­
       bols, being 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

       the decimal system. If we are talking about another num­
       bering system, we'll have to make that clear. There are a
       few wide-spread methods to do so. One common form is to
       write 1010(2) which means that you wrote down a number in
       the binary form. It is the number ten.  If you would write
       1010 it means the number one thousand and ten.

       In books, another form is most used. It uses subscript
       (little chars, more or less in between two rows). You can
       leave out the parentheses in that case and write down the
       number in normal characters followed with a little two
       just behind it.

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

       For the binary system, is is common to write leading
       zero's. The numbers are written down in series of four,
       eight or sixteen depending on the context.

       We can use the binary form when talking to computers
       (...programming...)  but the numbers will have large rep­
       resentations. The number 65535 would be written down as
       1111111111111111(2) which is 16 times the digit 1.  This
       is difficult and prone to errors. Therefore we normally
       would use another base, called hexadecimal. It uses 16
       different symbols. First the symbols from the decimal sys­
       tem are used, thereafter we continue with the alphabetic
       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 converted into the binary system very easy
       (and back).

       There is yet another system in use, called the octal sys­
       tem. This was more common in the old days but not anymore.
       You will find it in use on some places so get used to it.
       The same story applies, but now with only eight different
       symbols.

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

        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 preferred for
       that: You'd need three digits to represent 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
       hexadecimal 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. Each time take four
       digits from the right and make a hexadecimal digit from it
       (see the table above). Stop when there are no more digits.
       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). There­
       fore hexadecimal numbers get 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 com­
       mon 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 octal.  The following numbers are all
       the same, just the way they are written 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 per­
       haps you do not "see" it yet:
        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 can
       only use two symbols. Another example:

       %1010 would be

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

       It would have been more easy to convert it to its hexadec­
       imal form and just translate %1010 into 0xA. After a while
       you get used to it. You will not need to do any calcula­
       tions anymore but just know that 0xA means 10.

       To convert a decimal number into a hexadecimal one you
       could use the next method. It will take some time to be
       able to do the estimates but it will be more and more easy
       when you use the system more frequent. Another way is pre­
       sented to you thereafter.

       First you will need to know how many positions will be
       used in the other system. To do so, you need to know the
       If a number is smaller than 65536 it will thus fit in four
       positions.  If the number is bigger than 4095, you will
       need to use position 4.  How many times can you take 4096
       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.

       Number is 41029. 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 41029 ten times without going below
       zero.  The leftmost digit will be "A" so we have 0xA????.
       The number is reduced to 41029 - 10*4096 = 41029-40960 =
       69.  69 is smaller than 16^3 but not bigger than 16^2-1.
       The second digit is therefore "0" and we know 0xA0??.  69
       is smaller than 16^2 and bigger than 16^1-1. We can sub­
       tract 16^1 (which is just plain 16) four times and write
       down "4" to get 0xA04?.  Take 64 from 69 (69 - 4*16) and
       the last digit is 5 --> 0xA045.

       The other method builds the number from the right. Take
       again 41029.  Divide by 16 and do not use fractions (only
       whole numbers).

        41029 / 16 is 2564 with a remainder of 5. Write down 5.
        2564 / 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. Personally 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 fre­
       quently while programming, if the number is close then I
       will use the first method (like 32770, translate into
       32768 + 2 and 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 simple if you should write down a zero or a one: if
       you divide by two the remainder will be zero if it was an
       even number and one if it was 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

        %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 in the base that is used.  In any representa­
       tion it is the same, add the numbers on the right, write
       down the rightmost digit from the result, remember the
       other digits and use them in the next round. Continue with
       the second digits 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, check
       them with a calculator. The more you do the calculations
       yourself, the more you find that you didn't make mistakes.
       In the end, you'll do calculi in other bases as easy as
       you do in decimal.

       I hope you enjoyed the examples and their descriptions. If
       you do, help other people by pointing them to this docu­
       ment when they are asking basic 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.0.45                      2002-02-26             BIN_DEC_HEX(1)
  
Show your Support for the Linux Tutorial

Purchase one of the products from our new online shop. For each product you purchase, the Linux Tutorial gets a portion of the proceeds to help keep us going.


Login
Nickname

Password

Security Code
Security Code
Type Security Code


Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!


Amazon Wish List

Did You Know?
The Linux Tutorial welcomes your suggestions and ideas.


Friends



Tell a Friend About Us

Bookmark and Share



Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.09 Seconds