Literals/Floating point: Difference between revisions

 

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

2.3

0.3e+34

// single precision (32-bit) floating point literals:

2.3s

 

=={{header|360 Assembly}}==

[[wp:IBM_hexadecimal_floating_point|IBM hexadecimal floating point]]

XDPI DC D'3.141592653589793' long floating-point

* extended floating-point - 128 bits - 16 bytes : 33 decimal digits

 

 

=={{header|6502 Assembly}}==

You'll have to do it the hard way unfortunately. I used an IEEE-754 floating point calculator to figure this out.

 

=={{header|68000 Assembly}}==

If you don't have a floating-point unit, floats aren't of very much use. The most portable way to declare float literals is also the most tedious: by storing their hexadecimal representation as data.

 

=={{header|Ada}}==

Real literals contain decimal point. The exponent part is optional. Underline may be used to separate groups of digits. A literal does not have sign, + or - are unary operations. Examples of real literals:

3.141_592_6

1.0E-12

0.13

 

=={{header|Aime}}==

5.0

8r # without the "r"(eal) suffix, "8" would be an integer

 

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

# They have the following forms: #

# 1: a digit sequence followed by "." followed by a digit sequence #

r := 3.142e-23;

r := 1 234 567 . 9 e - 4;

 

=={{header|ALGOL W}}==

real r; long real lr;

% floating point literals have the following forms: %

r := 7;

lr := 5.4321L;

 

=={{header|Applesoft BASIC}}==

 

=={{header|Arturo}}==

 

{{out}}

With the One True Awk ([[nawk]]), all numbers are floating-point. A numeric literal consists of one or more digits '0-9', with an optional decimal point '.', followed by an optional exponent. The exponent is a letter 'E' or 'e', then an optional '+' or '-' sign, then one or more digits '0-9'.

 

2.

.3

45e+6

78e-9

 

Other implementations of Awk can differ. They might not use floating-point numbers for integers.

This Awk program will detect whether each line of input contains a valid integer.

 

print $0 " is a literal number."

next

{

print $0 " is not valid."

 

A leading plus or minus sign (as in <tt>+23</tt> or <tt>-14</tt>) is not part of the literal; it is a unary operator. This is easy to check if you know that exponentiation has a higher precedence than unary minus; <tt>-14 ** 2</tt> acts like <tt>-(14 ** 2)</tt>, not like <tt>(-14) ** 2</tt>.

=={{header|Axe}}==

Axe does not support floating point literals. However, it does support converting floats to integers and vice versa.

 

Axe does, however, support fixed-point literals.

 

There are some mathematical operators in Axe that operate specifically on fixed-point numbers.

 

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

REM [-]{digit}[.]{digit}[E[-]{digit}]

PRINT 8.9E

PRINT .33E-

'''Output:'''

<pre>

=={{header|C sharp}}==

Floating point suffixes are not case-sensitive.

d = 1d;

d = 1D;

m = 12e-12m;

m = 12E-12m;

 

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

 

int main()

std::cout << "\nfloat3: " << float3;

std::cout << "\n";

{{out}}

<pre>

Dyalect built-in types include only one floating point number of type ''Float'' (64-bit). Both regular and scientific notations are supported:

 

 

EBNF grammar for the floating point number is as follows:

Floating point literals are of the form D.DeSD, where D represents a sequence of decimal digits, and S represents an optional sign. A leading "+" or "-" indicates a unary plus or minus feature and is not considered part of the literal.

 

1.

1.23

.5

1.23E4

 

=={{header|Elena}}==

r := 23.2r;

 

=={{header|Elixir}}==

0.123

iex(181)> -123.4

 

iex(187)> 1e4

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

printf(1,"Exponential:\t%e, %e, %e, %e\n",{-10.1246,10.2356,16.123456789,64.12})

printf(1,"Floating Point\t%03.3f, %04.3f, %+3.3f, %3.3f\n",{-10.1246,10.2356,16.123456789,64.12})

printf(1,"Floating Point or Exponential: %g, %g, %g, %g\n",{10,16.123456789,64,123456789.123})

{{out}}

<pre>

 

=={{header|Factor}}==

+3.14 ! Optional signs

-3.14

! normalized hex form ±0x1.MMMMMMMMMMMMMp±EEEE allows any floating-point

! number to be specified precisely according to IEEE 754 representation

 

=={{header|Fennel}}==

3.14159 ;3.14159

 

;;Underscores can optionally be used to split numbers into readable chunks.

123_456.789 ;123456.789

 

=={{header|Forth}}==

Some examples, taken from the language documentation follow:

 

 

Dim a As Double = 123.456

Dim j As Single = -123.456e-7f

Dim k As Double = 0#

 

=={{header|GAP}}==

 

22.03e4

 

=={{header|gecho}}==

0.0

-1

-1.4324

3 4 /

 

=={{header|Go}}==

=={{header|Groovy}}==

Solution:

println 1.00d // double (IEEE-64)

println 1.00 // BigDecimal (scaled BigInteger)

assert 1.00 instanceof BigDecimal

assert 1.00g instanceof BigDecimal

 

{{out}}

Haskell supports decimal representation of float literals, with or without an exponent. For more information, see the [http://www.haskell.org/onlinereport/lexemes.html#sect2.5 relevant portion] of the Haskell 98 Report.

 

 

Output:

 

The program below shows a full range of valid real literals.

every write( ![ 1., .1, 0.1, 2e10, 2E10, 3e-1, .4e2, 1.41e2, 8.e+3, 3.141e43 ])

 

The function write will cause the real values to be coerced as string constants. Icon/Unicon will format these as it sees fit resorting to exponent forms only where needed.

Here is an informal bnf for J's numeric constant language. Note, however, that the implementation may disallow some unusual cases -- cases which are not treated as exceptional here (for example, the [http://jsoftware.com/help/dictionary/dcons.htm language specification] allows 1.2e3.4 but the current implementation does not support fractional powers of 10 in numeric constants):

 

whitespace ::= whitespacecharacter | whitespacecharacter whitespace

whitespacecharacter ::= ' ' | TAB

signed-digits ::= digits | '_' digits

digits ::= digit | digit digits

 

e indicates exponential or scientific notation (number on left multiplied by 10 raised to power indicated by number on right)

Floating point examples:

 

0 1 _2 3.4 30000 292.227 163.794

16bcafe.babe _16b_cafe.babe _10b11

 

Note that all the values in an array are the same type, thus the 0, 1 and 2 in the above example are floating point because they do not appear by themselves. Note also that by default J displays no more than six significant digits of floating point values.

 

=={{header|Java}}==

1.0 //double

2432311.7567374 //double

1.0F //float

1 / 2. //double

Values that are outside the bounds of a type will give compiler errors when trying to force them to that type.

 

=={{header|jq}}==

jq floating point literals are identical to JSON floating point literals. However, when jq parses a floating point or integer literal, conversion to IEEE 754 numbers takes place, which may result in a loss of accuracy and/or an apparent change of type, as illustrated by the following sequence of input => output pairs:

1.2 => 1.2

1e10 => 10000000000

1e1234 => 1.7976931348623157e+308

.1 => 0.1

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

.1

1.

1e+10

1e-10

 

=={{header|Kotlin}}==

val d2: Double = 1.234e-10

val f: Float = 728832f

 

=={{header|Lasso}}==

0.1

-0.1

1.2e3

1.3e+3

 

=={{header|Lingo}}==

-- 0.2300

 

-- casting string to float

put float("0.23")

 

=={{header|Lua}}==

 

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

We can use Decimal using @ and Currency using # (no exponent part, both types)

 

Def ExpType$(x)=Type$(x)

Print ExpType$(-12)="Double", -12

Print ExpType$(12.e-5~)="Single", 12.e-5~

Print ExpType$(.1~)="Single", .1~

 

=={{header|Maple}}==

Maple distinguishes "software floats" (of arbitrary precision) and "hardware floats" (of machine precision). To get the latter, use the "HFloat" constructor.

> 123.456; # decimal notation

123.456

> Float(undefined); # "NaN", not-a-number

Float(undefined)

Whether a given float is a software or hardware float can be determined by using "type".

> type( 2.3, 'hfloat' );

false

> type( HFloat( 2.3 ), 'hfloat' );

true

(There is also a type "sfloat" for software floats, and the type "float", which covers both.)

 

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

{6.7^-4,6.7^6,6.7^8}

{0.00049625,90458.4,4.06068*10^6}

In accounting form, negative numbers are given in parentheses, and scientific notation is never used.

AccountingForm[{5.6,-6.7,10.^7}]

 

=={{header|Maxima}}==

arbitrary length "big floats" */

 

 

bfloat(%pi);

=={{header|MIPS Assembly}}==

Ultimately it depends on the assembler, however, it's standard to allow simple expressions like "2.5". Since MIPS uses a floating-point coprocessor with separate registers, the assembler understands that you're trying to load a float into the register rather than an integer, and so the assembler will calculate the IEEE-754 hexadecimal representation for you.

 

 

Defining literal float data in your code also depends on the assembler. If all else fails, you can use a calculator to get the IEEE-754 hexadecimal representation of the desired float and store it as an "integer."

 

lwc1 $f0,0($t0) ;load pi into $f0

 

 

pi:

 

=={{header|Nemerle}}==

it's built in ''Rexx'' object and any other Java object that supports floating point numbers.

 

options replace format comments java crossref symbols nobinary

 

method normalize(fv) private constant

return fv + 0

'''Output:'''

<pre>

 

=={{header|Nim}}==

x = 2.3

x = 2.0

var y = 2'f32 # Automatically a float32

var z = 2'f64 # Automatically a float64

 

=={{header|Objeck}}==

3 + .14159

3.14159

314.159E-2

 

=={{header|OCaml}}==

Here are some examples:

 

1.0

1. (* it is not possible to write only "1" because OCaml is strongly typed,

and this would be interpreted as an integer *)

1e-10

 

=={{header|Oforth}}==

A literal floating point number is written with a . and with or without an exponential notation :

 

1.0e-12

0.13

1000.0

 

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

 

=={{header|Perl}}==

.5;

0.5;

# The numbers can be grouped:

100_000_000; # equals to 100000000

 

=={{header|Phix}}==

and on a 64-bit architecture they can range from approximately -1e4932 to +1e4932 with 19 decimal digits.<br>

The included bigatom library allows working with extremely large integers and floats with arbitrary precision. In the following, '?x' is the Phix shorthand for 'print(1,x)', plus \n

<span style="color: #0000FF;">?</span><span style="color: #000000;">1e+12</span> <span style="color: #000080;font-style:italic;">-- (same as 1e12)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">1e-12</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">1</span><span style="color: #0000FF;">/</span><span style="color: #000000;">3</span> <span style="color: #000080;font-style:italic;">-- 0.333333</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%g %G\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1e-30</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|PHP}}==

