Extreme floating point values: Difference between revisions

The IEEE floating point specification defines certain 'extreme' floating point values such as minus zero, -0.0, a value distinct from plus zero; not a number, NaN; and plus and minus infinity.

 

 

 

=={{header|Ada}}==

 

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;

<pre>

-oo = -Inf*******

 

=={{header|AWK}}==

 

 

{{works with|nawk|20100523}}

# This requires 1e400 to overflow to infinity.

nzero = -0

pinf = 1e400

ninf = -1e400

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

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

 

----

 

<pre>$ awk -f extreme.awk

nan == 42? yes</pre>

 

 

----

 

<pre>nzero = 0

The attempts to use negative zero have failed. GNU awk uses both integers and floating point; GNU awk converted negative zero to an integer and lost the negative sign.

 

 

=={{header|bc}}==

 

bc also has no negative zero, and no NaN.

 

=={{header|C}}==

{{works with|gcc|4.4.3}}

 

int main()

 

return 0;

 

<pre>positive infinity: inf

negative infinity: -inf

0.0 == -0.0 = true</pre>

 

<pre>positive infinity: 1.#INF00

negative infinity: -1.#INF00

0.0 == -0.0 = true</pre>

 

 

}

 

 

 

 

 

 

 

 

}

 

 

 

 

 

 

 

writeln("-----------------------------");

 

writeln(getNaNPayload(f1));

writeln(getNaNPayload(f2));

writeln(getNaNPayload(f3));

<pre>Computed extreme float values:

float +oo = inf

real min_normal = -3.3621e-4932

-----------------------------

4194303

1125899906842623

4610560118520545279</pre>

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

 

void main() {

FloatingPointControl fpc;

fpc.enableExceptions(FloatingPointControl.severeExceptions);

double f0 = 0.0;

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

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

 

Tested on Delphi 2009:

 

 

{$APPTYPE CONSOLE}

 

Readln;

 

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

 

positive infinity: inf

negative infinity: -inf

NaN + 1.0 = -nan

NaN + NaN = -nan

 

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

 

import (

func main() {

// compute "extreme values" from non-extreme values

var zero float64 // zero is handy.

var negZero, posInf, negInf, nan float64 // values to compute.

// mod is specifically named in "What every computer scientist..."

// Go math package doc lists many special cases for other package functions.

validateNaN(1+nan, "1 + NaN")

validateZero(1/posInf, "1 / Inf")

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

}

<pre>

-0 +Inf -Inf NaN

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

 

<pre> Negative inf: -Infinity

Positive inf: Infinity

NaN equals NaN: true</pre>

 

 

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

 

 

=={{header|J}}==

 

'''Extreme values'''

NegInf=: __

 

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

}

<pre>Negative inf: -Infinity

Positive inf: Infinity

0 * NaN: NaN

NaN == NaN: false</pre>

=={{header|MUMPS}}==

===ANSI MUMPS===

<pre>USER>write 3e145

30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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

Infinity: INF

Infinity is not a number

Not a Number: NAN

Not a Number is not a number</pre>

 

=={{header|OCaml}}==

- : float = infinity

# neg_infinity;;

- : bool = true

# 0. == -0.;;

 

=={{header|Oz}}==

Inf = 1.0e234 * 1.0e234

MinusInf = 1.0e234 * ~1.0e234

 

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

 

-infinite: -1.#INF

0: 0.0

true

true

 

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

 

PARI t_REAL numbers have a maximum value of

| 694,127,911,065,419,642 decimal digits

|}

 

=={{header|Perl}}==

 

use strict;

use warnings;

my $ninf = -"inf";

 

print "\$nan = $nan\n";

print "\$pinf = $pinf\n";

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

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

 

$nan = nan

$pinf = inf

----

 

 

use strict;

use warnings;

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

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

 

$pinf = inf

$ninf = -inf

$nan == $nan? no

$nan == $huge? no</pre>

 

=={{header|PicoLisp}}==

 

: (exp 1000.0) # Too large for IEEE floats

 

: (+ 1 2 NIL 3) # NaN propagates

 

=={{header|PureBasic}}==

If OpenConsole()

minus_zero = -1/inf

PrintN("positive infinity: "+StrF(inf))

PrintN("negative infinity: "+StrF(minus_inf))

PrintN("NaN + NaN = "+StrF(nan + nan))

PrintN("Logics")

If IsNAN(nan): PrintN("Variable 'nan' is not a number"): EndIf

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

<pre>positive infinity: +Infinity

negative infinity: -Infinity

NaN + NaN = -1.#IND000000

Logics

Variable 'nan' is not a number

 

 

=={{header|Python}}==

>>> inf = 1e234 * 1e234

>>> _inf = 1e234 * -1e234

nan

>>> inf * 0.0

 

>>> 1 / -0.0

 

1 / -0.0

ZeroDivisionError: float division by zero

 

=={{header|Tcl}}==

8.5.2

% expr inf+1

domain error: argument not in valid range

% expr {1/-inf}

1

% puts $nan

% # Show that it is a real NaN in there

% expr {$nan+0}