UNIT1: NUMBER SYSTEMS & CODES

UNIT1: NUMBER SYSTEMS & CODES Philosophy of number systems Complement representation of negative numbers Binary arithmetic Binary codes Error detecting & error correcting codes Hamming codes HISTORY OF THE NUMERAL SYSTEMS: A numeral system (or system of numeration) is a linguistic system and mathematical notation for representing numbers of a given set by symbols in a consistent manner. For example, It allows the numeral "11" to be interpreted as the binary numeral for three, the decimal numeral for eleven, or other numbers in different bases. Ideally, a numeral system will: Represent a useful set of numbers (e.g. all whole numbers, integers, or real numbers) Give every number represented a unique representation (or at least a standard representation) Reflect the algebraic and arithmetic structure of the numbers. For example, the usual decimal representation of whole numbers gives every whole number a unique representation as a finite sequence of digits, with the operations of arithmetic (addition, subtraction, multiplication and division) being present as the standard algorithms of arithmetic. However, when decimal representation is used for the rational or real numbers, the representation is no longer unique: many rational numbers have two numerals, a standard one that terminates, such as 2.31, and another that recurs, such as 2.309999999.... Numerals which terminate have no non-zero digits after a given position. For example, numerals like 2.31 and 2.310 are taken to be the same, except in the experimental sciences, where greater precision is denoted by the trailing zero. The most commonly used system of numerals is known as Hindu-Arabic numerals. Great Indian mathematicians Aryabhatta of Kusumapura (5 th Century) developed the place value notation. Brahmagupta (6 th Century) introduced the symbol zero. Unary System: Every natural number is represented by a corresponding number of symbols, for example the number seven would be represented by ///////. Elias gamma coding which is commonly used in data compression expresses arbitrary-sized numbers by using unary to indicate the length of a binary numeral. With different symbols for certain new values, if / stands for one, - for ten and + for 100, then the number 123 as + - - /// without any need for zero. This is called signvalue notation. More elegant is a positional system, also known as place-value notation. Again working in base 10, we use ten different digits 0,..., 9 and use the position of a digit to signify the power of ten that the digit is to be multiplied with, as in 304 = 3 100 + 0 10 + 4 1. Note that zero, which is not needed in the other systems, is of crucial importance here, in order to be able to "skip" a power. In certain areas of computer science, a modified base-k positional system is used, called bijective numeration, with digits 1, 2,..., k (k 1), and zero being represented by the empty string. This establishes a bijection between the set of all such digit-strings and the set of non-negative integers, avoiding the non-uniqueness 1

caused by leading zeros. Bijective base-k numeration is also called k-adic notation, not to be confused with p- adic numbers. Bijective base-1 the same as unary. Five A base-5 system (quinary), on the number of fingers, has been used in many cultures for counting. It may also be regarded as a sub-base of other bases, such as base 10 and base 60. Eight A base-8 system (octal), spaces between the fingers, was devised by the Yuki of Northern California, who used the spaces between the fingers to count, corresponding to the digits one through eight Ten The base-10 system (decimal) is the one most commonly used today. It is assumed to have originated because humans have ten fingers. These systems often use a larger superimposed base. Twelve Base-12 systems (duodecimal or dozenal) have been popular. It is the smallest multiple of one, two, three, four and six. There is still a special word for 12 1, dozen and a word for 12 2, gross. Multiples of 12 have been in common use as English units of resolution in the analog and digital printing world, where 1 point equals 1/72 of an inch and 12 points equal 1 pica, and printer resolutions like 360, 600, 720, 1200 or 1440 dpi (dots per inch) are common. These are combinations of base-12 and base-10 factors: (3 12) 10, (5 12) 10, (6 12) 10, (10 12) 10 and (12 12) 10. Twenty The Maya civilization and other civilizations of Pre-Columbian Mesoamerica used base-20 (vigesimal). Remnants of a Gaulish base-20 system also exist in French, as seen today in the names of the numbers from 60 through 99. The Irish language also used base-20 in the past. Danish numerals display a similar base- 20 structure. Sixty Base 60 (sexagesimal) was used by the Sumerians and their successors in Mesopotamia and survives today in our system of time (hence the division of an hour into 60 minutes and a minute into 60 seconds) and in our system of angular measure (a degree is divided into 60 minutes and a minute is divided into 60 seconds). 60 also has a large number of factors, including the first six counting numbers. Base-60 systems are believed to have originated through the merging of base-10 and base-12 systems. Dual base (five and twenty) Many ancient counting systems use 5 as a primary base, almost surely coming from the number of fingers on a person's hand. Often these systems are supplemented with a secondary base, sometimes ten, sometimes twenty. In some African languages the word for 5 is the same as "hand" or "fist". Counting continues by adding 1, 2, 3, or 4 to combinations of 5, until the secondary base is reached. In the case of twenty, this word often means "man complete". This system is referred to as quinquavigesimal. It is found in many languages of the Sudan region. 2