More [http://php.net/manual/en/language.types.float.php information] about floating point numbers in PHP.

0.1234

1.2e3

7E-10

Formal representation:

<pre>

 

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

1.2345e-4 decimal floating-point

7e5 decimal floating-point

or 7.3125 * 2**7

1e5b binary floating-point equals 1 * 2**5

 

=={{header|PureBasic}}==

This is an excerpt of an ANTLR grammar for python obtained from [http://www.antlr.org/grammar/1200715779785/Python.g here].

 

: '.' DIGITS (Exponent)?

| DIGITS '.' Exponent

Exponent

: ('e' | 'E') ( '+' | '-' )? DIGITS

 

Examples

2.3 # 2.2999999999999998

.3 # 0.29999999999999999

.3e-34 # 2.9999999999999999e-35

2.e34 # 1.9999999999999999e+34

 

=={{header|Racket}}==

 

#lang racket

.2

2.0f0 ; single float

1.0t0 ; extended 80-bit float (when available on platform)

 

Output:

(formerly Perl 6)

Floating point numbers (the Num type) are written in the standard 'e' scientific notation:

6.02e23

-2e48

1e-9

 

A number like <tt>3.1416</tt> is specifically not floating point, but rational (the Rat type), equivalent to <tt>3927/1250</tt>. On the other hand, <tt>Num(3.1416)</tt> would be considered a floating literal though by virtue of mandatory constant folding.

=={{header|REXX}}==

All values in REXX are character strings, &nbsp; so a value could hold such things as these (decimal) numbers:

something = '127' /*exactly the same as the above. */

something = 1.27e2

something = 1.27E2

something = 1.27E+2

To forcibly express a value in exponential notation, &nbsp; REXX has a built-in function &nbsp; '''format''' &nbsp; that can be used.

 

</pre>

by the &nbsp; '''format''' &nbsp; BIF.

say something

'''output'''

<pre>

=={{header|Rust}}==

The fractional part may be elided (so 1. is valid) but the integer part may not (so .0 is not valid).

3. // Equivalent to 3.0 (3 would be interpreted as an integer)

2f64 // The type (in this case f64, a 64-bit floating point number) may be appended to the value

 

=={{header|Scala}}==

{{libheader|Scala}}

As all values in Scala, values are boxed with wrapper classes. The compiler will unbox them to primitive types for run-time execution.

1.0 //Double, a 64-bit IEEE-754 floating point number (equivalent to Java's double primitive type)

2432311.7567374 //Double

Double.PositiveInfinity

Double.NegativeInfinity

Values that are outside the bounds of a type will give compiler-time errors when trying to force them to that type.

 

=={{header|Scheme}}==

.2 ; 0.2

2. ; 2.0

; #t

(inexact? 2)

 

=={{header|Seed7}}==

The type [http://seed7.sourceforge.net/libraries/float.htm float] consists of single precision floating point numbers. Float literals are base 10 and contain a decimal point. There must be at least one digit before and after the decimal point. An exponent part, which is introduced with E or e, is optional. The exponent can be signed, but the mantissa is not. A literal does not have a sign, + or - are unary operations. Examples of float literals are:

3.14159265358979

1.0E-12

0.1234

The functions [http://seed7.sourceforge.net/libraries/float.htm#str%28ref_float%29 str] and the operators [http://seed7.sourceforge.net/libraries/float.htm#%28ref_float%29digits%28ref_integer%29 digits] and [http://seed7.sourceforge.net/libraries/float.htm#%28attr_float%29parse%28in_string%29 parse] create and accept float literals with sign.

 

 

=={{header|Sidef}}==

say .1234;

say 1234e-5;

{{out}}

<pre>1.234

 

=={{header|Smalltalk}}==

45e6

45e+6

78e-9

 

base 2 mantissa:

2r0.01 -> 0.25

 

base 2 mantissa and base 2 exponent:

 

Complex numbers:

 

=={{header|Stata}}==

 

Examples:

1.5

-1.5e10

 

=={{header|Swift}}==

let float = 1.0 as Float // Single precision

let scientific = 1.0E-12

 

let div = 1.1 / 2 // Double

 

=={{header|Tcl}}==

=={{header|Ursa}}==

Cygnus/X Ursa (the standard Ursa interpreter) is written in Java and supports Java style floating-point literals.

1.0

2432311.7567374

758832D

728832F

 

=={{header|Verbexx}}==

//

// If present,the exponent must be of the form:

// Underscores can also appear in the exponent, after the first digit:

 

 

=={{header|Vim Script}}==

{{works with|VBA|6.5}}

{{works with|VBA|7.1}}

Dim d As Double ' 8 Bytes, type specifier = #

Dim s As Single ' 4 Bytes, type specifier = !

s = 0!

s = 2! * 10 ^ 3

There is no built-in support for not-a-number, but here's a way to handle that anyway:

Public Declare Function RtlCompareMemory Lib "ntdll.dll" _

(ByRef Source1 As Any, ByRef Source2 As Any, ByVal Length As Long) As Long

Debug.Assert IsNAN(d2)

Debug.Print CStr(d2)

{{out}}

<pre>-1,#IND</pre>

 

All numbers are instances of the built-in Num class which is always 8 bytes in size. Integers are really just floating point numbers which have no decimal part.

var g = 0.12345 // .12345 not allowed

var h = 1.234e2

var i = -0.0

 

{{out}}

 

=={{header|XPL0}}==

.1

1e3

123.456E-300

 

=={{header|Z80 Assembly}}==

You'll have to do it the hard way unfortunately. I used an IEEE-754 floating point calculator to figure this out.

The Z80 doesn't natively have any commands for floats, so you'll have to do it yourself.

 

=={{header|zkl}}==

zkl requires something on both sides of the dot for a thing to be a float