(Source: www.slideshare.net)

Contents

- 1. Calculation
- 2. Multiplication
- 3. Difficulty
- 4. Applications
- 5. Significant

You can read the page on numeric representation to review. This document will introduce you to the methods for adding and multiplying binary numbers.

In each section, the topic is developed by first considering the binary representation of unsigned numbers (which are the easiest to understand), followed by signed numbers and finishing with fractions (the hardest to understand). Adding unsigned numbers in binary is quite easy.

Addition is done exactly like adding decimal numbers, except that you have only two digits (0 and 1). So to add the numbers 06 10 =0110 2 and 07 10 =0111 2 (answer=13 10 =1101 2) we can write out the calculation (the results of any carry is shown along the top row, in italics).

In this case the extra carry from the most significant bit has no meaning. With signed numbers there are two ways to get an overflow -- if the result is greater than 7, or less than -8.

Obviously both of these results are incorrect, but in this case overflow is harder to detect. But you can see that if two numbers with the same sign (either positive or negative) are added and the result has the opposite sign, an overflow has occurred.

(Source: www.tattoosforyou.org)

Typically, DSP's, including the 320C5x, can deal somewhat with this problem by using something called saturation arithmetic, in which results that result in overflow are replaced by either the most positive number (in this case 7) if the overflow is in the positive direction, or by the most negative number (-8) for overflows in the negative direction. There is no further difficult in adding two signed fractions, only the interpretation of the results differs.

Multiplying unsigned numbers in binary is quite easy. Multiplication can be performed done exactly as with decimal numbers, except that you have only two digits (0 and 1).

When multiplying larger numbers, the result will be 8 bits, with the leftmost set to 1, as shown. As long as there are n+m bits for the result, there is no chance of overflow.

The easiest is to simply find the magnitude of the two multiplicands, multiply these together, and then use the original sign bits to determine the sign of the result. Multiplication by zero is a special case (the result is always zero, with no sign bit).

Although it is almost impossible to get an overflow (since the multiplicands and results usually have magnitude less than one), it is possible to get an overflow by multiplying -1x-1 since the result of this is +1, which cannot be represented by fixed point numbers. This means that we end up with two bits to the left of the decimal point.

(Source: ruinmyweek.com)

This obviously presents a difficulty if we wanted to store the number in a Q3 result, because if we took just the 4 leftmost bits, we would end up with two sign bits. So what we'd like to do is shift the number to the left by one and then take the 4 leftmost bit.

Mealtime systems consist of multiple processors communicating with each other via messages. In many systems this is achieved simply by defining C/C++ structures to implement the message format.

Attempting to write a 16-bit number at an odd address results in an exception. The reasons for not permitting misaligned long word reads and writes are not difficult to see.

Thus, the microprocessor can read the complete long word in a single bus cycle. If the same microprocessor now attempts to access a long word at address 0×000D, it will have to read bytes Y0, Y1, Y2 and Y3.

Notice that this read cannot be performed in a single 32 bit bus cycle. Thus, two applications using the same structure definition header file might be incompatible with each other.

(Source: www.tattoosforyou.org)

Thus, it is a good practice to insert pad bytes explicitly in all C-structures that are shared in an interface between machines differing in either the compiler and/or microprocessor. The following byte padding rules will generally work with most 32-bit processor.

You should consult your compiler and microprocessor manuals to see if you can relax any of these rules. Sometimes array indexing efficiency can also determine the pad bytes in the structure.

Since this operation involves a multiply, indexing into arrays can be expensive. The array indexing can be considerably speeded up by just making sure that the structure size is a power of 2.

The compiler can then replace the multiply with a simple shift operation. Big-endian is an order in which the “big end” (most significant byte) is stored first (at the lowest address).

The table below shows the representation of the hexadecimal number 0×0AC0FFEE on a big-endian and little-endian machine. Lilliputians were divided into two groups based on the end from which the egg should be broken.

(Source: wonderfuldiy.com)

The list of those defined as part of TLS 1.1 is in RFC 4346 Appendix A.5. This cipher suite then determines how these symmetric keys are eventually shared.

Certification Authorities tend to put “256 bits” on their websites because it looks good from a marketing point of view. It's not wrong, but it can be misleading for people who don't understand that it's how your server is set up and what your clients support that matters.

02: Off Road Truck

06: Of Blue Tack

07: Of High Turnout

09: Of Horse Nail