MATLAB: Binary representation of stored integer of fi object

fi bin

I am using a lookup table with values ranging from 0 to pi/4.

These values are all less than one, i.e. 0 to .7854.

I am using the bin function to get the eight MSBs of a 16 bit number.

I noticed that bin(fi(.5000,0,16)) = 1000 0000 0000 0000 but bin(fi(.4555, 0, 16)) = 1110 1001 0011 0111

with bin(fi(.2500,0,16)) = 1000 0000 0000 0000.

Why do .5 and .25 have the same binary representation? Why does .4555 have a larger sized binary representation?

Best Answer

Hi,

if you only specify the word length and not the fraction length you get two different objects:

>> fi(0.25, 0, 16)
ans = 
  0.2500
          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Unsigned
            WordLength: 16
        FractionLength: 17
>> fi(0.5, 0, 16)
ans = 
    0.5000
          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Unsigned
            WordLength: 16
        FractionLength: 16

Note the difference on the FractionLength.

Now if you want to have numbers between 0 and 1, so FractionLength 16, you get what I think you are looking for:

>> bin(fi(0.5, 0, 16, 16))
ans =
1000000000000000
>> bin(fi(0.25, 0, 16, 16))
ans =
0100000000000000

Titus

Related Solutions

MATLAB: 0.35 divide 0.001 return double, and 0.34 divide 0.001 return int.

MATLAB does not represent numbers with fractions in decimal (not even in the Symbolic toolbox, but you have to push hard to prove that for the Symbolic toolbox).

MATLAB itself represents most numbers in IEEE 754 Double Precision, which is a representation that uses one sign bit, 11 bits of binary exponent, and 52 bits of binary fraction. For technical reasons, this gives 53 bits of precision: numbers are effectively represented as a 53 bit integer times a power of 2 (that might be negative). The only fractions that can be exactly represented are those involving powers of 2. It is like having an unreduced fraction in which the denominator is always 2^53. Other denominators such as 10 are only possible if they are powers of 2: for example the system can exactly represent 16ths, but never 3rds or 10ths, not exactly.

This system has exactly the same variety of limitations that sticking strictly to a fixed number of decimal places would have. For example if you pick any fixed number of decimal places, you can never exactly represent 1/3 or 1/7, and instead those end up in decimal being infinite repeating decimals, just like how 1/3 in decimal starts 0.333333333333333 but continues on infinitely. Now in decimal, take that number and multiply it by 3 again, and what you get is 0.999999999999999 rather than exactly 1.

Just so, in binary, 1/10 is an infinite repeating number, and if you truncate it to any finite number of decimal places, and multiply by 10 you do not get exactly 1 back.

Now, with some multiples of 1/10 in binary, when you multiply by 10, the result rounds to the representation of an integer, but that is not the case for all multiples of 1/10 in finite binary: for some of them, after multiplication you get a number that is 1 bit different than an exact integer, just like the 0.99999999999999 is 1 trailing decimal place different from an exact decimal integer.

So 0.34/0.001 with both numbers expressed in finite binary approximation ends up rounding to an exact integer but 0.35/0.001 with both numbers expressed in finite binary approximation ends up rounding to one bit different from an exact integer.

The moral of the story is: Don't Do That!! Avoid using fractions to calculate integer indices, because fractions are only approximations.

Example: instead of

for f=0.01:0.01:1
  G(100*f)=f.^2;
end

You can use

for fi = 1:100
  f=fi/100;
  G(fi) = f.^2;
 end

MATLAB: How to create a row of numbers form 1 to 10 ?. like this [1.0000, 2.0000, 3.0000,…]

with

format long;x=1:10
=
     1     2     3     4     5     6     7     8     9    10

vpa only adds one zero:

y=vpa(x,5)
=
[ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
y=vpa(x,10)
=
[ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]

floating point boundaries (without vpa):

flintmax
 =
9.007199254740992e+15
intmax
 =
2147483647
   intmin
   =
   -2147483648

with fixed point precision objects, details here: http://uk.mathworks.com/help/fixedpoint/ref/fi.html?searchHighlight=fi

you get more than 4 zeros:

    a = fi(pi, 1, 8, 3)
    a = 
       3.125000000000000
              DataTypeMode: Fixed-point: binary point scaling
                Signedness: Signed
                WordLength: 8
            FractionLength: 3

but only if it is rounding non-zero decimals:

a = fi(1, 1, 8, 3)
 = 
     1
            DataTypeMode: Fixed-point: binary point scaling
              Signedness: Signed
              WordLength: 8
          FractionLength: 3
   a = fi(1.0000, 1, 8, 3)
   = 
       1
            DataTypeMode: Fixed-point: binary point scaling
              Signedness: Signed
              WordLength: 8
          FractionLength: 3

tried 1.0001 and then -0001 but did not work:

b = fi(1.0001, 1) b = 1.000122070312500

          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Signed
            WordLength: 16
        FractionLength: 14
 b-.0001
Warning: The behavior of adding or subtracting a fi and a non-fi operand has
changed. The non-fi operand is now cast to the data type of the fi operand.
See the release notes for information on retaining the old behavior of best
precision scaling cast.  In  -  (line 37) 
 = 
     1
          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Signed
            WordLength: 17
        FractionLength: 14

c=b-.0001 = 1

          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Signed
            WordLength: 17
        FractionLength: 14
 b2=fi(0.0001,1)
 = 
     1.000016927719116e-04
          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Signed
            WordLength: 16
        FractionLength: 28

b-b2 = 1.000022068619728

          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Signed
            WordLength: 31
        FractionLength: 28

d=b-b2 = 1.000022068619728

          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Signed
            WordLength: 31
        FractionLength: 28
 d2=vpa(d,4)
 =
1.0

If you really want to present the vector exactly with 4 zero decimals, you can translate each figure to char,

x=[1:1:4]
x_char=char(x+48)'
 =
1
2
3
4

and then add '.000'

   x2=repmat(['.0000'],4,1)
   =
  .0000
  .0000
  .0000
  .0000
x_char=[x_char x2]
 =
1.0000
2.0000
3.0000
4.0000

If you find this answer of any help solving your question,

please click on the thumbs-up vote link,

thanks in advance

John

jgb2012@sky.com

Best Answer

Related Solutions

MATLAB: 0.35 divide 0.001 return double, and 0.34 divide 0.001 return int.

MATLAB: How to create a row of numbers form 1 to 10 ?. like this [1.0000, 2.0000, 3.0000,…]

Related Question