Numeric separator syntax: Difference between revisions

 

Several programming languages allow separators in numerals in order to group digits together.

 

;Task:

 

<br><br>

 

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

In Algol 68, spaces are not significant in identifiers or numeric literals. This allows spaces to be used as numeric separators.

<br>Single or multiple spaces can be used as desired, it is not necessary to group the digits into blocks of three.

INT a = 1 234 567;

REAL b = 3 . 1 4159 26 5 359;

print( ( whole( a, 0 ), " ", fixed( b, - 14, 11 ), newline ) )

END

{{out}}

<pre>

1234567 3.14159265359

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f NUMERIC_SEPARATOR_SYNTAX.AWK

# converted from ALGOL 68

exit(0)

}

{{out}}

<pre>

 

=={{header|C}}==

#include <locale.h>

#include <stdio.h>

return 0;

}

Output :

<pre>

Locale : C, One Trillion : 1,000,000,000,000

</pre>

 

=={{header|Factor}}==

Factor allows the comma <code>,</code> as a separator character in number literals.

 

12,345 . ! 12345

 

! and complex numbers

 

If one desires to define a syntax for different separator rules, that is possible:

 

<< SYNTAX: PN: scan-token "_" without string>number suffix! ; >>

PN: _1_2_3_ . ! 123

PN: 1__234___567 . ! 1234567

 

Since Factor's parser is exposed, one could even make changes to the number parser, obviating the need for parsing words.

 

<<

>>

 

 

<!-- == Free Pascal == -->

{{omit from|Free Pascal}}

 

=={{header|Go}}==

 

Using the Raku examples plus a few more which Go allows:

 

import "fmt"

// none of these compile

// floats2 := []float64{_1234.25, 1234_.25, 1234._25, 1234.25_, 12__23.25}

 

{{out}}

Underscores have to be located within digits. The number of underscores and their position is not restricted.

 

 

public class NumericSeparatorSyntax {

 

}

 

{{out}}

Underscores allowed in floating point number: 0.0014400

Underscores allowed in floating point exponent: 0.0000144

</pre>

 

Commas are not allowed in numeric literals.

 

julia> 2_9

29

julia> 10__000__000

ERROR: UndefVarError: __000__000 not defined

 

=={{header|OCaml}}==

Underscores can be used as separators in integer or floating-point literals, and they are ignored. Underscores can be in any position except at the beginning, and you can use consecutive underscores.

Printf.printf "%d\n" 0b1_0_1_0_1;; (* 21 *)

Printf.printf "%d\n" 0xa_bc_d;; (* 43981 *)

Printf.printf "%f\n" 1234_.25;; (* 1234.250000 *)

Printf.printf "%f\n" 1234._25;; (* 1234.250000 *)

 

=={{header|Perl}}==

Perl allows underscore as a grouping / separator character in numeric inputs, as long as you use it between digits, and you do not use two underscores in a row:

print 1_2_3, "\n"; # 123

 

 

# Num

 

=={{header|Phix}}==

Phix simply ignores underscores in numeric literals, however a leading underscore signifies a normal identifier, much like a123 or tmp2.<br>

Commas are not allowed in numeric literals, since they delimit sequence elements, routine parameters, and such like, for example {1,2,3,4}.

 

=={{header|Python}}==

 

* E.g. 100_000_000_000, 0x_dead_beef, 3.14_15_93

 

=={{header|Racket}}==

Vanilla Racket does not have numeric separator syntax. However, it can be defined by users. A quick solution is to use <code>#%top</code>:

 

 

(require syntax/parse/define

 

1_234_567.89

 

{{out}}

If we wish to, for example, disallow multiple consecutive separators like <code>1_234__567.89</code>, we could do so easily:

 

 

(require syntax/parse/define

 

1_234_567.89

 

{{out}}

Raku allows underscore as a grouping / separator character in numeric inputs, though there are a few restrictions.

# May occur in nearly any position, in any* number. * See restrictions below.

 

# say 1234._25;

# say 1234.25_;

 

=={{header|REXX}}==

 

There is a way to work around such that blanks or commas could be used within a REXX program with a bit of coding:

pi= 3 . 14159_26535_89793_23846_26433_83279_50288_41971_69399_37510_58209_74945

 

─── where the last REXX statement will translate (change) any number of separator characters into blanks, &nbsp; and

''"The digits of a numeric literal may be separated by arbitrarily many underscores for purposes of legibility."''

Let's see how its work in a Scala REPL session:

Type in expressions for evaluation. Or try :help.

 

res5: Double = 1234.25

 

 

=={{header|Sidef}}==

Sidef allows underscores as a separator character in numeric inputs.

say 1_2_3; # 123

 

say 1234.25_; # 1234.25

say 12__34.25; # 1234.25

 

=={{header|XPL0}}==

program are also ignored.

 

[IntOut(0, Meg); CrLf(0);

RlOut(0, 123__45.67_89_); CrLf(0);

HexOut(0, %1010_1011_1100_1101_1110_1111_0000_0001); CrLf(0);

IntOut(0, IntIn(0));

 

{{out}}

{{libheader|Wren-fmt}}

Consistent with its C heritage, Wren doesn't support any form of separator in numeric literals.

 

As currently written, this just supports separation of decimal integers into 3 digit groups from the right though it could be extended to deal with other scenarios as well.

 

var nums = [1e6, 1e9, 123456789, -123456789012]

var seps = [",", ".", " ", "*"]

 

{{out}}

 

=={{header|zkl}}==

and completely ignores them:

1_000 == 1_000_ == 1_0_0_0 == 1__________000

1_2.3_4 == 12.34

%f (float: ","), %x (hex: "|") and %2B (binary: "|").

"%,d %,.0f %,x %,.2B".fmt(1234, 1234.0, 0x1234, 0x1234).println();

--> "1,234 1,234 12|34 1|0010|0011|0100"

Each objects toString method has optional parameters to specify a separator