Infinity: Difference between revisions

 

 

 

=={{header|ActionScript}}==

ActionScript has the built in function isFinite() to test if a number is finite or not.

 

=={{header|Ada}}==

 

procedure Infinities is

Put_Line ("Supremum" & Float'Image (Sup));

Put_Line ("Infimum " & Float'Image (Inf));

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.

 

 

Here is the code that should work for any type on any machine:

 

procedure Infinities is

Put_Line ("Supremum" & Real'Image (Sup));

Put_Line ("Infimum " & Real'Image (Inf));

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:

<pre>

===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:

The subtype Safe_Float keeps all the range of Float, yet behaves properly upon overflow, underflow and zero-divide.

 

ALGOL 68 does have some 7 built in [[Exceptions#ALGOL_68|exceptions]], these might be used to detect exceptions during transput, and so <u>if</u> the underlying hardware <u>does</u> support &infin;, 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(($"long max int: "gl$,long max int));

printf(($"long long max int: "gl$,long long max int));

printf(($"long max real: "gl$,long max real));

printf(($"long long max real: "gl$,long long max real));

Output:

<pre>

error char: *

</pre>

 

=={{header|Argile}}==

{{trans|C}} (simplified)

printf "%f\n" atof "infinity" (: this prints "inf" :)

 

 

k=1;

while (2^(k-1) < 2^k) k++;

INF = 2^k;

print INF;

 

This has been tested with GAWK 3.1.7 and MAWK, both return

<pre> inf </pre>

 

=={{header|C}}==

C89 has a macro HUGE_VAL in <math.h>. HUGE_VAL is a <tt>double</tt>. HUGE_VAL will be infinity if infinity exists, else it will be the largest possible number. HUGE_VAL is a <tt>double</tt>.

 

#include <stdio.h> /* printf() */

 

printf("%g\n", inf());

return 0;

 

The output from the above program might be "inf", "1.#INF", or something else.

C99 also has a macro for infinity:

 

 

#include <math.h>

printf("%g\n", INFINITY);

return 0;

 

=={{header|C sharp|C#}}==

 

class Program

Console.WriteLine(PositiveInfinity());

}

Output:

=={{header|C++}}==

 

 

double inf()

else

return std::numeric_limits<double>::max();

=={{header|Clojure}}==

{{trans|Java}}

 

 

=={{header|CoffeeScript}}==

 

JavaScript has a special global property called "Infinity":

as well as constants in the Number class:

 

The global isFinite function tests for finiteness:

 

=={{header|Common Lisp}}==

{{works with|LispWorks}} 5.1.2, Intel, OS X, 32-bit

 

MOST-POSITIVE-LONG-FLOAT, value: 1.7976931348623158D308

MOST-POSITIVE-SHORT-FLOAT, value: 3.4028172S38

MOST-NEGATIVE-SHORT-FLOAT, value: -3.4028172S38

MOST-NEGATIVE-DOUBLE-FLOAT, value: -1.7976931348623158D308

 

=={{header|D}}==

 

return typeof(1.5).infinity;

}

 

 

=={{header|Delphi}}==

 

Delphi defines the following constants in Math:

Test for infinite value using:

 

=={{header|E}}==

 

return Infinity # predefined variable holding positive infinity

 

=={{header|Eiffel}}==

class

APPLICATION

end

end

 

Output:

True

</pre>

 

=={{header|Euphoria}}==

 

 

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

Fantom's <code>Float</code> data type is an IEEE 754 64-bit floating point type. Positive infinity is represented by the constant <code>posInf</code>.

 

class Main

{

public static Void main () { echo (getInfinity ()) }

}

 

=={{header|Forth}}==

inf f. \ implementation specific. GNU Forth will output "inf"

 

\ IEEE infinity is the only value for which this will return true

 

 

=={{header|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.

use, intrinsic :: ieee_arithmetic

integer :: i

end if

end do

 

ISO Fortran 90 or later supports a HUGE intrinsic which returns the largest value supported by the data type of the number given.

 

=={{header|GAP}}==

inf := FLOAT_INT(1) / FLOAT_INT(0);

 

# GAP has also a formal ''infinity'' value

infinity in Cyclotomics;

 

=={{header|Go}}==

 

import (

x = posInf() // test function

fmt.Println(x, math.IsInf(x, 1)) // demonstrate result

Output:

<pre>

=={{header|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.

 

Test program:

 

Output:

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

 

maxRealFloat x = encodeFloat b (e-1) `asTypeOf` x where

b = floatRadix x - 1

infinity :: RealFloat a => a

infinity = if isInfinite inf then inf else maxRealFloat 1.0 where

 

Test for the two standard floating point types:

 

Infinity

*Main> infinity :: Double

 

Or you can simply use division by 0:

Infinity

Prelude> 1 / 0 :: Double

 

Or use "read" to read the string representation:

Infinity

Prelude> read "Infinity" :: Double

 

=={{header|Icon}} and {{header|Unicon}}==

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

 

 

=={{header|Io}}==

 

or

 

 

=={{header|J}}==

 

Example:

_ * 5 NB. multiplying infinity to 5 results in infinity

_

5 % 0 NB. dividing 5 by 0 results in infinity

_

 

=={{header|Java}}==

Java's floating-point types (<tt>float</tt>, <tt>double</tt>) all support infinity. You can get infinity from constants in the corresponding wrapper class; for example, <tt>Double</tt>:

As a function:

return Double.POSITIVE_INFINITY;

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

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

 

=={{header|JavaScript}}==

JavaScript has a special global property called "Infinity":

as well as constants in the Number class:

 

The global isFinite() function tests for finiteness:

 

=={{header|K}}==

K has predefined positive and negative integer and float infinities: -0I, 0I, -0i, 0i. They have following properties:

{{works with|Kona}}

/ 0I is just 2147483647

/ -0I is just -2147483647

/ but

0.0%0.0

 

Mathematica has infinity built-in as a symbol. Which can be used throughout the software:

1/Infinity

Integrate[Exp[-x^2], {x, -Infinity, Infinity}]

gives back:

<pre>Pi^2/6

True</pre>

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]]:

gives back:

<pre>-((Pi (I+Erfi[1]))/(2 E))</pre>

MATLAB implements the IEEE 754 floating point standard as the default for all numeric data types. +Inf and -Inf are by default implemented and supported by MATLAB. To check if a variable has the value +/-Inf, one can use the built-in function "isinf()" which will return a Boolean 1 if the number is +/-inf.

 

isinf(a)

 

Returns:

 

=={{header|Maxima}}==

 

declare(x, real)$

1.0/0.0;

/* expt: undefined: 0 to a negative exponent.

 

=={{header|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

 

 

=={{header|Modula-2}}==

 

IMPORT InOut;

InOut.WriteReal (1.0 / 0.0, 12, 12);

InOut.WriteLn

Producing

 

**** RUNTIME ERROR bound check error

 

=={{header|Modula-3}}==

 

If the implementation doesn't support IEEE floats, the program prints arbitrary values (Critical Mass Modula-3 implementation does support IEEE floats).

 

IMPORT IO, IEEESpecial;

IO.PutReal(IEEESpecial.RealPosInf);

IO.Put("\n");

 

Output:

=={{header|Nemerle}}==

Both single and double precision floating point numbers support PositiveInfinity, NegativeInfinity and NaN.

def a = IsInfinity(posinf); // a = true

def b = IsNegativeInfinity(posinf); // b = false

 

=={{header|OCaml}}==

is already a pre-defined value in OCaml.

 

- : float = infinity

</pre>

 

=={{header|OpenEdge/Progress}}==

The unknown value (represented by a question mark) can be considered to equal infinity. There is no difference between positive and negative infinity but the unknown value sometimes sorts low and sometimes sorts high when used in queries.

 

1.0 / 0.0 SKIP

-1.0 / 0.0 SKIP(1)

( 1.0 / 0.0 ) = ( -1.0 / 0.0 )

 

Output

=={{header|OxygenBasic}}==

Using double precision floats:

print 1.5e-400 '0

 

 

print f '#-INF

 

=={{header|Oz}}==

PosInf = 1./0.

NegInf = ~1./0.

PosInf * PosInf = PosInf

PosInf * NegInf = NegInf

 

=={{header|PARI/GP}}==

[1] \\ Used for many functions like intnum

 

=={{header|Pascal}}==

=={{header|Perl}}==

Positive infinity:

Negative infinity:

The "<code>0 + </code>..." is used here to make sure that the variable stores a value that is actually an infinitive number instead of just a string <code>"inf"</code> but in practice one can use just:

and <code>$x</code> while originally holding a string will get converted to an infinite number when it is first used as a number.

 

Some programmers use expressions that overflow the IEEE floating point numbers such as:

which is 10¹⁰⁰⁰ or googol¹⁰ or even numbers like this one:

which is 10^10000000000 but it has to make some assumptions about the underlying hardware format and its size. Furthermore, using such literals in the scope of some pragmas such as <code>bigint</code>, <code>bignum</code> or <code>bigrat</code> would actually compute those numbers:

 

my $x = 1e1000;

Here the <code>$x</code> and <code>$y</code> when printed would give 1001 and 10000000001-digit numbers respectively, the latter taking no less than 10GB of space to just output.

 

Under those pragmas, however, there is a simpler way to use infinite values, thanks to the <code>inf</code> symbol being exported into the namespace by default:

my $x = inf;

 

 

=={{header|PHP}}==

This is how you get infinity:

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.

 

=={{header|PicoLisp}}==

support (scaled bignum arithmetics), but some functions return 'T' for infinite

results.

 

: (exp 1000.0)

 

=={{header|PostScript}}==

 

=={{header|PowerShell}}==

[double]::PositiveInfinity

 

=={{header|PureBasic}}==

 

 

 

''Outputs''

+Infinity

-Infinity

 

=={{header|Python}}==

This is how you get infinity:

''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.'' <br>

''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:

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

 

If <tt>float('infinity')</tt> doesn't work on your platform, you could use this trick:

1.#INF</pre>

It works by trying to create a float bigger than the machine can handle.

 

=={{header|R}}==

-Inf #negative infinity

.Machine$double.xmax # largest finite floating-point number

forcefinite(c(1, -1, 0, .Machine$double.xmax, -.Machine$double.xmax, Inf, -Inf))

# [1] 1.000000e+00 -1.000000e+00 0.000000e+00 1.797693e+308

 

 

 

For the default setting of

 

.999999999e+999999999

</pre>

For a setting of

 

... and so on with larger NUMERIC DIGITS

</pre>

<br>but the pratical limit would be a little less than half of available virtual storage,

 

=={{header|Ruby}}==

Infinity is a Float value

a.finite? # => false

a.infinite? # => 1

a = Float::MAX # => 1.79769313486232e+308

a.finite? # => true

{{works with|Ruby|1.9.2+}}

 

=={{header|Scala}}==

res2: Double = Infinity

 

 

scala> 1 / Double.NegativeInfinity

 

=={{header|Scheme}}==

(define (finite? x) (< -inf.0 x +inf.0))

 

=={{header|Seed7}}==

The library [http://seed7.sourceforge.net/libraries/float.htm float.s7i] defines

the constant [http://seed7.sourceforge.net/libraries/float.htm#Infinity Infinity] as:

Checks for infinity can be done by comparing with this constant.

 

=={{header|Slate}}==

 

 

=={{header|Smalltalk}}==

Inf

</pre>

 

=={{header|Standard ML}}==

 

<pre>

val it = inf : real

</pre>

 

=={{header|Tcl}}==

 

Tcl 8.5 has Infinite as a floating point value, not an integer value

 

expr {1.0 / 0} ;# ==> Inf

expr {-1.0 / 0} ;# ==> -Inf

expr {inf} ;# ==> Inf

 

A maximal integer is not easy to find, as Tcl switches to unbounded integers when a 64-bit integer is about to roll over:

ffffffffffffffff

 

 

% incr ii

A theoretical MAXINT, though very impractical, could be

string repeat 9 [expr 2**32-1]

=={{header|TI-89 BASIC}}==

 

 

=={{header|TorqueScript}}==

{

return 1/0;

 

=={{header|Trith}}==

The following functions are included as part of the core operators:

: inf 1.0 0.0 / ;

: -inf inf neg ;

: inf? abs inf = ;

 

=={{header|Ursala}}==

 

 

 

 

=={{header|Visual Basic}}==

{{works with|Visual Basic|6}}

 

 

 

{{omit from|bc|No infinity. Numbers have unlimited precision, so no largest possible value.}}

{{omit from|Brainf***}}

{{omit from|dc|No infinity. Numbers have unlimited precision, so no largest possible value.}}

{{omit from|Integer BASIC}}

{{omit from|VBScript}}

{{omit from|UNIX Shell}}

[[Category:Irrational numbers]]