Re: Numerical calculations: Why not use fixed point types for everything?

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

On 13-02-04 12:09 , Ada novice wrote:
> On Monday, February 4, 2013 10:37:49 AM UTC+1, Niklas Holsti wrote:
>> 
>>    Number : constant Long_Float := 100.0;
> 
> When assigning constants, I always use
> 
>    Number : constant := 100.0
> 
> and then lets the compiler decides how it wants to treat the constant
> when say multiplying with a type such as integer,

(You can't multiply 100.0 with an integer, unless you do a type
conversion or define your own multiplication operator.)

> float etc. Is this good practice?

Depends. Such type-less "named numbers" (in Ada-speak) have different
properties than typed constant objects: if you combine them in an
expression, the compiler uses unbounded-precision and unbounded-range
arithmetic, which may or may not be what you want; and they match any
integer or floating-point type, respectively, which again may or may not
be what you want. In other words, if you declare:

   Max_Number_Of_Apples : constant := 42;

you may mistakenly use Max_Number_Of_Apples in a place where you are
counting oranges. But if you define different types, Apple_Count_Type
and Orange_Count_Type, and then declare

   Max_Number_Of_Apples : constant Apple_Count_Type := 42;

then the compiler should detect if this constant is used in an
orange-counting context.

I use named numbers (usually integers) when I want to be absolutely sure
that all computation with them is done statically, at compile-time, or
when I want to give other parts of the program the ability to use the
same numbers with various types (which is not often sensible). Nowadays
I mostly use typed constant objects.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .