Extreme floating point values: Difference between revisions

 

For performance reasons, the built-in floating-point types like Float and Long_Float are allowed to have IEEE 754 semantics if the machine numbers are IEEE 754. But the language provides means to exclude all non numbers from these types by defining a subtype with an explicit range:

subtype Consistent_Float is Float range Float'Range; -- No IEEE ideals

In general in properly written Ada programs variables may not become invalid when standard numeric operations are applied. The language also provides the attribute 'Valid to verify values obtained from unsafe sources e.g. from input, unchecked conversions etc.

 

As stated above on a machine where Float is implemented by an IEEE 754 machine number, IEEE 754 is permitted leak through. The following program illustrates how this leak can be exploited:

with Ada.Text_IO; use Ada.Text_IO;

 

end IEEE;

The expression -1.0 / 0.0 were non-numeric and thus could not be used.

To fool the compiler the variable Zero is used,

 

{{works with|nawk|20100523}}

# This requires 1e400 to overflow to infinity.

nzero = -0

print "nan == nan?", (nan == nan) ? "yes" : "no"

print "nan == 42?", (nan == 42) ? "yes" : "no"

 

----

 

{{works with|gcc|4.4.3}}

 

int main()

 

return 0;

 

{{out}}

(most significant bit first for each byte).

It should be pretty portable.

#include <values.h>

#include <math.h>

 

return 0;

 

=={{header|Clojure}}==

{{Trans|Groovy}}

(def neg-inf (/ -1.0 0.0)) ; Also Double/NEGATIVE_INFINITY

(def inf (/ 1.0 0.0)) ; Also Double/POSITIVE_INFINITY

(println " NaN == NaN: " (= Double/NaN Double/NaN))

(println "NaN equals NaN: " (.equals Double/NaN Double/NaN))

 

{{out}}

This program shows only part of the floating point features

supported by D and its Phobos standard library.

 

import std.stdio: writeln, writefln;

immutable real f3 = NaN(0x3FFF_FFFF_FFFF_FFFF);

writeln(getNaNPayload(f3));

{{out}}

<pre>Computed extreme float values:

 

Among other things, it is possible to trap FP hardware exceptions:

 