BINARY The ancient Indian writer Pingala developed advanced mathematical concepts for describing prosody, and in doing so presented the first known description of a binary numeral system. A full set of 8 trigrams and 64 hexagrams, analogous to the 3-bit and 6-bit binary numerals, were known to the ancient Chinese in the classic text I Ching. An arrangement of the hexagrams of the I Ching, ordered according to the values of the corresponding binary numbers (from 0 to 63), and a method for generating the same, was developed by the Chinese scholar and philosopher Shao Yong in the 11th century. In 1854, British mathematician George Boole published a landmark paper detailing an algebraic system of logic that would become known as Boolean algebra. His logical calculus was to become instrumental in the design of digital electronic circuitry. In 1937, Claude Shannon produced his master's thesis at MIT that implemented Boolean algebra and binary arithmetic using electronic relays and switches for the first time in history. Entitled A Symbolic Analysis of Relay and Switching Circuits, Shannon's thesis essentially founded practical digital circuit design. In November 1937, George Stibitz, then working at Bell Labs, completed a relay-based computer he dubbed the "Model K" (for "Kitchen", where he had assembled it), which calculated using binary addition. The Complex Number Computer was completed by January 8, 1940, was able to calculate complex numbers. On September 11, 1940, Stibitz was able to send the Complex Number Calculator remote commands over telephone lines by a teletype. Binary codes Binary codes are codes which are represented in binary system with modification from the original ones. Weighted Binary codes Non Weighted Codes Weighted binary codes are those which obey the positional weighting principles, each position of the number represents a specific weight. The binary counting sequence is an example. Decimal BCD 8421 Excess-3 84-2-1 2421 5211 Bi-Quinary 5043210 5 0 4 3 2 1 0 0 0000 0011 0000 0000 0000 0100001 0 X X 1 0001 0100 0111 0001 0001 0100010 1 X X 2 0010 0101 0110 0010 0011 0100100 2 X X 3 0011 0110 0101 0011 0101 0101000 3 X X 4 0100 0111 0100 0100 0111 0110000 4 X X 5 0101 1000 1011 1011 1000 1000001 5 X X 6 0110 1001 1010 1100 1010 1000010 6 X X 7 0111 1010 1001 1101 1100 1000100 7 X X 8 1000 1011 1000 1110 1110 1001000 8 X X 9 1001 1111 1111 1111 1111 1010000 9 X X 3

Reflective Code A code is said to be reflective when code for 9 is complement for the code for 0, and so is for 8 and 1 codes, 7 and 2, 6 and 3, 5 and 4. Codes 2421, 5211, and excess-3 are reflective, whereas the 8421 code is not. Sequential Codes A code is said to be sequential when two subsequent codes, seen as numbers in binary representation, differ by one. This greatly aids mathematical manipulation of data. The 8421 and Excess-3 codes are sequential, whereas the 2421 and 5211 codes are not. Non weighted codes Non weighted codes are codes that are not positionally weighted. That is, each position within the binary number is not assigned a fixed value. Ex: Excess-3 code Excess-3 Code Excess-3 is a non weighted code used to express decimal numbers. The code derives its name from the fact that each binary code is the corresponding 8421 code plus 0011(3). Gray Code The gray code belongs to a class of codes called minimum change codes, in which only one bit in the code changes when moving from one code to the next. The Gray code is non-weighted code, as the position of bit does not contain any weight. The gray code is a reflective digital code which has the special property that any two subsequent numbers codes differ by only one bit. This is also called a unit-distance code. In digital Gray code has got a special place. Decimal Number Binary Code Gray Code Decimal Number Binary Code Gray Code 0 0000 0000 8 1000 1100 1 0001 0001 9 1001 1101 2 0010 0011 10 1010 1111 3 0011 0010 11 1011 1110 4 0100 0110 12 1100 1010 5 0101 0111 13 1101 1011 6 0110 0101 14 1110 1001 7 0111 0100 15 1111 1000 Binary to Gray Conversion Gray Code MSB is binary code MSB. Gray Code MSB-1 is the XOR of binary code MSB and MSB-1. MSB-2 bit of gray code is XOR of MSB-1 and MSB-2 bit of binary code. MSB-N bit of gray code is XOR of MSB-N-1 and MSB-N bit of binary code. 4

