Infinity
From Rosetta Code
Programming Task
This is a programming task. It lays out a problem which Rosetta Code users are encouraged to solve, using languages they know.
For languages with several floating point types, use the type of the literal constant 1.0 as floating point type.
Contents |
[edit] ActionScript
ActionScript has the built in function isFinite() to test if a number is finite or not.
trace(5 / 0); // outputs "Infinity"
trace(isFinite(5 / 0)); // outputs "false"
[edit] Ada
with Ada.Text_IO; use Ada.Text_IO;
procedure Infinities is
function Sup return Float is -- Only for predefined types
Result : Float := Float'Last;
begin
if not Float'Machine_Overflows then
Result := Float'Succ (Result);
end if;
return Result;
end Sup;
function Inf return Float is -- Only for predefined types
Result : Float := Float'First;
begin
if not Float'Machine_Overflows then
Result := Float'Pred (Result);
end if;
return Result;
end Inf;
begin
Put_Line ("Supremum" & Float'Image (Sup));
Put_Line ("Infimum " & Float'Image (Inf));
end Infinities;
The language-defined attribute Machine_Overflows is defined for each floating-point type. It is true when an overflow or divide-by-zero results in Constraint_Error exception propagation. When the underlying machine type is incapable to implement this semantics the attribute is false. It is to expect that on the machines with IEEE 754 hardware Machine_Overflows is true. The language-defined attributes Succ and Pred yield the value next or previous to the argument, correspondingly.
Sample output on a machine where Float is IEEE 754:
Supremum +Inf******* Infimum -Inf*******
Note that the code above does not work for user-defined types, which may have range of values narrower than one of the underlying hardware type. This case represents one of the reasons why Ada programmers are advised not to use predefined floating-point types. There is a danger that the implementation of might be IEEE 754, and so the program semantics could be broken.
Here is the code that should work for any type on any machine:
with Ada.Text_IO; use Ada.Text_IO;
procedure Infinities is
type Real is digits 5 range -10.0..10.0;
function Sup return Real is
Result : Real := Real'Last;
begin
return Real'Succ (Result);
exception
when Constraint_Error =>
return Result;
end Sup;
function Inf return Real is
Result : Real := Real'First;
begin
return Real'Pred (Result);
exception
when Constraint_Error =>
return Result;
end Inf;
begin
Put_Line ("Supremum" & Real'Image (Sup));
Put_Line ("Infimum " & Real'Image (Inf));
end Infinities;
Sample output. Note that the compiler is required to generate Constraint_Error even if the hardware is IEEE 754. So the upper and lower bounds are 10.0 and -10.0:
Supremum 1.0000E+01 Infimum -1.0000E+01
[edit] Getting rid of IEEE ideals
There is a simple way to strip IEEE 754 ideals (non-numeric values) from a predefined floating-point type such as Float or Long_Float:
subtype Safe_Float is Float range Float'Range;
The subtype Safe_Float keeps all the range of Float, yet behaves properly upon overflow, underflow and zero-divide.
[edit] ALGOL 68
ALGOL 68R (from Royal Radar Establishment) has an infinity variable as part of the standard prelude, on the ICL 1900 Series mainframes the value of infinity is 5.79860446188₁₀76 (the same as max float).
Note: The underlying hardware may sometimes support an infinity, but the ALGOL 68 standard itself does not, and gives no way of setting a variable to either ±∞.
ALGOL 68 does have some 7 built in exceptions, these might be used to detect exceptions during transput, and so if the underlying hardware does support ∞, then it would be detected with a on value error while printing and if mended would appear as a field full of error char.
printf(($"max int: "gl$,max int)); printf(($"long max int: "gl$,long max int)); printf(($"long long max int: "gl$,long long max int)); printf(($"max real: "gl$,max real)); printf(($"long max real: "gl$,long max real)); printf(($"long long max real: "gl$,long long max real)); printf(($"error char: "gl$,error char))ALGOL 68G-mk14.1 output:
max int: +2147483647 long max int: +99999999999999999999999999999999999 long long max int: +9999999999999999999999999999999999999999999999999999999999999999999999 max real: +1.79769313486235e+308 long max real: +1.000000000000000000000000e+999999 long long max real: +1.00000000000000000000000000000000000000000000000000000000000e+999999 error char: *
[edit] C
Works with: GCC
#include <stdlib.h>
#include <stdio.h>
double inf() {
return atof("infinity");
}
int main() {
printf("%f\n", inf()); /* outputs "inf" */
return 0;
}
C99 also has a macro for infinity:
#define _ISOC99_SOURCE
#include <math.h>
#include <stdio.h>
int main() {
printf("%f\n", INFINITY);
return 0;
}
[edit] 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();
}
[edit] C#
class Program {
static void Main(string[] args) {
double infinity = Double.PositiveInfinity;
}
}
[edit] D
typeof(1.0) inf()
{
return typeof(1.0).infinity;
}
[edit] E
def infinityTask() {
return Infinity # predefined variable holding positive infinity
}
[edit] Forth
: inf ( -- f ) 1e 0e f/ ; inf f. \ implementation specific. GNU Forth will output "inf" : inf? ( f -- ? ) s" MAX-FLOAT" environment? drop f> ; \ IEEE infinity is the only value for which this will return true : has-inf ( -- ? ) ['] inf catch if false else inf? then ;
[edit] Fortran
ISO Fortran 2003 or later supports an IEEE_ARITHMETIC module which defines a wide range of intrinsic functions and types in support of IEEE floating point formats and arithmetic rules.
program to_f_the_ineffable
use, intrinsic :: ieee_arithmetic
integer :: i
real dimension(2) :: y, x = (/ 30, ieee_value(y,ieee_positive_inf) /)
do i = 1, 2
if (ieee_support_datatype(x(i))) then
if (ieee_is_finite(x(i))) then
print *, 'x(',i,') is finite'
else
print *, 'x(',i,') is infinite'
end if
else
print *, 'x(',i,') is not in an IEEE-supported format'
end if
end do
end program to_f_the_ineffable
ISO Fortran 90 or later supports a HUGE intrinsic which returns the largest value supported by the data type of the number given.
real :: x real :: huge_real = huge(x)
[edit] Groovy
Groovy, like Java, requires full support for IEEE 32-bit (Float) and 64-bit (Double) formats. So the solution function would simply return either the Float or Double constant encoded as IEEE infinity.
def biggest = { Double.POSITIVE_INFINITY }
Test program:
println biggest()
printf ( "0x%xL \n", Double.doubleToLongBits(biggest()) )
Output:
Infinity 0x7ff0000000000000L
[edit] 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
Or you can simply use division by 0:
Prelude> 1 / 0 :: Float Infinity Prelude> 1 / 0 :: Double Infinity
Or use "read" to read the string representation:
Prelude> read "Infinity" :: Float Infinity Prelude> read "Infinity" :: Double Infinity
[edit] 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
[edit] J
Positive infinity is produced by the primary constant function _:
It is also represented directly as a numeric value by an underscore, used alone.
[edit] Io
inf := 1/0
[edit] Java
Java's floating-point types (float, double) all support infinity. You can get infinity from constants in the corresponding wrapper class; for example, Double:
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)*21023 or 1.7976931348623157*10308 (a.k.a. "big"). Other number classes (Integer, Long, Float, Byte, and Short) have maximum values that can be accessed in the same way.
[edit] JavaScript
JavaScript has a special global property called "Infinity":
Infinity
as well as constants in the Number class:
Number.POSITIVE_INFINITY
Number.NEGATIVE_INFINITY
The global isFinite() function tests for finiteness:
isFinite(x)
[edit] Mathematica
Mathematica has infinity built-in as a symbol. Which can be used throughout the software:
Sum[1/n^2,{n,Infinity}]
1/Infinity
Integrate[Exp[-x^2], {x, -Infinity, Infinity}]
10^100 < Infinity
gives back:
Pi^2/6 0 Sqrt[Pi] True
Moreover Mathematica has 2 other variables that represent 'infinity': DirectedInfinity[r] and ComplexInfinity. DirectInfinity[r] represents an infinite quantity with complex direction r. ComplexInfinity represents an infinite quantity with an undetermined direction; like 1/0. Which has infinite size but undetermined direction. So the general infinity is DirectedInfinity, however if the direction is unknown it will turn to ComplexInfinity, DirectedInfinity[-1] will return -infinity and DirectedInfinity[1] will return infinity. Directed infinity can, for example, be used to integrate over an infinite domain with a given complex direction: one might want to integrate Exp[-x^2]/(x^2-1) from 0 to DirectedInfinity[Exp[I Pi/4]]:
Integrate[Exp[-x^2]/(x^2 - 1), {x, 0, DirectedInfinity[Exp[I Pi/4]]}]
gives back:
-((Pi (I+Erfi[1]))/(2 E))
[edit] Metafont
Metafont numbers are a little bit odd (it uses fixed binary arithmetic). For Metafont, the biggest number (and so the one which is also considered to be infinity) is 4095.99998. In fact, in the basic set of macros for Metafont, we can read
infinity := 4095.99998;
[edit] Modula-3
IEEESpecial contains 3 variables defining negative infinity, positive infinity, and NaN for all 3 floating point types in Modula-3 (REAL, LONGREAL, and EXTENDED).
If the implementation doesn't support IEEE floats, the program prints arbitrary values (Critical Mass Modula-3 implementation does support IEEE floats).
MODULE Inf EXPORTS Main;
IMPORT IO, IEEESpecial;
BEGIN
IO.PutReal(IEEESpecial.RealPosInf);
IO.Put("\n");
END Inf.
Output:
Infinity
[edit] OCaml
infinity
is already a pre-defined value in OCaml.
# infinity;; - : float = infinity # 1.0 /. 0.0;; - : float = infinity
[edit] Perl
I'm don't know of the official way to get infinity. The following seems to work on my version of Perl:
1e600
Unfortunately, "1.0 / 0.0" doesn't evaluate to infinity; but throws an exception.
[edit] PHP
This is how you get infinity:
INF
Unfortunately, "1.0 / 0.0" doesn't evaluate to infinity; but instead seems to evaluate to False, which is more like 0 than infinity.
PHP has functions is_finite() and is_infinite() to test for infiniteness.
[edit] Python
This is how you get infinity:
>>> float('infinity')
inf
Note: When passing in a string to float(), values for NaN and Infinity may be returned, depending on the underlying C library. The specific set of strings accepted which cause these values to be returned depends entirely on the underlying C library used to compile Python itself, and is known to vary.
The Decimal module explicitly supports +/-infinity Nan, +/-0.0, etc without exception.
Floating-point division by 0 doesn't give you infinity, it raises an exception:
>>> 1.0 / 0.0 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: float division
[edit] Ruby
Infinity is a Float value
a = 1.0/0 # => Infinity
a.finite? # => false
a.infinite? # => 1
a = -1/0.0 # => -Infinity
a.infinite? # => -1
a = Float::MAX # => 1.79769313486232e+308
a.finite? # => true
a.infinite? # => nil
[edit] Slate
PositiveInfinity
[edit] Standard ML
Real.posInf
- Real.posInf; val it = inf : real - 1.0 / 0.0; val it = inf : real
[edit] Tcl
Works with: Tcl version 8.5
Tcl 8.5 has Infinite as a floating point value, not an integer value
package require Tcl 8.5
expr {1.0 / 0} ;# ==> Inf
expr {-1.0 / 0} ;# ==> -Inf
expr {inf} ;# ==> Inf
expr {1 / 0} ;# ==> "divide by zero" error; Inf not part of range of integer division
A maximal integer is not easy to find, as Tcl switches to unbounded integers when a 64-bit integer is about to roll over:
% format %lx -1 ;# all bits set
ffffffffffffffff
% regsub f 0x[format %lx -1] 7 ;# unset the sign bit for positive
0x7fffffffffffffff
% set ii [expr [regsub f 0x[format %lx -1] 7]] ;# show as decimal
9223372036854775807
% incr ii
9223372036854775808 ;# silently upgrade to unbounded integer, still positive
A theoretical MAXINT, though very impractical, could be
string repeat 9 [expr 2**32-1]
[edit] Ursala
IEEE double precision floating point numbers are a primitive type in Ursala. This function returns IEEE double precision infinity when applied to any argument, using the value inf, which is declared as a constant in the flo library.
#import flo infinity = inf!