void main() {

double y1 = f0 / f0; // generates hardware exception

// unless it's compiled with -O)

{{out}}

<pre>object.Error: Invalid Floating Point Operation</pre>

Tested on Delphi 2009:

 

 

{$APPTYPE CONSOLE}

 

Readln;

 

=={{header|Eiffel}}==

class

APPLICATION

print("(0.0 = -0.0) = ") print((0.0 = negZero)) print("%N")

end

{{out}}

<pre>Negative Infinity: -Infinity

=={{header|Euphoria}}==

{{trans|C}}

constant minus_inf = -inf

constant nan = 0*inf

printf(1,"0.0 * +inf = %f\n", 0.0 * inf)

printf(1,"NaN + 1.0 = %f\n", nan + 1.0)

 

{{out}}

 

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

0.0/0.0 //->nan

0.0/(-0.0) //->nan

-infinity<infinity //->true

(-0.0)<0.0 //->false

 

=={{header|Factor}}==

0. neg . ! -0.0 neg works with floating point zeros

0. -1. * . ! -0.0 calculating negative zero

! arbitrary 64-bit hex payload

1/0. 1/0. - . ! NAN: 8000000000000 calculating NaN by subtracting

 

=={{header|Forth}}==

{{works with|GNU Forth}}

-1e 0e f/ f. \ inf (output bug: should say "-inf")

-1e 0e f/ f0< . \ -1 (true, it is -inf)

0e 0e f/ f. \ nan

 

=={{header|Fortran}}==

===Pragmatics===

To prepare variables with these non-numerical states is troublesome, because attaining infinity by x = 1/0 or the like is not only bad behaviour, it invites complaint from the compiler or the generation of a run-time error and immediate cancellation of the run. One could mess about by using a READ statement on special texts, but that prevents the results being constants. Instead, one studies the definitions and devises code such as ...

REAL*8 BAD,NaN !Sometimes a number is not what is appropriate.

PARAMETER (NaN = Z'FFFFFFFFFFFFFFFF') !This value is recognised in floating-point arithmetic.

PARAMETER (PINF = Z'7FF0000000000000') !May well cause confusion

PARAMETER (NINF = Z'FFF0000000000000') !On a cpu not using this scheme.

After experimenting with code such as

Cause various arithmetic errors to see what sort of hissy fit is thrown.

REAL X2,X3,X4,Y4,XX,ZERO

WRITE (6,*) "Burp!"

END

Which provides output such as

<pre>

 

=={{header|FreeBASIC}}==

 

#Include "crt/math.bi"

Print notNum, notNum + inf + negInf

Print negZero, negZero - 1

 

{{out}}

 

=={{header|Go}}==

 

import (

fmt.Println("!!! Expected", op, " Found not true.")

}

{{out}}

<pre>

{{Trans|Java}}

Solution:

def inf = 1.0d / 0.0d; //also Double.POSITIVE_INFINITY

def nan = 0.0d / 0.0d; //also Double.NaN

println(" 0 * NaN: " + (0 * nan));

println(" NaN == NaN: " + (nan == nan));

 

{{out}}

 

=={{header|haskell}}==

main = do

let inf = 1/0

putStrLn ("0.0 == - 0.0 = "++(show (0.0 == minus_zero)))

putStrLn ("inf == inf = "++(show (inf == inf)))

{{out}}

<pre>

 

'''Extreme values'''

NegInf=: __

NB. Negative zero cannot be represented in J to be distinct from 0.

The numeric atom <code>_.</code> ([[j:Essays/Indeterminate|Indeterminate]]) is provided as a means for dealing with NaN in data from sources outside J.

J itself generates NaN errors rather than NaN values and recommends that <code>_.</code> be removed from data as soon as possible because, by definition, NaN values will produce inconsistent results in contexts where value is important.

 

'''Extreme values from expressions'''

_ __

(1e234 * 1e234) , (_1e234 * 1e234)

%__ NB. Under the covers, the reciprocal of NegInf produces NegZero, but this fact isn't exposed to the user, who just sees zero

0

 

'''Some arithmetic'''

_

__ + __

_

NegInf * 0

 

=={{header|Java}}==

public static void main(String[] args) {

double negInf = -1.0 / 0.0; //also Double.NEGATIVE_INFINITY

System.out.println("NaN == NaN: " + (nan == nan));

}

{{out}}

<pre>Negative inf: -Infinity

 

For example, here are two expressions and the result of displaying their values:

 

If your jq does not already have `infinite` and `nan` defined as built-in functions, they can be defined as follows:

 

 

Here are some further expressions with their results:

 

0 == -0 # => true

infinite == infinite #=> true

1/infinite #=> 0

 

 

Since `==` cannot be used to check if a value is IEEE NaN, jq 1.5 provides the builtin function `isnan` for doing so:

 

Exceptional values can be assigned to jq variables in the usual way:

 

=={{header|Julia}}==

function showextremes()

values = [0.0, -0.0, Inf, -Inf, NaN]

@show NaN == NaN

@show NaN === NaN

 

{{out}}

 

=={{header|Kotlin}}==

 

@Suppress("DIVISION_BY_ZERO", "FLOAT_LITERAL_CONFORMS_ZERO")

println("nan / nan : ${nan / nan}")

println("negZero + 0.0 : ${negZero + 0.0}")

 

{{out}}

Infinity and NaN are straight forward. for negative 0 you need to resort to a literal with a large,

negative exponent, which is not the same thing.

 

local inf=math.huge

local NaN=0/0

local negativeZeroSorta=-1E-240

Lua seems to break x==1/(1/x) for infinity:

1/(1/-math.huge)==math.huge

true

 

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

Function[expression,

Row@{HoldForm@InputForm@expression, " = ", Quiet@expression},

Infinity - Infinity, 0 Infinity, ComplexInfinity + 1,

ComplexInfinity + ComplexInfinity, 2 ComplexInfinity,

{{out}}

<pre>1./0. = ComplexInfinity

for positive and negative infinitesimal (though their usage is quite obscure),

and <code>und</code> for undefined value.

 

=={{header|MUMPS}}==

===Intersystems Caché===

Caché has the function $DOUBLE which complies with the IEEE 754 standard. The negative zero is indistinguishable from positive zero by operations. The special values evaluate to 0 when converted to a number in a later operation.

EXTREMES

NEW INF,NINF,ZERO,NOTNUM,NEGZERO

KILL INF,NINF,ZERO,NONNUM,NEGZERO

QUIT

{{out}}

<pre>USER>d EXTREMES^ROSETTA

While [[NetRexx]] native support for numbers allows for very large decimal precision, the [[Java]] primitives (<tt>int</tt>, <tt>long</tt>, <tt>float</tt>, <tt>double</tt> etc.), can use the constants and methods provided for &quot;extreme&quot; values:

{{trans|Java}}

options replace format comments java crossref symbols binary

 

 

return

{{out}}

<pre>

 

=={{header|Nim}}==

echo 1e234 * -1e234 # -inf

echo 1 / Inf # 0

echo NaN * 0.0 # nan

echo 0.0 * Inf # nan

 

=={{header|OCaml}}==

- : float = infinity

# neg_infinity;;

- : bool = true

# 0. == -0.;;

 

=={{header|Oforth}}==

By default numbers in Ol is rational (exact) with unlimited exactness (if you have enought RAM). Therefore, we must explicitly use the 'inexact' function to force vm to use machine dependent floating point values.

 

 

(print "infinity: " (/ 1 0))

; note: your must use equal? or eqv? but not eq? for comparison

(print "is this is not a number? " (equal? (fsqrt -1) +nan.0))

{{out}}

<pre>

 

=={{header|Oz}}==

Inf = 1.0e234 * 1.0e234

MinusInf = 1.0e234 * ~1.0e234

 

{Show 1.0/0.0 == Inf} %% true

 

{{out}}

-infinite: -1.#INF

0: 0.0

true

true

 

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

Division by zero, <tt>sqrt(-1)</tt> and <tt>log(0)</tt> are fatal errors.

To get infinity and NaN, use corresponding string and force a numeric conversion by adding zero to it, or prepending a "+" or "-":

use strict;

use warnings;

printf "nan test: %g\n", (1 + 2 * 3 - 4) / (-5.6e7 * $nan);

printf "nan == nan? %s\n", ($nan == $nan) ? "yes" : "no";

 

{{out}}

There is no negative zero.

 

use strict;

use warnings;

printf "\$nan * \$huge = %s\n", $nan->copy()->bmul($huge);

printf "\$nan == \$nan? %s\n", defined($nan->bcmp($nan)) ? "maybe" : "no";

 

{{out}}

 

=={{header|Phix}}==

{{out}}

<pre>

 

If you fancy having a go at negative zero support (ditto), your first stop should be :%pStoreFlt in builtins\VM\pHeap.e and use whatever the test is for -0.0 there. I would be happiest if apps that needed support of -0.0 had to explicitly call something in pHeap.e to set a flag to enable any new code.

 

=={{header|PicoLisp}}==

Minus zero and negative infinity cannot be represented,

while NaN is represented by NIL

 

: (exp 1000.0) # Too large for IEEE floats

 

: (+ 1 2 NIL 3) # NaN propagates

 

=={{header|PureBasic}}==

If OpenConsole()

inf = Infinity() ; or 1/None ;None represents a variable of value = 0

Print(#CRLF$+"Press ENTER to EXIT"): Input()

<pre>positive infinity: +Infinity

negative infinity: -Infinity

 

=={{header|Python}}==

>>> inf = 1e234 * 1e234

>>> _inf = 1e234 * -1e234

nan

>>> inf * 0.0

 

>>> 1 / -0.0

 

1 / -0.0

ZeroDivisionError: float division by zero

 

=={{header|R}}==

1/c(0, -0, Inf, -Inf, NaN)

 

=={{header|Racket}}==

(define division-by-zero (/ 1.0 0.0)) ;+inf.0

(define negative-inf (- (/ 1.0 0.0))) ;-inf.0

(+ zero nan) ; +nan.0

(= nan +nan.0) ;#f

 

This values can be assigned to a variable just as normal values

{{Works with|rakudo|2018.03}}

Floating point limits are to a large extent implementation dependent, but currently both Raku backends (MoarVM, JVM) running on a 64 bit OS have an infinity threshold of just under 1.8e308.

positive infinity: {1.8e308}

negative infinity: {-1.8e308}

NaN == NaN = {NaN == NaN}

0.0 == -0.0 = {0e0 == -0e0}

 

<code>0e0</code> is used to have floating point number.

dictates that a minimum number of decimal digits be supported as well as a minimum number

of decimal digits in the exponent.

parse version v; say 'version=' v; say

zero= '0.0' /*a (positive) value for zero. */

p=!; !=! + j /*save number; bump mantissa. */

end /*forever*/

{{out|output|text= &nbsp; when using Regina REXX:}}

<pre>

 

=={{header|Ruby}}==

nan = 0.0 / 0.0 # or Float::NAN

 

expression.each do |exp|

puts "%15s => %p" % [exp, eval(exp)]

 

{{out}}

Negative zero needs to printed using the [https://doc.rust-lang.org/std/fmt/trait.Debug.html Debug trait] (rather than the "user-facing" [https://doc.rust-lang.org/std/fmt/trait.Display.html Display trait]) because <code>0 == -0</code> to most users. See https://github.com/rust-lang/rfcs/issues/1074 and https://github.com/rust-lang/rust/issues/24623 for further discussion about this.

 

let inf: f64 = 1. / 0.; // or std::f64::INFINITY

let minus_inf: f64 = -1. / 0.; // or std::f64::NEG_INFINITY

println!("NaN == NaN = {}", nan == nan);

println!("0.0 == -0.0 = {}", 0. == -0.);

{{out}}

<pre>

=={{header|S-lang}}==

Each of these can be directly input; I'll calc the Infs for good measure:

() = printf("%S", $1[0]);

if (length($1) > 1) () = printf("\t%S\n", eval($1[1]));

else () = printf("\n");

<pre>-0.0

inf inf

nan

</pre>

() = printf("-0.0 and 0.0 are %sequal\n", -0.0 == 0.0 ? "" : "not ");

() = printf("-_Inf == _Inf are %sequal\n", -_Inf == _Inf ? "" : "not ");

() = printf("-0.0 and 0.0 are %sthe 'same'\n", __is_same(-0.0, 0.0) ? "" : "not ");

<pre>-0.0 and 0.0 are equal

-_Inf == _Inf are not equal

=={{header|Scala}}==

{{libheader|Scala}}

val negInf = -1.0 / 0.0 //also Double.NegativeInfinity

val inf = 1.0 / 0.0 // //also Double.PositiveInfinity

println(f"0 * NaN: ${0 * nan}%9s ${(inf + negInf).isInfinity}%9s ${(inf + negInf).isWhole}%9s")

println(f"NaN == NaN: ${nan == nan}%9s")

{{out}}

<pre>Value: Result: Infinity? Whole?

 

=={{header|Scheme}}==

(define minus-infinity (- infinity))

(define zero 0.0)

(list +inf.0 -inf.0 0.0 -0.0 +nan.0))

; #t

 

=={{header|Seed7}}==

can be used. NaN can be checked with [http://seed7.sourceforge.net/libraries/float.htm#isNaN%28ref_float%29 isNaN].

 

include "float.s7i";

writeln("isNegativeZero(-0.0) = " <& isNegativeZero(-0.0));

writeln("isNegativeZero(0.0) = " <& isNegativeZero(0.0));

 

{{out}}

{{trans|Ruby}}

''NaN'' and ''Inf'' literals can be used to represent the ''Not-a-Number'' and ''Infinity'' values, which are returned in special cases, such as ''0/0'' and ''1/0''. However, one thing to notice, is that in Sidef there is no distinction between ''0.0'' and ''-0.0'' and can't be differentiated from each other.

var nan = 0/0 # same as: NaN

 

say("atan(Inf) = ", atan(inf))

say("log(-1) = ", log(-1))

{{out}}

<pre>

 

=={{header|Smalltalk}}==

FloatD nan

FloatE infinity

FloatD negativeInfinity

 

=={{header|Stata}}==

 

Stata does not use NaN values, but instead it has several kinds of missing values, which are denoted by . and .a to .z. These are stored as large floating point numbers, as can be seen in the hexadecimal representation:

 

+1.0000000000000X+3ff

 

 

. display %21x c(maxdouble)

 

Notice that .z > ... > .a > . and . is greater than any real number, and c(maxdouble) is the value 8.9884656743115785e+307.

 

=={{header|Swift}}==

let inf = 1.0 / 0.0 //also Double.infinity

let nan = 0.0 / 0.0 //also Double.NaN

println("inf + -inf: \(inf + negInf)")

println("0 * NaN: \(0 * nan)")

{{out}}

<pre>

(they are parsed case-insensitively).

For example, see this log of an interactive session:

8.5.2

% expr inf+1

domain error: argument not in valid range

% expr {1/-inf}

It ''is'' possible to introduce a real NaN though numeric computation,

but only by using the mechanisms for dealing with external binary data

(it being judged better to just deal with it in that case

rather than throwing an exception):

1

% puts $nan

% # Show that it is a real NaN in there

% expr {$nan+0}

 

=={{header|Wren}}==

var negZero = -0

System.print([inf, negInf, nan, negZero])

System.print([inf + inf, negInf + inf, nan * nan, negZero == 0])

System.print([inf/inf, negInf/2, nan + inf, negZero/0])

 

{{out}}

[infinity, nan, nan, true]

[nan, -infinity, nan, nan]

</pre>