C Programming - Floating Point Issues - Discussion

Binary equivalent of 5.375 in normalised form is

0100 -> 4
0000 -> 0

1010 -> A
1100 -> C

0000 -> 0
0000 -> 0

0000 -> 0
0000 -> 0

Since the PC's (intel processors) use " LITTLE ENDIAN" byte order, the higher order byte of number is stored in lowest address. The result is written from bottom to top.

In the statement p= (char*) &a; we are doing type casting since p is a char pointer you cannot assign float variable to it a pointer variable can hold the address of another variable only if the variable has the same data type of that as pointer variable.

The format string used for each of the prints is %02X, which I've always interpreted as 'print the supplied int as a hexadecimal value with at least two digits'.

Understand the memory you will understand it easy

Used is little endian type of memory storage i.e., higher byte at lower address

Data:40 AC 00 00
100:40
101:AC
102:00
103:00

Now pointer to memory location points to 103
If it is used as character pointer it grabs a byte as char pointer is capable of handling only value of its size

On the other end if a integer pointer is used it would give output same as it is


For detailed view try this example,

int x=Ox12345678;
char *cp;
short int *sip;
int *ip;
ip=sip=cp=&x;
printf("%x %x %x",*cp,*sip,*ip);

O/P:0x78 0x5678 0x12345678

Thank you preeti:).

Can any please explain How to do normalization of floating point?

Normalize:

Given Floating point Number = 5.375

In binary:
5 = (101) and
0.375 = (011)
{ 0.375*2 = 0.750 --> 0
0.750*2 = 1.500 --> 1
0.500*2 = 1.000 --> 1 }

i.e., 5.375 = 101.011

For single precision representation, decimal point is shifted by 2 times.
i.e., 1.01011*2^2 = 1.01011*100 where 2 is true exponent.

According to IEEE, the representation has three fields:
----------------------------
| S | E | F |
----------------------------
S is one bit representing the sign of the number (0/1 & hidden bit)
E is an 8-bit biased integer representing the exponent
F is an unsigned integer

For single precision representation (the emphasis in this class)
n = 23
bias = 127

2 is the true exponent. For the standard form, it needs to be in 8-bit, biased-127 representation.

2
+127
-----
129

129 in 8-bit, unsigned representation is 1000 0001

The mantissa stored (F) is the stuff to the right of the radix point in the normalized form. We need 23 bits of it.

010110 00000000000000000

Put it all together (and include the correct sign bit):

S E F
0 1000 0001 010110 00000000000000000

The values are often given in hex, so here it is

0100 0000 1010 1100 0000 0000 0000 0000
0x 4 0 A C 0 0 0 0

@Shilpa m raj.

1.01011*2^2 = 1.01011*100 where 2 is true exponent.

I didn't understand, how *2^2 become *100.

I think this value stored in this manner.

0100 0000 1010 1100 0000 0000 0000 0000 which is 40ac0000.


float taken 4 byte in memory in program p=(char*)&a casting this to char type nw p(it char pointer its point to i byte value) point to lower byte of the a(5.375) which is 0000 0000.

p[0]-> contain the fist lower byte data 00(because print bye the hexa format specifier withe 2 width)
p[1]-> contain 00
p[2]-> contain ac
p[3]-> contain 40

Then output become ...0000ac40.

Little Endian means that the lower order byte of the number is stored in memory at the lowest address, and the higher order byte is stored at the highest address. That is, the little end comes first.

For example, a 4 byte, 32-bit integer.


Byte3 Byte2 Byte1 Byte0.


will be arranged in memory as follows:


Base_Address+0 Byte0.
Base_Address+1 Byte1.
Base_Address+2 Byte2.
Base_Address+3 Byte3.


Example :Intel processors use "Little Endian" byte order.


"Big Endian" means that the higher order byte of the number is stored in memory at the lowest address, and the lower order byte at the highest address. The big end comes first.


Base_Address+0 Byte3.
Base_Address+1 Byte2.
Base_Address+2 Byte1.
Base_Address+3 Byte0.


Motorola, Solaris processors use "Big Endian" byte order.