C / C ++-将32位浮点值转换为24位归一化定点值？

Question

Please let me know how to convert 32 bit float to 24 bit normalized value? What I tried is (units * (1 <<24) but doesn't seem to be working. Please help me with this. Thanks.

Answer 1

Of course it is not working, (1 << 24) is too large for a 24-bit number capable of representing 0 to store, by exactly 1 . To put this another way, 1 << 24 is actually a 25-bit number.

Consider (units * ((1 << 24) - 1)) instead.

_{(1 << 24) - 1 is the largest value an unsigned 24-bit integer that begins at 0 can represent.}

Now, a floating-point number in the range [ 0.0 - 1.0 ] will actually fit into an unsigned 24-bit fixed-point integer without overflow.

Answer 2

A normalized fixed-point representation, means that the maximum representable value, not strictly reachable, is 1. So 1 is represented by 1<<24 . See also Q Formats .
For example Q24 means 24 fractional bits, 0 integer bit and no sign. If using a 32 bits unsigned integer to manage a Q24, the remainig 8 bits can be used to ease calculations.
Before translating from floating-point to fixed-point representation, you always have to define the range for your original value. Example: the floating point value is a physical value in the range from [0, 5) , so 0 is included and 5 is not included in the range, and your fixed-point value is normalized to 5.

#include <string.h>
#include <stdio.h>

float length_flp = 4.5;     // Units: meters. Range: [0,5)
float time_flp = 1.2;       // Seconds. Range: [0,2)
float speed_flp = 1.2;      // m/sec. Range: [0,2.5)
unsigned uint32_t length_fixp;   // Meters. Representation: Q24 = 24 bit normalized to MAX_LENGTH=5
unsigned uint32_t time_fixp;     // Seconds. Representation: Q24 = 24 bit normalized to MAX_TIME=2
unsigned uint32_t speed_fixp;    // m/sec. Repr: Q24 = 24 bit normalized to MAX_SPEED=(MAX_LENGTH/MAX_TIME)=2.5

void main(void)
{
    printf("length_flp=%f m\n", length_flp);
    printf("time_flp=%f sec\n", time_flp);
    printf("speed_flp=%f m/sec\n\n", length_flp / time_flp);

    length_fixp = (length_flp / 5) * (1 << 24);
    time_fixp = (time_flp / 2) * (1 << 24);
    speed_fixp = (length_fixp / (time_fixp >> 12)) << 12;

    printf("length_fixp=%d m\n", length_fixp);
    printf("time_fixp=%d sec\n", time_fixp);
    printf("speed_fixp = %d msec [fixed-point] = %f msec\n", speed_fixp, (float)speed_fixp / (1 << 24) * 2.5);
}

The advantage with normalized representation is that operations between normalized values return a normalized value. By the way, you have to define a generic function for each operation (division, multiplication, etc.), to prevent overflow and save precision. As you can see I've used a small trick to calculate speed_fixp . The output is

length_flp=4.500000 m
time_flp=1.200000 sec
speed_flp=3.750000 m/sec

length_fixp = 15099494 m [fixed-point]
time_fixp = 10066330 sec [fixed-point]
speed_fixp = 25169920 msec [fixed-point] = 3.750610 msec