How to convert float to custom encoding

Question

I am writing a program that creates ICC color formats. These formats define a data type called s15Fixed16Number, which has a signed bit, 15 integer bits, and 16 fractional bits. The 32-bit IEEE 754 floaters have a signed bit, 8 exponential bits, and 23 fractional bits.

I need to get input from a text field and convert them to s15Fixed16Number. Some searches have shown this in Google books, but it's about converting the decimal to s15Fixed16Number. I suppose I could just use the method described in the link, but I haven't done any testing yet to determine how accurate this is. I think I could also try converting the input of characters from a text box, but I have not thought about that yet.

I use Cocoa, but I do not think this is important; any C function should work. Here are some examples of values ​​in s15Fixed16Number format:

-32768.0 = 0x80000000 0 = 0x00000000 1.0 = 0x00010000 32767 + (65535/65536) = 0x7FFFFFFF 

I think it was some time after this numerical class of calculations!

Answer 1

Assuming your C environment is doing 2 integer additions, it's a lot easier than it sounds.

 typedef long s1516; // 32bit 2 complement signed integer s1516 floattos1516(double f) { return (s1516)(f * 65536. + 0.5); } 

A view is a fixed point value with 16 bits of a fraction. This is the same as a rational number whose denominator is always 65536 (or 2 ¹⁶ ). To form such a rational value from a floating point value, you simply multiply by the denominator. Then it is just a matter of suitable rounding and truncation of the integral type.

The standard chose the form they made because it only works if your system uses 2 additional integer arithmetic. Although it is true that the leftmost bit represents a sign, it is not a sign bit in the sense that is used in a floating point representation.

If your calculations are really a float , not a double , you will find that you do not have as much accuracy in your calculation as is available at a fixed point for numbers near full scale. If you calculate in double , then you will always have more accuracy in your calculation than in the result.

Edit:

Apparently, the latest specification is available from ICC as Specification ICC.1: 2004-10 (profile version 4.2.0.0) . Section 5.1.3:

5.1.3 s15Fixed16Number

A fixed signed 4-byte / 32-bit number that has 16 fractional bits, as shown in table 3.

  Table 3 - s15Fixed16Number
   Number encoding
 -32768.0 80000000h
      0 00000000h
      1.0 00010000h
  32767 + (65535/65536) 7FFFFFFFh

Besides the localized preference for the decimal point representation, these values ​​are fully consistent with my understanding that the representation is just a signed integer, which must be divided by 65536 to get their values.

The natural conversion to representation is simply multiplied by 65536, and it’s easy to separate from it. Choosing the right rounding rule is a matter of preference.

The full scale range is from -32768.0 (0x80000000) to approximately 32767.9999847412 (0x7fffffff) inclusive.

I agree that it would be clearer if the specification had a hexadecimal representation of any negative values. I shot the entire document, and the only values ​​I found in decimal and hexadecimal were the CIE XYZ color coordinates, which by definition range from 0 to 1 and therefore do not help as approximate negative values.

Answer 2

Do not get carried away with the internal representation of the float. The fixed point values ​​are integers with a constant scale factor. Just remember that you have more limited accuracy in floats than in your target format, so expected values ​​can be turned off in the lower 9 bits for larger values.

 //s15Fixed16Number is presumably typedef'ed to unsigned int float foo = 1.0f; int fooFixedSigned = (int)(foo * 65536); s15Fixed16Number fooFixed = (s15Fixed16Number)(abs(fooFixedSigned)); if (foo < 0) fooFixed = fooFixed | (1 << 31); //you'll also need to explicitly check for overflows and underflows and handle them however is appropriate to your situation 

Edit: fixed and |