Infinity: Difference between revisions

=={{header|11l}}==

{{out}}

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

that support infinity, this will be infinity. Otherwise, it will be some large, but finite value.

{{out}}

=={{header|Argile}}==

{{trans|C}} (simplified)

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

=={{header|Arturo}}==

{{out}}

=={{header|AWK}}==

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

=={{header|BASIC256}}==

infinity = 1e300*1e300

end

TratoError:

if lasterror = 29 then print lasterrormessage

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PRINT FNinfinity

END

RESTORE ERROR

UNTIL maxpos = prev

Output:

<pre>

=={{header|bootBASIC}}==

The code below can't print anything on the screen, plus the program won't end. No way is currently known to break out of the program.

=={{header|BQN}}==

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

Java's floating-point types (float, double) all support infinity. Clojure has literals for infinity:

##-Inf ;; same as Double/NEGATIVE_INFINITY

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

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|Component Pascal}}==

BlackBox Component Builder

MODULE Infinity;

IMPORT StdLog;

END Do;

Execute: ^Q Infinity.Do<br/>

Output:

=={{header|D}}==

return typeof(1.5).infinity;

}

=={{header|Delphi}}==

Delphi defines the following constants in Math:

Test for infinite value using:

=={{header|Dyalect}}==

Dyalect floating point number support positive infinity:

=={{header|E}}==

return Infinity # predefined variable holding positive infinity

=={{header|Eiffel}}==

class

APPLICATION

end

end

Output:

floating and MAXLONGREAL for double precision floating. An infinity test can be achieved with

an EXCEPTION:

PROGRAM INFINITY

END WHILE

END PROGRAM

=={{header|Euphoria}}==

