[Fsf-friends] [OT]Doing arithmetic with computers

[Ramanraj K]

On 6/8/05, Anand Babu <ab@gnu.org.in> wrote:
> ,----[ Ramanraj K <ramanraj.k@gmail.com> ]
> | While doing arithmetic, how is infinity represented on a computer?
> `----
> Most modern computers support the IEEE floating point standard, which
> provides for positive infinity and negative infinity as floating
> point values. It also provides for a class of values called NaN or
> "not-a-number"; numerical functions return such values in cases where
> there is no correct answer.

Thanks for the information.  The current IEEE standard appears to be
implemented in PHP and python too.

PHP users could try this:
<?php
$inf = 1.8e300;
do {
    $inf = $inf * 10;   
    echo "<p>$inf</p>";    
   } while (is_finite($inf));  # stops when $inf exceeds 1.8e307
?>
There is an is_infinite function also.

The standard provides for +$B!g(B and -$B!g(B but overlooks the overflow at the
point of transition to the next whole number.  The overflow there
should be explicitly represented.

To avoid any confusion in this discussion, a few practical uses of
these representations:

First, why infinity should be represented as integers.  Take the
question:  On how many computers can a user install and run free
software licensed under the GPL?

Answer: On an unlimited number of computers.

ie: $gnu_computers = infinite

Infinity should therefore be supported not only in floats, but also
integers. Practically, we may do very little arithmetic with the
infinity values themselves.  Now, on how many computers can we install
software licensed under the FreeBSD license? The answer again may be
written as $bsd_computers = infinite.  But, it makes no sense to add
this infinity with the previous one.  The question, on how many
computers a user has actually installed free software is very
different, and the answer would always be finite and countable.   Much
useful arithmetic could be done with such data, and we may never
accept infinity as an answer here, and we would like to see a clear
figure no matter how large or how difficult it is for programmers to
represent it.

Secondly, the IEEE standard representing inf should be made more
useful.  As Dr. Sasi Kumar pointed out earlier, there are an infinite
number of rational numbers between two integers, and floats on
machines cannot represent all the values in between.  It would be more
useful to return INF at the point where the machine cannot represent a
required float value.  For example, we may list the steps in a
procedure as follows:
1.1 - Step 1
1.2 - Step 2
If a new step is to be inserted between Steps 1 and 2, it could be
inserted as Step 1.1 and the float representing it could be (1.1 +
1.2)/2 = 1.15
The new list of steps would be:
1.1 - Step 1
1.15 - Step 1.1
1.2 - Step 2

 The float values help to sort the list when required.  Though it is a
bad idea to keep inserting new steps infinitely this way in the real
world, in theory, this should be possible. But, there would be a point
when the machine is unable to generate a float for inserting a new
step where it would give a value after "rounding off" that is not
between 1 and 2, which would defeat the purpose and design.  It would
be better if INF is returned instead of rounding off at this point, so
that we may trap the overflow and handle it appropriately.


>    Positive infinity
>      `.0e+INF'
>    Negative infinity
>      `.0e+NaN'.
>    Not-a-number
>      `.0e+NaN'.
> 
> Under GNU Guile (Scheme)
>    (define +Inf (/ 1.0 0.0))
>    (define -Inf (- +Inf))
>    (define NaN (/ 0.0 0.0))
> 
>    guile> +Inf
>    +#.#
>    guile> -Inf
>    -#.#
>    guile> NaN
>    #.#
> 
> Under GNU Emacs (elisp)
>    (setq +Inf (/ 1.0 0.0))
>    => 1.0e+INF
>    (setq -Inf (- +Inf))
>    => -1.0e+INF
>    (setq NaN (/ 0.0 0.0))
>    => -0.0e+NaN
> 
> Under GCC (C)
>    #include <stdio.h>
>    int
>    main ()
>    {
>      float p_inf=1e30000; /* causes overflow and sets to infinity */
>      float n_inf=-p_inf;
>      float nan = p_inf/p_inf;
>      printf ("%f %f %f\n", p_inf, n_inf, nan);
> 
>      return (0);
>    }
>    => inf -inf nan
> 
> And now you can do arithmetic using these symbols.

and with recursion :)