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.

 

=={{header|ALGOL 68}}==

 

 

 

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));

long max int: +99999999999999999999999999999999999

long long max int: +9999999999999999999999999999999999999999999999999999999999999999999999

long max real: +1.000000000000000000000000e+999999

long long max real: +1.00000000000000000000000000000000000000000000000000000000000e+999999

 

=={{header|Argile}}==

{{trans|C}} (simplified)

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

 

=={{header|C}}==

 

}

 

int main() {

return 0;

 

C99 also has a macro for infinity:

 

#include <math.h>

 

int main() {

return 0;

 

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

 

 

double inf()

else

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

 

 

 

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

 

 

=={{header|E}}==

 

return Infinity # predefined variable holding positive infinity

 

=={{header|Factor}}==

 

=={{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|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|IDL}}==

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|Lua}}==

function infinity()

return 1/0 --lua uses unboxed C floats for all numbers

end

 

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:

0

Sqrt[Pi]

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:

 

 

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

<pre>

Infinity

</pre>

 

=={{header|OCaml}}==

is already a pre-defined value in OCaml.

 

- : float = infinity

</pre>

 

=={{header|Oz}}==

PosInf = 1./0.

NegInf = ~1./0.

PosInf * PosInf = PosInf

PosInf * NegInf = NegInf

 

=={{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|PL/I}}==

declare x float, y float (15), z float (18);

 

put skip list (huge(x), huge(y), huge(z));

 

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

 

=={{header|Ruby}}==

Infinity is a Float value

a.finite? # => false

a.infinite? # => 1

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

a.finite? # => true

 

=={{header|Scala}}==

 

 

 

 

 

=={{header|Seed7}}==

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

 

=={{header|Slate}}==

 

 

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

 

 

<pre>

</pre>