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

["Randy Brukardt" <randy@rrsoftware.com>]

"Ada novice" <shai.lesh@gmx.com> wrote in message 
news:c81e7d23-8757-4a81-9ca2-d540afe0d819@googlegroups.com...
On Saturday, February 2, 2013 10:08:50 PM UTC+1, Nasser M. Abbasi wrote:

>>
>> Well, it is common only in sloppy programming.
>>
>>
>>
>> loop counters should always be discrete. as in integers,

>I do not think we should judge things too quickly.

I tend to agree with you in general, but your example seems to demostrate 
the OPs point...

>By having a "delta" that we can explicitly specify, this can make the code 
>simpler to understand. Look at this code:
>
>with Ada.Text_IO;             use Ada.Text_IO;
>with Ada.Long_Float_Text_IO;  use Ada.Long_Float_Text_IO;
>
>procedure Step_Freq is
>   Count : Integer;
>   Frequency : Long_Float;
>   Frequency_Start : constant := -44.88;
>   Frequency_Step  : constant := (67.32 - Frequency_Start) / 299.0;

This 299 seems related to the one in the loop below. As such, I think it 
should have a named constant:
    Steps : constant := 300;
   Frequency_Step  : constant := (67.32 - Frequency_Start) / (Steps-1);
[Aside: This is legal even though the denominator is integer because of the 
extra operators defined in 4.5.5(17). And examples like this is why.]

>   Delta_Frequency : Long_Float;
>
> begin
>   Count := 0;
>   Frequency := Frequency_Start;
>   for I in 1..300 loop
     for I in 0 .. Step-1 loop
         -- This avoids the odd "-1" in the loop below. If you had directly 
used I somewhere
         -- else, this might not work, but it does in this example.
>       Frequency := Frequency_Start + Frequency_Step * Long_Float (I - 1);
       Frequency := Frequency_Start + Frequency_Step * Long_Float (I);
>       if I = 2 then
      if I = 1 then
>          Delta_Frequency := abs(Frequency - Frequency_Start);
>          Put (Item => Delta_Frequency, Fore => 3, Aft => 5, Exp => 0); 
> Put("  ");
>          Put (Item => Frequency_Step, Fore => 3, Aft => 5, Exp => 0);
>          New_Line;
>       end if;
>       Count := Count + 1;
    --?? Besides the fact that this isn't even used in the loop, it has the 
same value as I
    -- (or I-1 in the original code). Why duplicate the value? One the huge 
benefits of
    -- Ada is that you don't have to start every range at 0 or 1 - do 
whatever your
    -- program needs.
>   end loop;
>    Put_Line ("Count after loop is" & Integer'Image (Count));
    -- Unless your program is *really* buggy, this is just the constant 
Step.
>    New_Line;
>    Put (Item => Frequency, Fore => 3, Aft => 3, Exp => 0);
>end Step_Freq;
>
>Well, I am using a discrete loop counter. But is this the best way to go 
>about for such
>a simple example? What if I want the Frequency_Step to take a specific 
>value? Then
>I will have perhaps to play with the range and the amount of discrete 
>points I need in
>order to arrive at a desired Frequency_Step in the code.

Nah, all you need to do is make the Step value calculated from the 
Frequency_Step, rather than the reverse.

>So why not use fixed-point for the frequency as we know exactly what step 
>we want?

The main reason is that you almost always need to get your data from an 
array somewhere, and you use the for loop parameter ("I" in this case) to 
get the values from the array, and then use the float version of the step 
for the calculation. With the exception of benchmarks, I don't think I've 
ever written a loop that does exactly the same thing 300 times without 
changing the input data. (When such things appear to happen, usually you can 
refactor the expression to avoid the loop altogether, which is usually 300 
times faster.)

                                                             Randy.