Re: How unchecked conversion works?

[Mark H Johnson <mark_h_johnson@raytheon.com>]

None wrote:

> well, I try to explain. I have those types for example
> 
> type fixed is delta 0.03 range -90.0..90.0
> for fixed'size use 16
> 
> and
> 
> type inte is range -32768..32767
> for inte'size use 16
> 
> 
> and a new function that renames unchecked_conversion to come from fixed 
> to inte (probably an inefficient way, but I have to do this way), so I'd 
> like to predict on paper which value of inte type corresponds to 89.09 
> for example: what kind of calculus should I do? This depends on 
> something else? Thanks again!

The specific answer will likely be compiler specific so you may need to 
write a test application to verify the result. Let me see if I can 
explain why...

One choice - the compiler chooses to represent value as 1 == your delta 
value (0.03) and scale everything appropriately. Then 90.0 is 
represented by 3000 (decimal) since
   3000 * 0.03 == 90.0
So you have a range of values +/- 3000 when you do the unchecked 
conversion. Pretty straight forward implementation for your problem.

Another choice - the compiler chooses to make 'Small of your datatype 
not equal to 'Delta of your data type (this IS allowed in ARM 3.5.9). 
Since you did not request a decimal fixed point value, 'Small will be a 
power of two smaller than 'Delta. If my arithmetic is correct, that 
could be something like 1/64 (0.015625) or even smaller (e.g., 1/256). 
In this case, the value could be mapped as follows:
  Siiiiiiiffffffff
where S is  the sign bit, iiiiiii is the 7 bit integer value and 
ffffffff is the 8 bit fraction. I assume you can do the appropriate 
arithmetic to interpret this form of fixed point value.

To some extent this gets back to how fixed point values were represented 
"long ago". You could either represent them as:
  - values right adjusted into a register / storage location
OR
  - values left adjusted into a register / storage location
Each method has definite advantages and disadvantages when doing 
arithmetic - especially when considering multiplication and division. 
Both methods were used in the past and the Ada reference manual 
basically allows either to be used in this case.

Your compiler should define this "implementation detail" in sufficient 
detail to figure out which method is used. Note however, that whatever 
code you use to process this will NOT be very portable between Ada 
compilers and target systems.

   --Mark