Infinity

Infinity
You are encouraged to solve this task according to the task description, using any language you may know.

Write a function which tests if infinity is supported for floating point numbers (this step should be omitted for languages where the language specification already demands the existence of infinity, e.g. by demanding IEEE numbers), and if so, returns positive infinity. Otherwise, return the largest possible number.

For languages with several floating point types, use the type of the literal constant 1.0 as floating point type.

Ada

Works with: GNAT version GPL 2007

with Ada.Text_Io; use Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;

procedure Infinities is
   F : Float := Float'Last;
   I : Float := F * 10.0; 
   Ff : Float := Float'First;
   II : Float := FF * 10.0;  
begin
   Put(Item => F);
   New_Line;
   Put(Item => I);
   New_Line;
   Put(Item => Ff);
   New_Line;
   Put(Item => Ii);
end Infinities;

Output:

 3.40282E+38
+Inf********
-3.40282E+38
-Inf********

C++

#include <limits>

double inf()
{
  if (std::numeric_limits<double>::has_infinity)
    return std::numeric_limits<double>::infinity();
  else
    return std::numeric_limits<double>::max();
}

Haskell

The Haskell 98 standard does not require full IEEE numbers, and the required operations on floating point numbers leave some degree of freedom to the implementation. Also, it's not possible to use the type of the literal 1.0 to decide which concrete type to use, because Haskell number literals are automatically converted.

Nevertheless, the following may come close to the task description:

maxRealFloat :: RealFloat a => a -> a
maxRealFloat x = encodeFloat b (e-1) `asTypeOf` x where
  b     = floatRadix x - 1
  (_,e) = floatRange x

infinity :: RealFloat a => a
infinity = if isInfinite inf then inf else maxRealFloat 1.0 where
  inf = 1/0 

Test for the two standard floating point types:

*Main> infinity :: Float
Infinity
*Main> infinity :: Double
Infinity

IDL

IDL provides the standard IEEE values for _inf and _NaN in the !Values system structure:

print, !Values.f_infinity             ;; for normal floats or
print, !Values.D_infinity             ;; for doubles  

J

Positive infinity is produced by the primary constant function _:
It is also represented directly as a numeric value by an underscore, used alone.

Java

Java does not have a test for the existence of infinity, but it does have the concept in the Double class.

double infinity = Double.POSITIVE_INFINITY; //defined as 1.0/0.0
Double.isInfinite(infinity); //true

As a function:

public static double getInf(){
   return Double.POSITIVE_INFINITY;
}

The largest possible number in Java (without using the Big classes) is also in the Double class.

double biggestNumber = Double.MAX_VALUE;

Its value is (2-2^-52)*2¹⁰²³ or 1.7976931348623157*10³⁰⁸ (a.k.a. "big"). Other number classes (Integer, Long, Float, Byte, and Short) have maximum values that can be accessed in the same way.