Error-Detection Codes Binary information may be transmitted through some communication medium, e.g. using wires or wireless media. A corrupted bit will have its value changed from 0 to 1 or vice versa. To be able to detect errors at the receiver end, the sender sends an extra bit (parity bit) with the original binary message. A parity bit is an extra bit included with the n-bit binary message to make the total number of 1 s in this message (including the parity bit) either odd or even. If the parity bit makes the total number of 1 s an odd (even) number, it is called odd (even) parity. The table shows the required odd (even) parity for a 3-bit message. At the receiver end, an error is detected if the message does not match have the proper parity (odd/even). Parity bits can detect the occurrence 1, 3, 5 or any odd number of errors in the transmitted message. At the receiver end, an error is detected if the message does not match have the proper parity (odd/even). Parity bits can detect the occurrence 1, 3, 5 or any odd number of errors in the transmitted message. No error is detectable if the transmitted message has 2 bits in error since the total number of 1 s will remain even (or odd) as in the original message. In general, a transmitted message with even number of errors cannot be detected by the parity bit. Three-Bit Message Odd Parity Bit Even Parity Bit X Y Z P P 0 0 0 1 0 0 0 1 0 1 0 1 0 0 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 1 1 0 1 0 1 1 1 0 1 Binary information may be transmitted through some communication medium, e.g. using wires or wireless media. Noise in the transmission medium may cause the transmitted binary message to be corrupted by changing a bit from 0 to 1 or vice versa. To be able to detect errors at the receiver end, the sender sends an extra bit (parity bit). Gray Code The Gray code consists of 16 4-bit code words to represent the decimal Numbers 0 to 15. For Gray code, successive code words differ by only one bit from one to the next as shown in the table and further illustrated in the Figure. 5