=={{header|F_Sharp|F#}}==

printfn "%f" (1.0/0.0)

{{out}}

<pre>

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

#Include "crt/math.bi"

Print d; " (String representation of Positive Infinity)"

Sleep

{{out}}

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

Output:

<pre>

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

jq uses IEEE 754 64-bit floating-point arithmetic, and very large number literals, e.g. 1e1000, are evaluated as IEEE 754 infinity. If your version of jq does not include `infinite` as a built-in, you could therefore define it as follows:

To test whether a JSON entity is equal to `infinite`, one can simply use `==` in the expected manner. Thus, assuming `infinite` has been defined, one could define a predicate, isinfinite, as follows:

Currently, the infinite value prints as though it were a very large floating point number.

Julia uses IEEE floating-point arithmetic and includes a built-in constant `Inf` for (64-bit) floating-point infinity. Inf32 can be used as 32-bit infinity, when avoiding type promotions to Int64.

julia> julia> Inf32 == Inf64 == Inf16 == Inf

true

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

=={{header|Klingphix}}==

=={{header|Kotlin}}==

val p = Double.POSITIVE_INFINITY // +∞

println(p.isInfinite()) // true

println(n.isFinite()) // false

println("${n < 0} ${n > 0}") // true false

{{out}}

<pre>true

=={{header|Lambdatalk}}==

Lambdatalk is built on Javascript and can inherit lots of its capabilities. For instance:

{/ 1 0}

-> Infinity

{< {pow 10 1000} Infinity}

-> false

=={{header|Lasso}}==

Lasso supports 64-bit decimals.. This gives Lasso's decimal numbers a range from approximately negative to positive 2x10^300 and with precision down to 2x10^-300. Lasso also supports decimal literals for NaN (not a number) as well and positive and negative infinity.

'<br />'

-> inf

Lingo stores floats using IEEE 754 double-precision (64-bit) format.

INF is not a constant that can be used programmatically, but only a special return value.

put ilk(x), x

-- #float 1.79769313486232e308

x = (1-power(2, -53)) * power(2, 1023) * 3

put ilk(x), x, -x

=={{header|Lua}}==

function infinity()

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

end

=={{header|M2000 Interpreter}}==

Rem : locale 1033

Module CheckIt {

}

Checkit

=={{header|Maple}}==

Maple's floating point numerics are a strict extension of IEEE/754 and IEEE/854 so there is already a built-in infinity. (In fact, there are several.) The following procedure just returns the floating point (positive) infinity directly.

> proc() Float(infinity) end();

Float(infinity)

There is also an exact infinity ("infinity"), a negative float infinity ("Float(-infinity)" or "-Float(infinity)") and a suite of complex infinities. The next procedure returns a boxed machine (double precision) float infinity.

> proc() HFloat(infinity) end();

HFloat(infinity)

=={{header|Mathematica}} / {{header|Wolfram Language}}==

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

MiniScript uses IEEE numerics, so:

{{out}}

<pre>INF</pre>

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

is a predefined constant in Nim:

=={{header|NS-HUBASIC}}==

{{out}}

?DZ ERROR is a division by zero error in NS-HUBASIC.

=={{header|OCaml}}==

is already a pre-defined value in OCaml.

=={{header|Oforth}}==

{{out}}

-inf.0 ; negative infinity

(define (infinite? x) (or (equal? x +inf.0) (equal? x -inf.0)))

(infinite? 1/3456) ==> #false

(infinite? 17+28i) ==> #false

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

{{works with|PARI/GP|version 2.8.0 and higher}}

{{works with|PARI/GP|version 2.2.9 to 2.7.0}}

[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|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">infinity</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1e300</span><span style="color: #0000FF;">*</span><span style="color: #000000;">1e300</span>

<span style="color: #0000FF;">?</span> <span style="color: #000000;">infinity</span>

{{out}}

desktop/Phix:

=={{header|Phixmonti}}==

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

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

results.

: (exp 1000.0)

=={{header|PL/I}}==

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

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

=={{header|PostScript}}==

=={{header|PowerShell}}==

A .NET floating-point number representing infinity is available.

[double]::PositiveInfinity

=={{header|PureBasic}}==

PureBasic uses [[wp:IEEE_754-2008|IEEE 754]] coding for float types. PureBasic also includes the function <tt>Infinity()</tt> that return the positive value for infinity and the boolean function <tt>IsInfinite(value.f)</tt> that returns true if the floating point value is either positive or negative infinity.

Define.d a, b

b = 0

CloseConsole()

EndIf

''Outputs''

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

=={{header|QB64}}==

//save as inf.h

double inf(void){

return HUGE_VAL;

Function inf#

End Declare

=={{header|QBasic}}==

{{works with|QBasic|1.1}}

ON ERROR GOTO TratoError

FUNCTION f!

f! = -1.5 / 0

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

as in Scheme:

+inf.0 ; positive infinity

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

=={{header|Raku}}==

(formerly Perl 6)

Inf support is required by language spec on all abstract Numeric types (in the absence of subset constraints) including Num, Rat and Int types. Native integers cannot support Inf, so attempting to assign Inf will result in an exception; native floats are expected to follow IEEE standards including +/- Inf and NaN.

=={{header|REXX}}==

=={{header|RLaB}}==

>> x = inf()

inf

>> -inf() > 10

0

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

Rust has builtin function for floating types which returns infinity. This program outputs 'inf'.

let inf = f32::INFINITY;

println!("{}", inf);

=={{header|Scala}}==

* [[Extreme_floating_point_values#Scala]]

In order to be compliant with IEEE-754, Scala has all support for infinity on its floating-point types (<tt>float</tt>, <tt>double</tt>). You can get infinity from constants in the corresponding wrapper class; for example, <tt>Double</tt>:

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

REPL session:

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

say a.is_inf # true

say a.is_pos # true

var inf = Inf

var ninf = -Inf

=={{header|Slate}}==

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

The behavior is slightly different, in that an exception is raised if you divide by zero:

but we can simulate the other behavior with:

1.0 / 0.0

] on: ZeroDivide do:[:ex |

ex proceedWith: (FloatD infinity)

]

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

<pre>

=={{header|Swift}}==

Swift's floating-point types (<tt>Float</tt>, <tt>Double</tt>, and any other type that conforms to the <tt>FloatingPointNumber</tt> protocol) all support infinity. You can get infinity from the <tt>infinity</tt> class property in the type:

As a function:

return Double.infinity

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

Infinity is a defined value in Ursa.

=={{header|Ursala}}==

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

Positive infinity, negative infinity and indefinite number (usable as NaN) can be generated by deliberately dividing by zero under the influence of <code>On Error Resume Next</code>:

Private Declare Sub GetMem8 Lib "msvbvm60.dll" _

DoubleAsHex = Right$(String$(8, "0") & Hex$(l(1)), 8) _

& Right$(String$(8, "0") & Hex$(l(0)), 8)

{{out}}<pre>PlusInfinity = 1,#INF (7FF0000000000000)

MinusInfinity = -1,#INF (FFF0000000000000)

=={{header|Vlang}}==

fn main() {

x = math.inf(1)

println('$x ${math.is_inf(x, 1)}') // demonstrate result

=={{header|Wren}}==

Wren certainly supports infinity for floating point numbers as we already have a method ''Num.isInfinity'' to test for it.

var y = x / 0

System.print("x = %(x)")

System.print("y = %(y)")

System.print("'x' is infinite? %(x.isInfinity)")

{{out}}

=={{header|XPL0}}==

The IEEE 754 floating point standard is used.

real X;

[Format(0, 15); \output in scientific notation

A(1):= $7FEF_FFFF;

RlOut(0, X); \display it

{{out}}

=={{header|Yabasic}}==

=={{header|Zig}}==

const debug = std.debug;

// isFinite(f128) is not implemented.

//debug.assert(!math.isFinite(infinite_f128));

=={{header|zkl}}==

zkl doesn't like INF, NaN, etc but sorta knows about them:

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

A quick doubling loop will get you halfway to the maximum floating point value:

20 PRINT z

30 LET z=z*2

Output will end with: