Infinity: Difference between revisions
m
→{{header|Fōrmulæ}}
(copyedit PowerShell entry) |
|||
(89 intermediate revisions by 52 users not shown) | |||
Line 1:
{{task|Basic language learning}}
[[Category:Discrete math]]
;Task:
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 positive floating point number.
For languages with several floating point types, use the type of the literal constant '''1.5''' as floating point type.
;Related task:
* [[Extreme floating point values]]
<br><br>
=={{header|11l}}==
<syntaxhighlight lang="11l">print(Float.infinity)</syntaxhighlight>
{{out}}
<pre>
inf
</pre>
=={{header|ActionScript}}==
ActionScript has the built in function isFinite() to test if a number is finite or not.
<
trace(isFinite(5 / 0)); // outputs "false"</
=={{header|Ada}}==
<
procedure Infinities is
Line 34 ⟶ 49:
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.
Line 45 ⟶ 60:
Here is the code that should work for any type on any machine:
<
procedure Infinities is
Line 70 ⟶ 85:
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:
<pre>
Line 78 ⟶ 93:
===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.
Line 92 ⟶ 107:
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 ∞, 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));
Line 98 ⟶ 113:
printf(($"long max real: "gl$,long max real));
printf(($"long long max real: "gl$,long long max real));
printf(($"error char: "gl$,error char))</
Output:
<pre>
Line 109 ⟶ 124:
error char: *
</pre>
=={{header|APL}}==
For built-in functions, reduction over an empty list returns the identity value for that function.
E.g., <code>+/⍬</code> gives <code>0</code>, and <code>×/⍬</code> gives 1.
The identity value for <code>⌊</code> (minimum) is the largest possible value. For APL implementations
that support infinity, this will be infinity. Otherwise, it will be some large, but finite value.
<syntaxhighlight lang="apl">inf ← {⌊/⍬}</syntaxhighlight>
{{out}}
[[GNU APL]]:
<pre>∞</pre>
[[Dyalog APL]]:
<pre>1.797693135E308</pre>
=={{header|Argile}}==
{{trans|C}} (simplified)
<
printf "%f\n" atof "infinity" (: this prints "inf" :)
#extern :atof<text>: -> real</
=={{header|
<syntaxhighlight lang="rebol">print infinity
print neg infinity</syntaxhighlight>
{{out}}
<pre>∞
-∞</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk"> BEGIN {
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|
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">onerror TratoError
infinity = 1e300*1e300
end
TratoError:
if lasterror = 29 then print lasterrormessage
return</syntaxhighlight>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<
PRINT FNinfinity
END
Line 148 ⟶ 198:
RESTORE ERROR
UNTIL maxpos = prev
= maxpos</
Output:
<pre>
1.79769313E308
</pre>
==={{header|bootBASIC}}===
There are no floating point numbers in bootBASIC. All numbers and variables are 2 byte unsigned integers.
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.
<syntaxhighlight lang="BASIC">10 print 1/0</syntaxhighlight>
=={{header|BQN}}==
Positive infinity is just ∞:
<pre>
∞ + 1
∞
∞ - 3
∞
-∞
¯∞
∞ - ∞
NaN
</pre>
Line 159 ⟶ 230:
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() */
Line 169 ⟶ 240:
printf("%g\n", inf());
return 0;
}</
The output from the above program might be "inf", "1.#INF", or something else.
Line 175 ⟶ 246:
C99 also has a macro for infinity:
<
#include <math.h>
Line 183 ⟶ 254:
printf("%g\n", INFINITY);
return 0;
}</
=={{header|C sharp|C#}}==
<
class Program
Line 199 ⟶ 270:
Console.WriteLine(PositiveInfinity());
}
}</
Output:
<syntaxhighlight lang="text">Infinity</
=={{header|C++}}==
<
double inf()
Line 212 ⟶ 284:
else
return std::numeric_limits<double>::max();
}</
=={{header|Clojure}}==
{{trans|Java}}
Java's floating-point types (float, double) all support infinity.
<syntaxhighlight lang="clojure">##Inf ;; same as Double/POSITIVE_INFINITY
##-Inf ;; same as Double/NEGATIVE_INFINITY
(Double/isInfinite ##Inf) ;; true</syntaxhighlight>
The largest possible number in Java (without using the Big classes) is also in the Double class
(def biggestNumber Double/MAX_VALUE). Its value is (1+(1-2^(-52)))*2^1023 or 1.7976931348623157*10^308 (a.k.a. "big"). Other number classes (Integer, Long, Float, Byte, and Short) have maximum values that can be accessed in the same way.
=={{header|CoffeeScript}}==
Line 228 ⟶ 301:
JavaScript has a special global property called "Infinity":
<syntaxhighlight lang
as well as constants in the Number class:
<
Number.NEGATIVE_INFINITY</
The global isFinite function tests for finiteness:
<syntaxhighlight lang
=={{header|Common Lisp}}==
Line 242 ⟶ 315:
{{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
Line 254 ⟶ 327:
MOST-NEGATIVE-SHORT-FLOAT, value: -3.4028172S38
MOST-NEGATIVE-DOUBLE-FLOAT, value: -1.7976931348623158D308
MOST-NEGATIVE-FIXNUM, value: -536870912</
=={{header|Component Pascal}}==
BlackBox Component Builder
<
MODULE Infinity;
IMPORT StdLog;
Line 270 ⟶ 343:
END Do;
</syntaxhighlight>
Execute: ^Q Infinity.Do<br/>
Output:
Line 276 ⟶ 349:
x:> inf
</pre>
=={{header|D}}==
<
return typeof(1.5).infinity;
}
void main() {}</
=={{header|Delphi}}==
Delphi defines the following constants in Math:
<
NegInfinity = -1.0 / 0.0;</
Test for infinite value using:
<syntaxhighlight lang
=={{header|Dyalect}}==
Dyalect floating point number support positive infinity:
<syntaxhighlight lang="dyalect">func infinityTask() => Float.Infinity</syntaxhighlight>
=={{header|E}}==
<
return Infinity # predefined variable holding positive infinity
}</
=={{header|EasyLang}}==
<syntaxhighlight>
print number "inf"
# or
print 1 / 0
</syntaxhighlight>
=={{header|Eiffel}}==
<
class
APPLICATION
Line 320 ⟶ 407:
end
end
</syntaxhighlight>
Output:
Line 336 ⟶ 423:
floating and MAXLONGREAL for double precision floating. An infinity test can be achieved with
an EXCEPTION:
<syntaxhighlight lang="erre">
PROGRAM INFINITY
Line 352 ⟶ 439:
END WHILE
END PROGRAM
</syntaxhighlight>
=={{header|Euphoria}}==
<
? infinity -- outputs "inf"</
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
printfn "%f" (1.0/0.0)
</syntaxhighlight>
{{out}}
<pre>
Infinity
</pre>
=={{header|Factor}}==
<syntaxhighlight lang
=={{header|Fantom}}==
Line 367 ⟶ 463:
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
{
Line 373 ⟶ 469:
public static Void main () { echo (getInfinity ()) }
}
</syntaxhighlight>
=={{header|Forth}}==
<
inf f. \ implementation specific. GNU Forth will output "inf"
Line 382 ⟶ 478:
\ IEEE infinity is the only value for which this will return true
: has-inf ( -- ? ) ['] inf catch if false else inf? then ;</
=={{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
Line 403 ⟶ 499:
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 :: huge_real = huge(x)</
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
#Include "crt/math.bi"
#Print Typeof(1.5) ' Prints DOUBLE at compile time
Dim d As Typeof(1.5) = INFINITY
Print d; " (String representation of Positive Infinity)"
Sleep
</syntaxhighlight>
{{out}}
<pre>
1.#INF (String representation of Positive Infinity)
</pre>
=={{header|FutureBasic}}==
FB has a native definition for infinite floating point types. As demonstrated below, it returns "inf".
<syntaxhighlight lang="futurebasic">
printf @"%g", INFINITY
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
inf
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Infinity}}
'''Solution'''
Fōrmulæ does not use floating point numbers, but arbitrary-size integers and arbitrary-precision decimal numbers.
Infinity is a predefined expression in Fōrmulæ.
Reduction of certain expressions can produce it:
[[File:Fōrmulæ - Infinity 01.png]]
[[File:Fōrmulæ - Infinity 02.png]]
=={{header|GAP}}==
<
inf := FLOAT_INT(1) / FLOAT_INT(0);
Line 418 ⟶ 559:
# GAP has also a formal ''infinity'' value
infinity in Cyclotomics;
# true</
=={{header|Go}}==
<
import (
Line 439 ⟶ 580:
x = posInf() // test function
fmt.Println(x, math.IsInf(x, 1)) // demonstrate result
}</
Output:
<pre>
Line 447 ⟶ 588:
=={{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:
<
printf ( "0x%xL \n", Double.doubleToLongBits(biggest()) )</
Output:
Line 463 ⟶ 604:
Nevertheless, the following may come close to the task description:
<
maxRealFloat x = encodeFloat b (e-1) `asTypeOf` x where
b = floatRadix x - 1
Line 470 ⟶ 611:
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:
<
Infinity
*Main> infinity :: Double
Infinity</
Or you can simply use division by 0:
<
Infinity
Prelude> 1 / 0 :: Double
Infinity</
Or use "read" to read the string representation:
<
Infinity
Prelude> read "Infinity" :: Double
Infinity</
=={{header|Icon}} and {{header|Unicon}}==
Line 500 ⟶ 641:
IDL provides the standard IEEE values for _inf and _NaN in the !Values system structure:
<
print, !Values.D_infinity ;; for doubles</
=={{header|Io}}==
<
or
<syntaxhighlight lang
=={{header|IS-BASIC}}==
<syntaxhighlight lang="is-basic">PRINT INF</syntaxhighlight>
Output:
<pre>
9.999999999E62
</pre>
=={{header|J}}==
Line 515 ⟶ 663:
Example:
<syntaxhighlight lang="j">
_ * 5 NB. multiplying infinity to 5 results in infinity
_
Line 522 ⟶ 670:
5 % 0 NB. dividing 5 by 0 results in infinity
_
</syntaxhighlight>
=={{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>:
<
Double.isInfinite(infinity); //true</
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<sup>-52</sup>)*2<sup>1023</sup> or 1.7976931348623157*10<sup>308</sup> (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":
<syntaxhighlight lang
as well as constants in the Number class:
<
Number.NEGATIVE_INFINITY</
The global isFinite() function tests for finiteness:
<syntaxhighlight lang
=={{header|Joy}}==
<syntaxhighlight lang="joy">1 1024 ldexp dup neg stack.</syntaxhighlight>
{{out}}
<pre>[-inf inf]</pre>
=={{header|jq}}==
Sufficiently recent versions of the C, Go and Rust implementations of jq (jq, gojq, and jaq, respectively) all allow `infinite` as a scalar value in jq programs; jq and gojq display its value as 1.7976931348623157e+308. The C implementation also allows the token `inf` when reading JSON, and stores it as `infinite`.
The C implementation of jq uses IEEE 754 64-bit floating-point arithmetic, and very large real number literals, e.g. 1e1000, are evaluated as IEEE 754 infinity, so if your version of jq does not include `infinite` as a built-in, you could therefore define it as follows:
<syntaxhighlight lang="jq">def infinite: 1e1000;</syntaxhighlight>
To test whether a jq value is equal to `infinite` or `- infinite`, one can use the built-in filter `isinfinite`. One can also use `==` in the expected manner.
=={{header|Julia}}==
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.
<syntaxhighlight lang="julia">
julia> julia> Inf32 == Inf64 == Inf16 == Inf
true
</syntaxhighlight>
=={{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
Line 628 ⟶ 767:
/ but
0.0%0.0
0.0</
=={{header|Klingphix}}==
<syntaxhighlight lang="klingphix">1e300 dup mult tostr "inf" equal ["Infinity" print] if
" " input</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">fun main(args: Array<String>) {
val p = Double.POSITIVE_INFINITY // +∞
println(p.isInfinite()) // true
println(p.isFinite()) // false
println("${p < 0} ${p > 0}") // false true
val n = Double.NEGATIVE_INFINITY // -∞
println(n.isInfinite()) // true
println(n.isFinite()) // false
println("${n < 0} ${n > 0}") // true false
}</syntaxhighlight>
{{out}}
<pre>true
false
false true
true
false
true false</pre>
=={{header|Lambdatalk}}==
Lambdatalk is built on Javascript and can inherit lots of its capabilities. For instance:
<syntaxhighlight lang="scheme">
{/ 1 0}
-> Infinity
{/ 1 Infinity}
-> 0
{< {pow 10 100} Infinity}
-> true
{< {pow 10 1000} Infinity}
-> false
</syntaxhighlight>
=={{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 />'
infinity -> type</
-> inf
decimal
=={{header|Lingo}}==
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.
<syntaxhighlight lang="lingo">x = (1-power(2, -53)) * power(2, 1023) * 2
put ilk(x), x
-- #float 1.79769313486232e308
x = (1-power(2, -53)) * power(2, 1023) * 3
put ilk(x), x, -x
-- #float INF -INF</syntaxhighlight>
=={{header|Lua}}==
<syntaxhighlight lang="lua">
function infinity()
return 1/0 --lua uses unboxed C floats for all numbers
end
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Rem : locale 1033
Module CheckIt {
Form 66,40
Cls 5
Pen 14
\\ Ensure True/False for Print boolean (else -1/0)
\\ from m2000 console use statement Switches without Set.
\\ use Monitor statement to see all switches.
Set Switches "+SBL"
IF version<9.4 then exit
IF version=9.4 and revision<25 then exit
Function Infinity(positive=True) {
buffer clear inf as byte*8
m=0x7F
if not positive then m+=128
return inf, 7:=m, 6:=0xF0
=eval(inf, 0 as double)
}
K=Infinity(false)
L=Infinity()
Function TestNegativeInfinity(k) {
=str$(k, 1033) = "-1.#INF"
}
Function TestPositiveInfinity(k) {
=str$(k, 1033) = "1.#INF"
}
Function TestInvalid {
=str$(Number, 1033) = "-1.#IND"
}
Pen 11 {Print " True True"}
Print TestNegativeInfinity(K), TestPositiveInfinity(L)
Pen 11 {Print " -1.#INF 1.#INF -1.#INF 1.#INF -1.#INF 1.#INF"}
Print K, L, K*100, L*100, K+K, L+L
M=K/L
Pen 11 {Print " -1.#IND -1.#IND True True" }
Print K/L, L/K, TestInvalid(M), TestInvalid(K/L)
M=K+L
Pen 11 {Print " -1.#IND -1.#IND -1.#IND True True"}
Print M, K+L, L+K, TestInvalid(M), TestInvalid(K+L)
Pen 11 {Print " -1.#INF 1.#INF"}
Print 1+K+2, 1+L+2
Pen 11 {Print " -1.#INF"}
Print K-L
Pen 11 {Print " 1.#INF"}
Print L-K
}
Checkit
</syntaxhighlight>
=={{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.
<syntaxhighlight lang="maple">
> proc() Float(infinity) end();
Float(infinity)
</syntaxhighlight>
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.
<syntaxhighlight lang="maple">
> proc() HFloat(infinity) end();
HFloat(infinity)
</syntaxhighlight>
=={{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}]
10^100 < Infinity</
gives back:
<pre>Pi^2/6
Line 663 ⟶ 909:
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>
Line 670 ⟶ 916:
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)
</syntaxhighlight>
Returns:
Line 681 ⟶ 927:
=={{header|Maxima}}==
<
declare(x, real)$
Line 694 ⟶ 940:
1.0/0.0;
/* expt: undefined: 0 to a negative exponent.
-- an error. To debug this try: debugmode(true); */</
=={{header|Metafont}}==
Line 700 ⟶ 946:
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:
<syntaxhighlight lang="miniscript">posInfinity = 1/0
print posInfinity</syntaxhighlight>
{{out}}
<pre>INF</pre>
=={{header|Modula-2}}==
<
IMPORT InOut;
Line 710 ⟶ 964:
InOut.WriteReal (1.0 / 0.0, 12, 12);
InOut.WriteLn
END inf.</
Producing
<
**** RUNTIME ERROR bound check error
Floating point exception</
=={{header|Modula-3}}==
Line 721 ⟶ 975:
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;
Line 728 ⟶ 982:
IO.PutReal(IEEESpecial.RealPosInf);
IO.Put("\n");
END Inf.</
Output:
Line 737 ⟶ 991:
=={{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
def c = IsPositiveInfinity(posinf); // c = true</
=={{header|Nim}}==
<syntaxhighlight lang
is a predefined constant in Nim:
<
echo f</
=={{header|NS-HUBASIC}}==
<syntaxhighlight lang="ns-hubasic">10 PRINT 1/0</syntaxhighlight>
{{out}}
?DZ ERROR is a division by zero error in NS-HUBASIC.
<pre>
?DZ ERROR IN 10
</pre>
=={{header|OCaml}}==
<syntaxhighlight lang
is already a pre-defined value in OCaml.
Line 758 ⟶ 1,020:
- : float = infinity
</pre>
=={{header|Oforth}}==
<
{{out}}
Line 770 ⟶ 1,031:
0
</pre>
=={{header|Ol}}==
Inexact numbers support can be disabled during recompilation using "-DOLVM_INEXACTS=0" command line argument. Inexact numbers in Ol demands the existence of infinity, by demanding IEEE numbers. There are two signed infinity numbers (as constants) in Ol:
+inf.0 ; positive infinity
-inf.0 ; negative infinity
<syntaxhighlight lang="scheme">
(define (infinite? x) (or (equal? x +inf.0) (equal? x -inf.0)))
(infinite? +inf.0) ==> #true
(infinite? -inf.0) ==> #true
(infinite? +nan.0) ==> #false
(infinite? 123456) ==> #false
(infinite? 1/3456) ==> #false
(infinite? 17+28i) ==> #false
</syntaxhighlight>
=={{header|OpenEdge/Progress}}==
Line 775 ⟶ 1,053:
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 )
VIEW-AS ALERT-BOX.</
Output
Line 796 ⟶ 1,074:
=={{header|OxygenBasic}}==
Using double precision floats:
<
print 1.5e-400 '0
Line 817 ⟶ 1,095:
print f '#-INF
</syntaxhighlight>
=={{header|Oz}}==
<
PosInf = 1./0.
NegInf = ~1./0.
Line 832 ⟶ 1,110:
PosInf * PosInf = PosInf
PosInf * NegInf = NegInf
NegInf * NegInf = PosInf</
=={{header|PARI/GP}}==
{{works with|PARI/GP|version 2.8.0 and higher}}
<syntaxhighlight lang="parigp">+oo</syntaxhighlight>
{{works with|PARI/GP|version 2.2.9 to 2.7.0}}
<syntaxhighlight lang="parigp">infty()={
[1] \\ Used for many functions like intnum
};</
=={{header|Pascal}}==
Line 844 ⟶ 1,126:
=={{header|Perl}}==
Positive infinity:
<
my $y = 0 + "+inf";</
Negative infinity:
<
my $y = 0 + "-inf";</
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<sup>1000</sup> or googol<sup>10</sup> or even numbers like this one:
<
which is 10<sup>10000000000</sup> 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;
my $y = 10**10**10; # N.B. this will consume vast quantities of RAM</
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;
my $y = -inf;</
=={{header|
<!--<syntaxhighlight lang="phix">(phixonline)-->
<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>
<!--</syntaxhighlight>-->
{{out}}
desktop/Phix:
<pre>
inf
</pre>
pwa/p2js:
<pre>
Infinity
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">1e300 dup * tostr "inf" == if "Infinity" print endif</syntaxhighlight>
=={{header|PHP}}==
This is how you get infinity:
<syntaxhighlight lang
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}}==
Line 892 ⟶ 1,183:
support (scaled bignum arithmetics), but some functions return 'T' for infinite
results.
<
: (exp 1000.0)
-> T</
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
declare x float, y float (15), z float (18);
put skip list (huge(x), huge(y), huge(z));
</syntaxhighlight>
=={{header|PostScript}}==
<
=={{header|PowerShell}}==
A .NET floating-point number representing infinity is available.
<
[double]::PositiveInfinity
}</
=={{header|PureBasic}}==
Line 910 ⟶ 1,208:
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
Line 929 ⟶ 1,227:
CloseConsole()
EndIf
</syntaxhighlight>
''Outputs''
Line 939 ⟶ 1,237:
=={{header|Python}}==
This is how you get 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.'' <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>
ZeroDivisionError: float division</
If <tt>float('infinity')</tt> doesn't work on your platform, you could use this trick:
Line 954 ⟶ 1,252:
1.#INF</pre>
It works by trying to create a float bigger than the machine can handle.
=={{header|QB64}}==
<syntaxhighlight lang="c++">#include<math.h>
//save as inf.h
double inf(void){
return HUGE_VAL;
}</syntaxhighlight>
<syntaxhighlight lang="vb">Declare CustomType Library "inf"
Function inf#
End Declare
Print inf</syntaxhighlight>
=={{header|QBasic}}==
{{works with|QBasic|1.1}}
<syntaxhighlight lang="qbasic">DECLARE FUNCTION f! ()
ON ERROR GOTO TratoError
PRINT 0!
PRINT 0 / -1.5
PRINT 1.5 / 0
PRINT 0 / 0
PRINT f
END
TratoError:
PRINT "Error "; ERR; " on line "; ERL; CHR$(9); " --> ";
SELECT CASE ERR
CASE 6
PRINT "Overflow"
RESUME NEXT
CASE 11
PRINT "Division by zero"
RESUME NEXT
CASE ELSE
PRINT "Unexpected error, ending program."
END
END SELECT
FUNCTION f!
f! = -1.5 / 0
END FUNCTION</syntaxhighlight>
=={{header|R}}==
<
-Inf #negative infinity
.Machine$double.xmax # largest finite floating-point number
Line 966 ⟶ 1,307:
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
# [5] -1.797693e+308 1.797693e+308 -1.797693e+308</
=={{header|Racket}}==
Line 972 ⟶ 1,313:
as in Scheme:
<
+inf.0 ; positive infinity
(define (finite? x) (< -inf.0 x +inf.0))
(define (infinite? x) (not (finite? x)))</
=={{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.
<syntaxhighlight lang="raku" line>my $x = 1.5/0; # Failure: catchable error, if evaluated will return: "Attempt to divide by zero ...
my $y = (1.5/0).Num; # assigns 'Inf'</syntaxhighlight>
=={{header|REXX}}==
Line 1,012 ⟶ 1,359:
... and so on with larger NUMERIC DIGITS
</pre>
For
<br>but the pratical limit would be a little less than half of available virtual storage,
<br>which would (realistically) be around one billion digits. Other interpreters have a limitation of roughly 8 million
=={{header|RLaB}}==
<syntaxhighlight lang="rlab">
>> x = inf()
inf
Line 1,026 ⟶ 1,373:
>> -inf() > 10
0
</syntaxhighlight>
=={{header|RPL}}==
{{in}}
<pre>
MAXR →NUM
</pre>
{{out}}
<pre>
1: 1.7976931348E+308
</pre>
=={{header|Ruby}}==
Infinity is a Float value
<
a.finite? # => false
a.infinite? # => 1
Line 1,040 ⟶ 1,395:
a = Float::MAX # => 1.79769313486232e+308
a.finite? # => true
a.infinite? # => nil</
{{works with|Ruby|1.9.2+}}
<
=={{header|Rust}}==
Rust has builtin function for floating types which returns infinity. This program outputs 'inf'.
<syntaxhighlight lang="rust">fn main() {
let inf = f32::INFINITY;
println!("{}", inf);
}</
=={{header|Scala}}==
Line 1,059 ⟶ 1,412:
* [[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>:
<
inf.isInfinite; //true</
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
Line 1,075 ⟶ 1,428:
scala> 1 / Double.NegativeInfinity
res5: Double = -0.0</
=={{header|Scheme}}==
<
(define (finite? x) (< -inf.0 x +inf.0))
(define (infinite? x) (not (finite? x)))</
=={{header|Seed7}}==
Line 1,086 ⟶ 1,439:
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
say a.is_pos
var b = -1.5/0 # -Inf
say b.is_ninf # true
say b.is_neg # true
var
var ninf = -Inf
say
=={{header|Slate}}==
<syntaxhighlight lang
=={{header|Smalltalk}}==
Line 1,116 ⟶ 1,469:
</pre>
{{works with|Smalltalk/X}}
The behavior is slightly different, in that an exception is raised if you divide by zero:
<syntaxhighlight lang="smalltalk">FloatD infinity -> INF
1.0 / 0.0 -> "ZeroDivide exception"</syntaxhighlight>
but we can simulate the other behavior with:
<
1.0 / 0.0
] on: ZeroDivide do:[:ex |
ex proceedWith: (
]
-> INF</
=={{header|Standard ML}}==
<syntaxhighlight lang
<pre>
Line 1,141 ⟶ 1,492:
=={{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:
<
inf.isInfinite //true</
As a function:
<
return Double.infinity
}</
=={{header|Tcl}}==
Line 1,152 ⟶ 1,503:
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
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:
<
ffffffffffffffff
Line 1,170 ⟶ 1,521:
% 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]
Line 1,176 ⟶ 1,527:
=={{header|TI-89 BASIC}}==
<syntaxhighlight lang
=={{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 = ;
</syntaxhighlight>
=={{header|Ursa}}==
Infinity is a defined value in Ursa.
<syntaxhighlight lang="ursa">decl double d
set d Infinity</syntaxhighlight>
=={{header|Ursala}}==
Line 1,199 ⟶ 1,555:
<
infinity = inf!</
=={{header|Visual Basic}}==
{{works with|Visual Basic|5}}
{{works with|Visual Basic|6}}
{{works with|VBA|Access 97}}
{{works with|VBA|6.5}}
{{works with|VBA|7.1}}
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>:
<syntaxhighlight lang="vb">Option Explicit
Private Declare Sub GetMem8 Lib "msvbvm60.dll" _
(ByVal SrcAddr As Long, ByVal TarAddr As Long)
Sub Main()
Dim PlusInfinity As Double
Dim MinusInfinity As Double
Dim IndefiniteNumber As Double
On Error Resume Next
PlusInfinity = 1 / 0
MinusInfinity = -1 / 0
IndefiniteNumber = 0 / 0
Debug.Print "PlusInfinity = " & CStr(PlusInfinity) _
& " (" & DoubleAsHex(PlusInfinity) & ")"
Debug.Print "MinusInfinity = " & CStr(MinusInfinity) _
& " (" & DoubleAsHex(MinusInfinity) & ")"
Debug.Print "IndefiniteNumber = " & CStr(IndefiniteNumber) _
& " (" & DoubleAsHex(IndefiniteNumber) & ")"
End Sub
Function DoubleAsHex(ByVal d As Double) As String
Dim l(0 To 1) As Long
GetMem8 VarPtr(d), VarPtr(l(0))
DoubleAsHex = Right$(String$(8, "0") & Hex$(l(1)), 8) _
& Right$(String$(8, "0") & Hex$(l(0)), 8)
End Function</syntaxhighlight>
{{out}}<pre>PlusInfinity = 1,#INF (7FF0000000000000)
MinusInfinity = -1,#INF (FFF0000000000000)
IndefiniteNumber = -1,#IND (FFF8000000000000)
</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import math
fn main() {
mut x := 1.5 // type of x determined by literal
// that this compiles demonstrates that PosInf returns same type as x,
// the type specified by the task.
x = math.inf(1)
println('$x ${math.is_inf(x, 1)}') // demonstrate result
}</syntaxhighlight>
=={{header|Wren}}==
Wren certainly supports infinity for floating point numbers as we already have a method ''Num.isInfinity'' to test for it.
<syntaxhighlight lang="wren">var x = 1.5
var y = x / 0
System.print("x = %(x)")
System.print("y = %(y)")
System.print("'x' is infinite? %(x.isInfinity)")
System.print("'y' is infinite? %(y.isInfinity)")</syntaxhighlight>
{{out}}
<pre>
x = 1.5
y = infinity
'x' is infinite? false
'y' is infinite? true
</pre>
=={{header|XPL0}}==
The IEEE 754 floating point standard is used.
<syntaxhighlight lang="xpl0">int A;
real X;
[Format(0, 15); \output in scientific notation
A:= addr X; \get address of (pointer to) X
A(0):= $FFFF_FFFF; \stuff in largest possible value
A(1):= $7FEF_FFFF;
RlOut(0, X); \display it
]</syntaxhighlight>
{{out}}
<pre>
1.797693134862320E+308
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">infinity = 1e300*1e300
if str$(infinity) = "inf" print "Infinity"</syntaxhighlight>
=={{header|Zig}}==
'''Works with:''' 0.10.x, 0.11.x, 0.12.0-dev.1577+9ad03b628
Assumes that defaul float optimization mode was not changed via @setFloatMode (performed in Strict mode, not Optimized, latter is equivalent to -ffast-math).
<syntaxhighlight lang="zig">const std = @import("std");
const math = std.math;
test "infinity" {
const expect = std.testing.expect;
const float_types = [_]type{ f16, f32, f64, f80, f128, c_longdouble };
inline for (float_types) |T| {
const infinite_value: T = comptime std.math.inf(T);
try expect(math.isInf(infinite_value));
try expect(math.isPositiveInf(infinite_value));
try expect(!math.isNegativeInf(infinite_value));
try expect(!math.isFinite(infinite_value));
}
}</syntaxhighlight>
{{out}}
<pre>
$ zig test src/infinity_float.zig
All 1 tests passed.
</pre>
=={{header|zkl}}==
zkl doesn't like INF, NaN, etc but sorta knows about them:
<syntaxhighlight lang
{{out}}
<pre>
Line 1,229 ⟶ 1,685:
</pre>
=={{header|ZX Spectrum Basic}}==
ZX Spectrum BASIC has no infinity handling; <syntaxhighlight lang="zxbasic">PRINT 1/0</syntaxhighlight> will be met with <pre>6 Number too big, 0:1</pre>
A quick doubling loop will get you halfway to the maximum floating point value:
<syntaxhighlight lang="zxbasic">10 LET z=1
20 PRINT z
30 LET z=z*2
40 GO TO 20</syntaxhighlight>
Output will end with:
<pre>
4.2535296E+37
8.5070592E+37
6 Number too big, 30:1
</pre>
Precision has been lost by this stage through the loop, but one more manual double and subtract 1 will get you the true displayable maximum of 1.7014118E+38 (or 2^127-1).
{{omit from|6502 Assembly|Has no dedicated floating point hardware}}
{{omit from|8080 Assembly|Has no dedicated floating point hardware}}
{{omit from|bc|No infinity. Numbers have unlimited precision, so no largest possible value.}}
{{omit from|Brainf***}}
{{omit from|Computer/zero Assembly|Has no dedicated floating point hardware}}
{{omit from|dc|No infinity. Numbers have unlimited precision, so no largest possible value.}}
{{omit from|Integer BASIC}}
Line 1,238 ⟶ 1,713:
{{omit from|VBScript}}
{{omit from|UNIX Shell}}
{{omit from|Z80 Assembly|Has no dedicated floating point hardware}}
[[Category:Irrational numbers]]
|