Error detection codes The general idea for achieving error detection and correction is to add some redundancy (i.e., some extra data) to a message, which receivers can use to check consistency of the delivered message, and to recover data determined to be erroneous. Error-detection and correction schemes can be either systematic or nonsystematic: In a systematic scheme, the transmitter sends the original data, and attaches a fixed number of check bits (or parity data), which are derived from the data bits by some deterministic algorithm. If only error detection is required, a receiver can simply apply the same algorithm to the received data bits and compare its output with the received check bits; if the values do not match, an error has occurred at some point during the transmission. In a system that uses a non-systematic code, the original message is transformed into an encoded message that has at least as many bits as the original message. Good error control performance requires the scheme to be selected based on the characteristics of the communication channel. Common channel models include memory-less models where errors occur randomly and with a certain probability, and dynamic models where errors occur primarily in bursts. Consequently, error-detecting and correcting codes can be generally distinguished between random-errordetecting/correcting and burst-error-detecting/correcting. Some codes can also be suitable for a mixture of random errors and burst errors. If the channel capacity cannot be determined, or is highly varying, an error-detection scheme may be combined with a system for retransmissions of erroneous data. This is known as automatic repeat request (ARQ), and is most notably used in the Internet. An alternate approach for error control is hybrid automatic repeat request (HARQ), which is a combination of ARQ and error-correction coding. Error detection schemes Error detection is most commonly realized using a suitable hash function (or checksum algorithm). A hash function adds a fixed-length tag to a message, which enables receivers to verify the delivered message by recomputing the tag and comparing it with the one provided. There exists a vast variety of different hash function designs. However, some are of particularly widespread use because of either their simplicity or their suitability for detecting certain kinds of errors (e.g., the cyclic redundancy check's performance in detecting burst errors). Random-error-correcting codes based on minimum distance coding can provide a suitable alternative to hash functions when a strict guarantee on the minimum number of errors to be detected is desired. Repetition codes, described below, are special cases of error-correcting codes: although rather inefficient, they find applications for both error correction and detection due to their simplicity. Repetition codes A repetition code is a coding scheme that repeats the bits across a channel to achieve error-free communication. Given a stream of data to be transmitted, the data is divided into blocks of bits. Each block is transmitted some predetermined number of times. For example, to send the bit pattern "1011", the four-bit block can be repeated three times, thus producing "1011 1011 1011". However, if this twelve-bit pattern was received as "1010 1011 1011" where the first block is unlike the other two it can be determined that an error has occurred. 6

Repetition codes are not very efficient, and can be susceptible to problems if the error occurs in exactly the same place for each group (e.g., "1010 1010 1010" in the previous example would be detected as correct). The advantage of repetition codes is that they are extremely simple, and are in fact used in some transmissions of numbers stations. Parity bits A parity bit is a bit that is added to a group of source bits to ensure that the number of set bits (i.e., bits with value 1) in the outcome is even or odd. It is a very simple scheme that can be used to detect single or any other odd number (i.e., three, five, etc.) of errors in the output. An even number of flipped bits will make the parity bit appear correct even though the data is erroneous. Extensions and variations on the parity bit mechanism are horizontal redundancy checks, vertical redundancy checks, and "double," "dual," or "diagonal" parity (used in RAID-DP). Checksums A checksum of a message is a modular arithmetic sum of message code words of a fixed word length (e.g., byte values). The sum may be negated by means of a one's-complement prior to transmission to detect errors resulting in all-zero messages. Checksum schemes include parity bits, check digits, and longitudinal redundancy checks. Some checksum schemes, such as the Luhn algorithm and the Verhoeff algorithm, are specifically designed to detect errors commonly introduced by humans in writing down or remembering identification numbers. Cyclic redundancy checks (CRCs) A cyclic redundancy check (CRC) is a single-burst-error-detecting cyclic code and non-secure hash function designed to detect accidental changes to digital data in computer networks. It is characterized by specification of a so-called generator polynomial, which is used as the divisor in a polynomial long division over a finite field, taking the input data as the dividend, and where the remainder becomes the result. Cyclic codes have favorable properties in that they are well suited for detecting burst errors. CRCs are particularly easy to implement in hardware, and are therefore commonly used in digital networks and storage devices such as hard disk drives. Even parity is a special case of a cyclic redundancy check, where the single-bit CRC is generated by the divisor x+1. Cryptographic hash functions A cryptographic hash function can provide strong assurances about data integrity, provided that changes of the data are only accidental (i.e., due to transmission errors). Any modification to the data will likely be detected through a mismatching hash value. Furthermore, given some hash value, it is infeasible to find some input data (other than the one given) that will yield the same hash value. Message authentication codes, also called keyed cryptographic hash functions, provide additional protection against intentional modification by an attacker. 7

Error-correcting codes Any error-correcting code can be used for error detection. A code with minimum Hamming distance, d, can detect up to d-1 errors in a code word. Using minimum-distance-based error-correcting codes for error detection can be suitable if a strict limit on the minimum number of errors to be detected is desired. Codes with minimum Hamming distance d=2 are degenerate cases of error-correcting codes, and can be used to detect single errors. The parity bit is an example of a single-error-detecting code. The Berger code is an early example of a unidirectional error(-correcting) code that can detect any number of errors on an asymmetric channel, provided that only transitions of cleared bits to set bits or set bits to cleared bits can occur. Hamming Codes It is an error correction code that separates the bits holding the original value (data bits) from the error correction bits (check bits), and the difference between the calculated and actual error correction bits is the position of the bit that's wrong. Error correction codes are a way to represent a set of symbols so that if any 1 bit of the representation is accidentally flipped, you can still tell which symbol it was. For example, you can represent two symbols x and y in 3 bits with the values x=111 and y=000. If you flip any one of the bits of these values, you can still tell which symbol was intended. If more than 1 bit changes, you can't tell, and you probably get the wrong answer. So it goes; 1-bit error correction codes can only correct 1-bit changes. If b bits are used to represent the symbols, then each symbol will own 1+b values: the value representing the symbol, and the values differing from it by 1 bit. In the 3-bit example above, y owned 1+3 values: 000, 001, 010, and 100. Representing n symbols in b bits will consume n*(1+b) values. If there is a 1-bit error correction code of b bits for n symbols, then n*(1+b) <= 2 b. An x-bit error correction code requires that n*( (b choose 0) + (b choose 1) +... + (b choose x) ) <= 2 b. The key to the Hamming Code is the use of extra parity bits to allow the identification of a single error. Create the code word as follows: 1. Mark all bit positions that are powers of two as parity bits. (positions 1, 2, 4, 8, 16, 32, 64, etc.) 2. All other bit positions are for the data to be encoded. (positions 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 17, etc.) 3. Each parity bit calculates the parity for some of the bits in the code word. The position of the parity bit determines the sequence of bits that it alternately checks and skips. Position 1: check 1 bit, skip 1 bit, check 1 bit, skip 1 bit, etc. (1,3,5,7,9,11,13,15,...) Position 2: check 2 bits, skip 2 bits, check 2 bits, skip 2 bits, etc. (2,3,6,7,10,11,14,15,...) Position 4: check 4 bits, skip 4 bits, check 4 bits, skip 4 bits, etc. (4,5,6,7,12,13,14,15,20,21,22,23,...) Position 8: check 8 bits, skip 8 bits, check 8 bits, skip 8 bits, etc. (8-15,24-31,40-47,...) Position 16: check 16 bits, skip 16 bits, check 16 bits, skip 16 bits, etc. (16-31,48-63,80-95,...) Position 32: check 32 bits, skip 32 bits, check 32 bits, skip 32 bits, etc. (32-63,96-127,160-191,...) etc. 4. Set a parity bit to 1 if the total number of ones in the positions it checks is odd. Set a parity bit to 0 if the total number of ones in the positions it checks is even. 8

Here is an example: A byte of data: 10011010 Create the data word, leaving spaces for the parity bits: 1 _ 0 0 1 _ 1 0 1 0 Calculate the parity for each parity bit (a? represents the bit position being set): Position 1 checks bits 1,3,5,7,9,11:? _ 1 _ 0 0 1 _ 1 0 1 0. Even parity so set position 1 to a 0: 0 _ 1 _ 0 0 1 _ 1 0 1 0 Position 2 checks bits 2,3,6,7,10,11: 0? 1 _ 0 0 1 _ 1 0 1 0. Odd parity so set position 2 to a 1: 0 1 1 _ 0 0 1 _ 1 0 1 0 Position 4 checks bits 4,5,6,7,12: 0 1 1? 0 0 1 _ 1 0 1 0. Odd parity so set position 4 to a 1: 0 1 1 1 0 0 1 _ 1 0 1 0 Position 8 checks bits 8,9,10,11,12: 0 1 1 1 0 0 1? 1 0 1 0. Even parity so set position 8 to a 0: 0 1 1 1 0 0 1 0 1 0 1 0 Code word: 011100101010. Finding and fixing a bad bit The above example created a code word of 011100101010. Suppose the word that was received was 011100101110 instead. Then the receiver could calculate which bit was wrong and correct it. The method is to verify each check bit. Write down all the incorrect parity bits. Doing so, you will discover that parity bits 2 and 8 are incorrect. It is not an accident that 2 + 8 = 10, and that bit position 10 is the location of the bad bit. In general, check each parity bit, and add the positions that are wrong, this will give you the location of the bad bit. Try one yourself Test if these code words are correct, assuming they were created using an even parity Hamming Code. If one is incorrect, indicate what the correct code word should have been. Also, indicate what the original data was. 010101100011 0 1 0 1 0 1 1 0 0 0 1 1 C1 0 Therefore No 0 1 0 1 0 1 1 0 0 0 1 1 C2 0 Error 0 1 0 1 0 1 1 0 0 0 1 1 C3 0 0 1 0 1 0 1 1 0 0 0 1 1 C4 0 111110001100 1 1 1 1 1 0 0 0 1 1 0 0 C1 0 Error is in Bit 4 1 1 1 1 1 0 0 0 1 1 0 0 C2 1 1 1 1 1 1 0 0 0 1 1 0 0 C3 0 1 1 1 1 1 0 0 0 1 1 0 0 C4 0 000010001010 0 0 0 0 1 0 0 0 1 0 1 0 C1 1 Error is in Bit 9

0 0 0 0 1 0 0 0 1 0 1 0 C2 1 7 0 0 0 0 1 0 0 0 1 0 1 0 C3 1 0 0 0 0 1 0 0 0 1 0 1 0 C4 0 Binary Arithmetic: An ordinary decimal number can be regarded as a polynomial in powers of 10. For example, 423.12 can be regarded as 4 X102 + 2 X101 + 3 X100 + 1 X10-1 + 2 X10-2. Decimal numbers like this are said to be expressed in a number system with base, or radix, 10 because there are 10 basic digits (0, 1, 2,, 9) from which the number system is formulated. In a similar fashion we can express any number N in a system using any base b. We shall write such a number as (N)b. Whenever (N)b is written, the convention of always expressing b in base 10 will be followed. Thus (N) b = (p n p n-1 p 1 p 0. p -1 p -2 p -m )b where b is an integer greater than 1 and 0 < pi < b -1. The value of a number represented in this fashion, which is called positional notation, is given by (N) b = p n b n + p n-1 b n-1 + + p 0 b 0 +p -1 b -1 +p -2 b -2 +..+p -m b -m n i (N ) = b t = m p i b For decimal numbers, the symbol. is called the decimal point; for more general base-b numbers, it is called the radix point. That portion of the number to the right of the radix point (p -1 p -2 p -m ) is called the fractional part, and the portion to the left of the radix point (p n p n+1 p 0 ) is called the integral part. Numbers expressed in base 2 are called binary numbers. They are often used in computers since they require only two coefficient values. The integers from 0 to 15 are given in Table below for several bases. Since there are no coefficient values for the range 10 to b 1 when b > 10, the letters A, B, C,... are used. Base-8 numbers are called octal numbers, and base-16 numbers are called hexadecimal numbers. Octal and hexadecimal numbers are often used as a shorthand for binary numbers. An octal number can be converted into a binary number by converting each of the octal coefficients individually into its binary equivalent. The same is true for hexadecimal numbers. This property is true because 8 and 16 are both powers of 2. For numbers with bases that are not a power of 2, the conversion to binary is more complex. 10

Sudhakar Chekuri Switching Theory and Logic Design Base 2 3 4 5... 8... 10 11 12 16 (N)b 0001 001 01 01 01 01 01 01 1 0010 002 02 02 02 02 02 02 2 0011 010 03 03 03 03 03 03 3 0100 011 10 04 04 04 04 04 4 0101 012 11 10 05 05 05 05 5 0110 020 12 11 06 06 06 06 6 0111 021 13 12 07 07 07 07 7 1000 022 20 13 10 08 08 08 8 1001 100 21 14 11 09 09 09 9 1010 101 22 20 12 10 0A 0A A 1011 102 23 21 13 11 10 0B B 1100 110 30 22 14 12 11 10 C 1101 111 31 23 15 13 12 11 D 1110 112 32 24 16 14 13 12 E 1111 120 33 30 17 15 14 13 F In converting (N)10 to (N)b the fraction and integer parts are converted separately. First, consider the integer part (portion to the left of the decimal point). The general conversion procedure is to divide (N)10 by b, giving (N)10/b and a remainder. The remainder, call it p0, is the least significant (rightmost) digit of (N)b. The next least significant digit, p1, is the remainder of (N)10/b divided by b, and succeeding digits are obtained by continuing this process. A convenient form for carrying out this conversion is illustrated in the following example. (a) (23) 10 = (10111) 2 (b) (23) 10 = (27) 8 c) (410) 10 = (3120) 5 2 23 (Remainder) 2 11 1 2 5 1 2 2 1 2 1 0 0 1 8 23 (Remainder) 5 410 (Remainder) 8 2 7 5 82 0 0 2 5 16 2 5 3 1 0 3 Now consider the portion of the number to the right of the decimal point, i.e., the fractional part. The procedure for converting this is to multiply (N)10 (fractional) by b. If the resulting product is less than 1, then the most significant (leftmost) digit of the fractional part is 0. If the resulting product is greater than 1, the most significant digit of the fractional part is the integral part of the product. The next most significant digit is formed by multiplying the fractional part of this product by b and taking the integral part. The remaining digits are formed by repeating this 11

process. The process may or may not terminate. A convenient form for carrying out this conversion is illustrated below. (a) (0.625) 10 = (0.5) 8 0.625 x 8 = 5.000 0.5 (b) (0.23) 10 = (0.001110... ) 2 0.23 x 2 = 0.46 0.0 0.46 x 2 = 0.92 0.00 0.92 x 2 = 1.84 0.001 0.84 x 2 = 1.68 0.0011 0.68 x 2 = 1.36 0.00111 0.36 x 2 = 0.72 0.001110 (c) (27.68) 10 = (11011.101011... ) 2 = (33.53... ) 8 2 27 2 13 2 6 2 3 2 1 0 27 8 8 3 0 0.68 x 2 = 1.36 0.1 1 0.36 x 2 = 0.72 0.10 1 0.72 x 2 = 1.44 0.101 0 0.44 x 2 = 0.88 0.1010 1 0.88 x 2 = 1.76 0.10101 1 0.76 x 2 = 1.52 0.68 x 8 = 5.44 0.101011 0.5 3 0.44 x 8 = 3.52 0.53 3 This example illustrates the simple relationship between the base-2 (binary) system and the base-8 (octal) system. The binary digits, called bits, are taken three at a time in each direction from the binary point and are expressed as decimal digits to give the corresponding octal number. For example, 101 in binary is equivalent to 5 in decimal; so the octal number in part (c) above has a 5 for the most significant digit of the fractional part. The conversion between octal and binary is so simple that the octal expression is sometimes used as a convenient shorthand for the corresponding binary number. When a fraction is converted from one base to another, the conversion may not terminate, since it may not be possible to represent the fraction exactly in the new base with a finite number of digits. For example, consider the conversion of (0.1) 3 to a base-10 fraction. The result is clearly (0.333 ) 10, which can be written as ( 0.3 ) 10 to indicate that the 3's are repeated indefinitely. It is always possible to represent the result of a conversion of base in this notation, since the non-terminating fraction must consist of a group of digits which are repeated indefinitely. For example, (0.2) 11 = 2 x 11-1 = (0.1818 ) 10 = ( 0.1818 ) 10. 12

It should be pointed out that by combining the two conversion methods it is possible to convert between any two arbitrary bases by using only arithmetic of a third base. For example, to convert (16)7 to base 3, first convert to base 10, (16)7 = 1X7 1 + 6X7 0 = 7 + 6 = (13)10 Then convert (13)10 to base 3, 3 13 3 4 3 1 3 0 (Remainder) 1 (16)7 = (13)10 = (111)3 1 1 Binary Addition The binary addition table is as follows: Sum Carry 0 + 0 = 0 0 0 + 1 = 1 0 1 + 0 = 1 0 1 + 1 = 0 1 Addition is performed by writing the numbers to be added in a column with the binary points aligned. The individual columns of binary digits, or bits, are added in the usual order according to the above addition table. Note that in adding a column of bits, there is a 1 carry for each pair of 1's in that column. These 1 carries are treated as bits to be added in the next column to the left. A general rule for addition of a column of numbers (using any base) is to add the column decimally and divide by the base. The remainder is entered as the sum for that column, and the quotient is carried to be added in the next column. Base 2 Carries: 10011 11 1001.011 = (9.375)10 1101.101 =(13.625)10 10111.000 = (23)10 = Sum Binary Subtraction The binary subtraction table is as follows: Difference Borrow 0-0 = 0 0 0-1 = 1 1 1-0 = 1 0 1-1 = 0 0 13

Subtraction is performed by writing the minuend over the subtrahend with the binary points aligned and carrying out the subtraction according to the above table. If a borrow occurs and the next leftmost digit of the minuend is a 1, it is changed to a 0 and the process of subtraction is then continued from right to left. Base 2 Base 10 Borrow: 1 0 Minuend 10 2 Subtrahend - 01-1 ------------------------------- Difference 01 1 ------------------------------- If a borrow occurs and the next leftmost digit of the minuend is a 0, then this 0 is changed to a 1, as is each successive minuend digit to the left which is equal to 0. The first minuend digit to the left which is equal to 1 is changed to 0, and then the subtraction process is resumed. Base 2 Base 10 Borrow: 1 0 1 1 Minuend 1 1 0 0 0 24 Subtrahend - 1 0 0 0 1-17 Difference 0 0 1 1 1 7 Base 2 Base 10 Borrow: 1 1 0 1 0 1 1 Minuend 1 0 1 0 0 0 40 Subtrahend - 0 1 1 0 0 1-25 Difference 0 0 1 1 1 1 15 Sign-and-magnitude method One may first approach the problem of representing a number's sign by allocating one sign bit to represent the sign: set that bit (most significant bit) to 0 for a positive number, and set to 1 for a negative number. The remaining bits in the number indicate the magnitude (or absolute value). Hence in a byte with only 7 bits (apart from the sign bit), the magnitude can range from 0000000 (0) to 1111111 (127). Thus you can represent numbers from 127 10 to +127 10 once you add the sign bit (the eight bit). A consequence of this representation is that there are two ways to represent zero, 00000000 (0) and 10000000 ( 0). Decimal 43 encoded in an eightbit byte this way is 10101011. This approach is directly comparable to the common way of showing a sign (placing a "+" or " " next to the number's magnitude). Some early binary computers (e.g. IBM 7090) used this representation, perhaps because of its natural relation to common usage. Sign-and-magnitude is the most common way of representing the significand in floating point values. 14

Sudhakar Chekuri Switching Theory and Logic Design Binary Signed Unsigned 00000000 +0 0 00000001 1 1......... 01111111 127 127 10000000 0 128 10000001 1 129......... 11111111 127 255 Ones' complement Alternatively, a system known as ones' complement can be used to represent negative numbers. The ones' complement form of a negative binary number is the bitwise NOT applied to it the "complement" of its positive counterpart. Like sign-and-magnitude representation, ones' complement has two representations of 0: 00000000 (+0) and 11111111 ( 0). The sum of an n-bit number and its complement is zero. Negative(X)=(2^N 1) - X The negative of a 1 s complement number is found by inverting each bit, 0 to 1 and 1 to 0. Problem is this scheme has two values for zero. Finding a negative number is easy and only requires a bit wise complement operation. However, an addition which produces a carry requires an extra add operation for the carry. As an example, the ones' complement form of 00101011 (43) becomes 11010100 ( 43). The range of signed numbers using ones' complement is represented by (2 N 1 1) to (2 N 1 1) and +/ 0. A conventional eight-bit byte is 127 10 to +127 10 with zero being either 00000000 (+0) or 11111111 ( 0). 15

Binary value Ones' complement interpretation 00000000 +0 0 00000001 1 1......... 01111101 125 125 01111110 126 126 01111111 127 127 10000000 127 128 10000001 126 129 10000010 125 130 Unsigned interpretation To add two numbers represented in this system, one does a conventional binary addition, but it is then necessary to add any resulting carry back into the resulting sum. To see why this is necessary, consider the following example showing the case of the addition of 1 (11111110) to +2 (00000010). binary decimal 11111110-1 + 00000010 +2...... 1 00000000 0 <-- not correct +1 <-- add carry...... 00000001 1 <-- correct answer Complement/Negate......... 11111101 2 253 11111110 1 254 11111111 0 255 2 s complement Representation: The sum of an n-bit number and its 2 s complement is zero. Negative(X) = (2^N) -X = ((2^N 1)-X)+1. 2 s complement = 1 s complement + 1. Only problem is the range is not symmetric. There is one more negative number than positive. The negative of a 2 s complement number is found by inverting each bit, then adding 1. Only problem is the range is not symmetric. There is one more negative number than positive. 16

o unsigned Sign magnitude 1 s complement 2 s complement 1111 [15] 0111 [7] 0111 [7] 0111 [7] 1110 0110 0110 0110 [6] 1101 0101 0101 0101 [5] 1100 0100 0100 0100 [4] 1011 0011 0011 0011 [3] 1010 0010 0010 0010 [2] 1001 0001 0001 0001 [1] 1000 0000, 1000[-0] 0000, 1000[-0] 0000 [0] 0111 1001 1110 1111 [-1] 0110 1010 1101 1110 [-2] 0101 1011 1100 1101 [-3] 0100 1100 1011 1100 [-4] 0011 1101 1010 1011 [-5] 0010 1110 1001 1010 [-6] 0001 1111 [-7] 1000 [-7] 1001 [-7] 0000 [0] 1000 [-8] Complement/Negate 01011101 number 10100010 invert bits 10100010 + 1 add 1 10100011 2 s Complement 01011101 number 10100011 2 s Complement 1 00000000 (discard carrys in 2 s complement arithmetic) o Addition 0100 [+4] 0100 [+4] 1101 [-3] 1011 [-5] 1 0001 [+1] [ignore carry] 0 1111 [-1] [no carry] Signed and Unsigned Arithmetic: (comparisons) Signed Arithmetic a) Use: in numerical computation b) Sign extension required for word size conversion c) Validity: produces overflow( = signed out-of range) and carry. 17

Unsigned Arithmetic a) Use: in address calculation b) No negative values c) No sign extension for word size conversion d) Validity: only produced carry ( = unsigned overflow = unsigned out-of-range) Arithmetic Exceptions/Multiword Precision: Sign Extension: a) Word size conversion: MSbit of word must be replicated in top of new word. b) Conversion to smaller word: produces truncation errors, i.e. changed sign c) Example: 4 bits: 1110 [-2] 8 bits: 1111 1110 [-2] byte 16 bits: 1111 1111 1111 1110 [-2] half word 32 bits: 1111 1111 1111 1111 1111 1111 1111 1110 [-2] word Arithmetic Exceptions/Multiword Precision: Overflow: (register) a) When a carry occurs from the msb-1 position to the msb and the sign of the is different from the sign of the two arguments. b) Overflow can not occur for the addition of two signed numbers with different signs. ( or subtraction with the same sign) c) Examples: 0100 [+4] 1100 [-4] 0101 [+5] 1011 [-5] 0 1001 [-7] (9) 1 0111 [+7] (-9) Carry/Borrow: a) Occurs during the addition of two unsigned numbers when a carry propagates from the Msbit of the result. b) Normally an error for unsigned arithmetic c) Basis for extended word precision. Words are added/subtracted from LSW to MSW with the carry from the previous word. d) Extended word precision for signed number is identical but the MSW addition/subtraction step uses signed arithmetic. e) Example: 1100 [12] 1011 [11] 0001 0111 [23] (16 + 7) 18

Questions 1 a What is the Gray code? What are the rules to construct Gray code? Develop the 4 bit Gray code for the decimal 0 to 15. b List the XS3 code for decimal 0 to 9 c What are the rules for XS3 addition? Add the two decimal numbers 123 and 658 in XS3 code. 2 Test if these code words are correct, assuming they were created using an even parity Hamming Code. If one is incorrect, indicate what the correct code word should have been. Also, indicate what the original data was. 010101100011 111110001100 000010001010 3 a Why the binary number system is used in computer design? b Given the binary numbers a = 1010.1, b = 101.01, c =1001.1 perform the following: i. a + c ii.a - b iii. a. c c Convert (2AC5.D) 16 to binary and then to octal 4 a What is the necessity of binary codes in computers? b Encode the decimal numbers 0 to 9 by means of the following weighted binary codes. i. 8 4 2 1 ii. 2 4 2 1 iii. 6 4 2-3 c Determine which of the above codes are self complementing and why? 5 a Explain the 7 bit Hamming code b A receiver with even parity Hamming code is received the data as 1110110. Determine the correct code. 6 The Octal system was devised by the Yuki of Northern California. Evaluate for A in each case. if (i) (A) 2 = (376) 8 (ii) (A) 10 = (376) 8 (iii) (A) 5 = (376) 8 (iv) (A) 12 = (376) 8 7 Write brief about i) Weighted Binary codes ii) Non Weighted Codes with at least one example code examples 8 Write brief about i) Reflective Code ii) Sequential Codes iii) Non weighted codes iv) Excess- 3 Code v) Gray Code vi) Repetition codes vii) Checksums viii) Cyclic redundancy checks (CRCs) ix) Cryptographic hash functions 9 Write down the procedure for converting a gray code to binary and vice versa (not more than 4 lines in each case) 10 Write a brief about Hamming Codes (Not more than 5 lines) and hamming distance (about 3 lines) 19

11 Check and find if any error in the received message. The message was coded by Hamming code method 0111001 12 Write the 32 bit pattern that your computer stores number (-2) if it uses i) 1 s complement method ii) 2 s complement method iii) Signed magnitude method 13 Make a table for 4 bit binary data representation in i) unsigned ii) Sign magnitude iii) 1 s complement iv) 2 s complement 14 The given data A = (AC) 16 B = (7D) 16 C = (F3) 16 ; Find A+B, A+B+C, A-C, A-B In each case i) if A,B,C are i) Sign magnitude ii) 2 s complement iii) Unsigned magnitude using binary arithmetic only. 20