Literals/Integer: Difference between revisions

 

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

print(0000'00FF) // hexadecimal literal

print(00'FF) // short hexadecimal literal

print(377o) // octal literal

print(1111'1111b) // binary literal

 

{{out}}

</pre>

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

LDA #$41

LDA #65

LDA #%01000001

 

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

MOVE.B #$41,D0

MOVE.B #65,D0

MOVE.B #%01000001,D0

 

=={{header|AArch64 Assembly}}==

 

{{works with|aarch64-linux-gnu-as/qemu-aarch64}}

.equ SVC_WRITE, 64

.equ SVC_EXIT, 93

_exit:

mov x8, #SVC_EXIT

 

=={{header|Ada}}==

Here <base> can be from the range 2..16.

For example:

 

procedure Test_Literals is

Put (8#1_327#);

Put (2#10_1101_0111#);

{{out}}

<pre>

 

=={{header|Aime}}==

o_text("true\n");

} else {

o_text("false\n");

 

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

Binary literals are of type BITS, and need to be converted

to INT using the operator ABS.

SHORT SHORT INT ssdec = SHORT SHORT 727,

END CO

 

[http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download algol68g] output:

<pre>

Algol W has only decimal integer literals. Hexadecimal values can be written (prefixed with #) but these are of type "bits" and the

standard number function must be used to "convert" them to an integer.

write( 16, number( #10 ) )

{{out}}

<pre>

 

=={{header|AmigaE}}==

IF ($2d7 = 727) AND (%001011010111 = 727) THEN WriteF('true\n')

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program integer.s */

 

 

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|AutoHotkey}}==

 

=={{header|Avail}}==

Avail's built-in lexers recognize "traditional" binary, octal, and hexadecimal prefixes <code>0b</code>, <code>0o</code>, and <code>0x</code> respectively:

Print: "0o755 = " ++ “0o755”;

Arbitrary integer bases from 2 to 36 are supported with the format ''digits r base''. As additional digit characters are needed, they are taken from the latin alphabet in order.

While the task limits examples to those understood by the compiler and "not involve the calling of any functions/methods", the line is not so clear cut in Avail. For example, one could define new lexers to understand new integer formats which are then accepted by the compiler, allowing for an unlimited array of integer literal kinds.

 

 

{{works with|gawk|3.1.7}}

if ( (0x2d7 == 727) &&

(01327 == 727) ) {

print "true with GNU awk"

}

 

nawk parses <tt>01327</tt> as <tt>1327</tt>, and parses <tt>0x2d7</tt> as <tt>0 x2d7</tt> (which is the string concatentation of <tt>"0"</tt> and variable <tt>x2d7</tt>).

 

x2d7 = "Goodbye, world!"

print 0x2d7 # gawk prints "727", nawk prints "0Goodbye, world!"

print 01327 # gawk prints "727", nawk prints "1327"

 

=={{header|Axe}}==

In addition to decimal integer literals, Axe supports hexadecimal and binary integers using a leading exponent operator or pi, respectively. Note that the leading E below is the small-caps E.

ᴇFACE

 

=={{header|BASIC}}==

&O = octal; &H = hexadecimal. Some flavors of BASIC also support &B = binary, but they're somewhat rare.

 

PRINT &O21

Output:

<pre>17

==={{header|BaCon}}===

BaCon allows (as it converts to C) C style integer literals. zero prefix Octal, 0x prefix Hexadecimal, no prefix Decimal, and if supported by the underlying compiler, 0b prefix for Binary. 0x and 0b can be upper case 0X and 0B.

PRINT 10

PRINT 010

PRINT 0x10

' C compiler dependent, GCC extension

 

{{out}}

16

2</pre>

 

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

PRINT &4D2 : REM Hexadecimal

'''Output:'''

<pre>

 

==={{header|IS-BASIC}}===

PRINT BIN(10001)

 

=={{header|bc}}==

This example shows the literal -727 in all bases from 2 to 16. (It never prints "Impossible!")

 

b[10] = -1011010111

ibase = 11 /* 3 */

for (i = 2; i <= 16; i++) if (b[i] != -727) "Impossible!

"

 

The digits 0-9 and A-F are valid with all input bases. For example, FF from base 2 is 45 (because 15 * 2 + 15 is 45), and FF from base 10 is 165 (because 15 * 10 + 15 is 45). Most importantly, <tt>ibase = A</tt> always switches to base ten.

While Befunge doesn't directly support numbers aside from 0-9 (base 10), characters in strings are essentially treated as base-256 numbers.

 

 

Output:

126 32

 

=={{header|Bracmat}}==

Leading 0 means octal, 0x or 0X means hexadecimal. Otherwise, it is just decimal.

 

 

int main(void)

 

return 0;

 

GCC supports specifying integers in binary using the [http://gcc.gnu.org/onlinedocs/gcc/Binary-constants.html 0b prefix] syntax, but it's not standard. Standard C has no way of specifying integers in binary.

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

C# has decimal and hexadecimal integer literals, the latter of which are prefixed with <code>0x</code>:

Literals of either form can be suffixed with <code>U</code> and/or <code>L</code>. <code>U</code> will cause the literal to be interpreted as an unsigned type (necessary for numbers exceeding 2³¹ or hex literals that have a first digit larger than <code>7</code>) and <code>L</code> signifies the use of a <code>long</code> type – using <code>UL</code> or <code>LU</code> as suffix will then use <code>ulong</code>. C# has no syntactic notion of expressing integer literals of smaller types than <code>Int32</code>; it is a compile-time error to have an assignment such as

'''Update'''<br/>

As of C#7, integer literals can be written in binary with the prefix <code>0b</code>. Furthermore, underscores can be used as separators:

int x = 0b1100_1001_1111_0000;

 

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

The same comments apply as to the [[#C|C example]].

 

 

int main()

return 0;

 

=={{header|Clojure}}==

Clojure uses the Java octal (0...) and hexadecimal (0x...) notation; for any other base, nR... is used, 2 <= n <= 36.

 

9

user=> 8r64

user=> 0x4b

75

 

=={{header|COBOL}}==

</pre>

 

display B#10 ", " O#01234567 ", " -0123456789 ", "

H#0123456789ABCDEF ", " X#0123456789ABCDEF ", " 1;2;3;4

 

{{out}}

Some characters are removed by the COBOL text manipulation facility, and are allowed in numeric literals. These symbols are stripped out, along with comment lines, before seen by the compiler proper.

 

if 1234 = 1,2,3,4 then display "Decimal point is not comma" end-if

if 1234 = 1;2;3;4 then display "literals are equal, semi-colons ignored" end-if

 

Comma is a special case, as COBOL can be compiled with <code>DECIMAL POINT IS COMMA</code> in the <code>CONFIGURATION SECTION</code>. The <tt>1,2,3,4</tt> comparison test above would cause a compile time syntax error when <code>DECIMAL POINT IS COMMA</code> is in effect.

 

=={{header|Comal}}==

IF 37=%00100101 THEN PRINT "True"

 

=={{header|Common Lisp}}==

 

binary: #b, octal: #o, hexadecimal: #x, any base from 2 to 36: #Nr

T

>(= 727 #o1327)

T

>(= 727 #20r1g7)

 

=={{header|D}}==

 

D besides hexadecimal, has also binary base. Additionally you can use '''_''' to separate digits in integer (and FP) literals. Octal number literals are library-based to avoid bugs caused by the leading zero.

 

void main() {

 

writefln("%x", 0xFEE1_BAD_CAFE_BABEuL);

{{out}}

<pre>oct: 511

 

=={{header|DCL}}==

$ decimal2 = %D123490

$ octal = %O12370

 

=={{header|Delphi}}==

DEC_VALUE = 256; // decimal notation

HEX_VALUE = $100; // hexadecimal notation

BIN_VALUE = %100000000; // binary notation (since Delphi 10.4 version)

 

=={{header|DWScript}}==

 

DWScript has decimal and hexadecimal integer literals, the latter of which are prefixed with <code>$</code>:

Both notations can also be used for character codes (when prefixed by <code>#</code>).

 

Dyalect has decimal and hexadecimal integer literals, the latter of which are prefixed with 0x:

 

 

=={{header|Dylan}}==

#x2A // a hexadecimal integer

#o52 // an octal integer

 

=={{header|E}}==

 

# value: 256

 

 

? 0123

 

=={{header|Efene}}==

 

run = fn () {

io.format("0xff : ~B~n", [0xff])

io.format("0b1011: ~B~n", [0b1011])

}

 

=={{header|Eiffel}}==

123 -- decimal

-1_2_3 -- decimal

0c173 -- octal

0b111_1011 -- binary

 

{NATURAL_8} 255

{INTEGER_64} 2_147_483_648

 

=={{header|Elena}}==

var n := 1234; // decimal number

var x := 1234h; // hexadecimal number

 

=={{header|Elixir}}==

1_000_000 #=> 1000000

0010 #=> 10

0B10 #=> syntax error before: B10

0X10 #=> syntax error before: X10

 

=={{header|Emacs Lisp}}==

#b101 ;; binary Emacs 21 up, XEmacs 21

#o77 ;; octal Emacs 21 up, XEmacs 21

#xFF ;; hex Emacs 21 up, XEmacs 21

 

The digits and the radix character can both be any mixture of upper and lower case. See [http://www.gnu.org/software/emacs/manual/html_node/elisp/Integer-Basics.html GNU Elisp reference manual "Integer Basics"].

 

=={{header|Erlang}}==

Erlang allows integer literals in bases 2 through 36. The format is Base#Number. For bases greater than 10, the values 10-35 are represented by A-Z or a-z.

> 2#101.

5

> 36#3z.

143

 

=={{header|ERRE}}==

% = binary, & = octal; $ = hexadecimal.

PRINT(17)

PRINT(&21)

PRINT($11)

PRINT(%1001)

Output:

<pre>

 

=={{header|Euphoria}}==

printf(1,"Decimal:\t%d, %d, %d, %d\n",{-10,10,16,64})

printf(1,"Hex:\t%x, %x, %x, %x\n",{-10,10,16,64})

printf(1,"Floating Point\t%3.3f, %3.3f, %+3.3f\n",{-10,10.2,16.25,64.12625})

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

{{out}}

<pre>

===Base prefixes===

Binary numbers begin with 0b, octal numbers with 0o, and hexadecimal numbers with 0x. The hexadecimal digits A-F may be in any case.

0o12 // = 10

 

===Type suffixes===

Most type suffixes can be preceded with a 'u', which indicates the type is unisgned.

'g'B // Character literals can be turned into unsigned 8-bit literals

10s // 16-bit

10I // Bigint (cannot be preceded by a 'u')

 

 

=={{header|Factor}}==

0b10 . ! binary

-0o10 . ! octal

{{out}}

<pre>

</pre>

Factor also supports the arbitrary use of commas in integer literals:

{{out}}

<pre>

1234567

</pre>

 

=={{header|Forth}}==

The standard method for entering numbers of a particular base is to set the user variable BASE to the desired radix from 2 to 36. There are also convenience words for setting the base to DECIMAL and HEX.

FEEDFACE

2 BASE !

DECIMAL

1234

The Forth numeric parser will look for symbols embedded within the stream of digits to determine whether to interpret it as a single cell, double cell, or floating point literal ('e').

123.4 ( l h )

 

===Base prefixes===

{{works with|GNU Forth}}

In addition, many Forths have extensions for using a prefix to temporarily override BASE when entering an integer literal. These are the prefixes supported by GNU Forth.

&1234 \ decimal

%1001101 \ binary

Some Forths also support "0xABCD" hex literals for compatibility with C-like languages.

 

=={{header|Fortran}}==

 

 

implicit none

print *, dec, hex, oct, bin

 

 

Outputs:

 

=={{header|FreeBASIC}}==

 

' The following all print 64 to the console

Print 64ULL '' Decimal unsigned 8 byte integer (ULongInt)

 

 

=={{header|Frink}}==

Bases from 2 to 36 are allowed in Frink. All literals can be arbitrarily large. Frink does not subscribe to the insanity that a leading 0 implies octal.

123456789123456789 // (a number in base 10)

123_456_789_123_456_789 // (the same number in base 10 with underscores for readability)

0b100001000101111111101101 // (Common binary notation)

0b1000_0100_0101_1111_1110_1101 // (Binary with underscores for readability)

 

=={{header|FutureBasic}}==

 

 

Output:

<pre>

</pre>

 

=={{header|GAP}}==

 

31415926

 

=={{header|Go}}==

Constant expressions are evaluated at compile time at an arbitrary precision.

It is only when a constant is assigned to a variable that it is given a type and an error produced if the constant value cannot be represented as a value of the respective type.

 

import "fmt"

fmt.Println(727 == '˗') // prints true

}

 

=={{header|Groovy}}==

Solution:

println 25 // decimal integer

println 25l // decimal long

println 25g // decimal BigInteger

 

Output:

=={{header|Harbour}}==

Hexademical integer literals are supported - the leading symbols must be 0x or 0X:

Output:

<pre>31</pre>

 

Oct(leading 0o or 0O), Hex(leading 0x or 0X)

True

Prelude> 727 == 0x2d7

 

=={{header|hexiscript}}==

println 15

println 000015 # Leading zeros are ignored

println 0b1111

println 0o17

 

=={{header|HicEst}}==

HolyC supports various integer sizes.

 

U16 i; // 16 bit integer

U32 i; // 32 bit integer

 

By default all integers are decimal. Leading "0x" implies hexadecimal.

 

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

Icon/Unicon supports digit literals of the form <base>r<value> with base being from 2-36 and the digits being from 0..9 and a..z.

L := [1, 2r10, 3r10, 4r10, 5r10, 6r10, 7r10, 8r10, 9r10, 10r10, 11r10, 12r10, 13r10, 14r10,

15r10, 16r10, 17r10, 18r10,19r10, 20r10, 21r10, 22r10, 23r10, 24r10, 25r10, 26r10, 27r10,

 

every write(!L)

 

=={{header|J}}==

Arbitrary base numbers begin with a base ten literal (which represents the base of this number), and then the letter 'b' and then an arbitrary sequence of digits and letters which represents the number in that base. Letters a..z represent digits in the range 10..35. Each numeric item in a numeric constant must have its base specified independently.

 

1

 

This may be used to enter hexadecimal or octal or binary numbers. However, note also that J's primitives support a variety of binary operations on numbers represented as sequences of 0s and 1s, like this:

 

 

 

J also supports extended precision integers, if one member of a list ends with an 'x' when they are parsed. Extended precision literals can not be combined, in the same constant, with arbitrary base literals. (The notation supports no way of indicating that extra precision in an arbitrary base literal should be preserved and the extra complexity to let this attribute bleed from any member of a list to any other member was deemed not worth implementing.)

 

123456789123456789123456789 100000000000

 

16b100 10x

 

J also allows integers to be entered using other notations, such as scientific or rational.

 

 

Internally, J freely [http://www.jsoftware.com/help/dictionary/dictg.htm converts] fixed precision integers to floating point numbers when they overflow, and numbers (including integers) of any type may be combined using any operation where they would individually be valid arguments.

A leading 0 means octal, 0x or 0X means hexadecimal. Otherwise, it is just decimal.

 

public static void main(String[] args) {

System.out.println( 727 == 0x2d7 &&

727 == 01327 );

}

 

You may also specify a <tt>long</tt> literal by adding an <tt>l</tt> or <tt>L</tt> (uppercase is preferred as the lowercase looks like a "1" in some fonts) to the end (ex: <tt>long a = 574298540721727L</tt>). This is required for numbers that are too large to be expressed as an <tt>int</tt>.

{{works with|Java|7}}

Java 7 has added binary literals to the language. A leading 0b means binary. You may also use underscores as separators in all bases.

public static void main(String[] args) {

System.out.println( 727 == 0b10_1101_0111 );

}

 

=={{header|JavaScript}}==

 

727 == 01327 )

 

=={{header|jq}}==

=={{header|Julia}}==

Julia has binary, octal and hexadecimal literals. We check that they give the same value.

 

=={{header|Kotlin}}==

 

 

 

 

 

 

 

{{out}}

<pre>

</pre>

 

=={{header|Lasso}}==

 

=={{header|Limbo}}==

Integer literals in Limbo can be written in any base from 2 to 36 by putting the base (or radix), then 'r' or 'R', and the digits of the number. If no base is explicitly given then the number will be in base 10.

 

include "sys.m";

sys->print("%d\n", 15); # decimal

sys->print("%d\n", 16rF); # hexadecimal

 

=={{header|LiveCode}}==

LiveCode supports hexadecimal literals, and if "convertOctals" is set to true, then integer literals with leading zeroes are interpreted as octal and not base 10.

 

 

=={{header|Logo}}==

=={{header|Logtalk}}==

Built-in support for bases 2, 8, 10, and 16:

:- object(integers).

 

 

:- end_object.

Sample output:

| ?- integers::show.

Binary 0b11110101101 = 1965

Hexadecimal 0x7AD = 1965

yes

 

=={{header|Lua}}==

Lua supports either base ten or hex

45, 0x45

 

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

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

Print ExpType$(12345678912345#)="Currency", 12345678912345#

\\ used for unsigned integers (but it is double)

Print ExpType$(0xFFFFFFFF)="Double", 0xFFFFFFFF=4294967295

 

=={{header|M4}}==

m4 has decimal, octal and hexadecimal literals like C.

 

eval(010) # base 8

 

Output: <pre>10 # base 10

{{works with|GNU m4}}

 

eval(`0r2:10') # base 2

...

 

Output: <pre>2 # base 2

 

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

2^^1011

-> 11

 

36^^1011

 

=={{header|MATLAB}} / {{header|Octave}}==

Matlab uses only base 10 integers.

 

Octave allows also a hexadecimal representation

 

Other representation of other bases need to be converted by functions

bin2dec(s)

 

Different integer types can be defined by casting.

uint8(8)

int16(8)

uint32(8)

int64(8)

 

=={{header|Maxima}}==

 

=={{header|Mercury}}==

 

Octal = 0o666,

Hex = 0x1fa,

 

An integer is either a decimal, binary, octal, hexadecimal, or character-code literal. A decimal literal is any sequence of decimal digits. A binary literal is <tt>0b</tt> followed by any sequence of binary digits. An octal literal is <tt>0o</tt> followed by any sequence of octal digits. A hexadecimal literal is <tt>0x</tt> followed by any sequence of hexadecimal digits. A character-code literal is <tt>0'</tt> followed by any single character.

=={{header|Metafont}}==

 

 

Metafont numbers can't be greater than 4096, so that the maximum octal and hexadecimal legal values are <tt>7777</tt> and <tt>FFF</tt> respectively. To be honest, <tt>"100"</tt> is a string, and <tt>oct</tt> is an "internal" "''macro''"; but this is the way Metafont specifies numbers in base 8 and 16.

 

=={{header|Modula-3}}==

All numbers 2 to 16 are allowed to be bases.

 

IMPORT IO;

IO.PutInt(2_1011010111);

IO.Put("\n");

 

=={{header|Neko}}==

Neko supports base 10 and 0x prefixed base 16 integer literals. Leading zero is NOT octal.

 

Integer literals, in Neko

Base 10 and Base 16, no leading zero octal in Neko

var num = 2730

if (num == 02730) $print("base 10, even with leading zero\n")

 

=={{header|Nemerle}}==

1_000_000 // _ can be used for readability

1_42_00 // or unreadability...

10ub, 10bu // unsigned byte

10L // long

 

Formally (adapted from [http://nemerle.org/wiki/index.php?title=Lexical_structure_%28ref%29 Reference Manual]):

character is <tt>B</tt> or <tt>b</tt>, and the digits of ''string'' must be either <tt>0</tt> or <tt>1</tt>, each representing a single bit.

 

options replace format comments java crossref symbols

 

iv = 32B1111111111111111; say '32B1111111111111111'.right(20) '==' iv.right(8) -- 65535

 

'''Output:'''

<pre>

 

=={{header|Nim}}==

x = 0b1011010111

x = 0b10_1101_0111

var g = 128'u16

var h = 129'u32

 

=={{header|Objeck}}==

As of v1.1, Objeck only supports hexadecimal and decimal literals.

bundle Default {

class Literal {

}

}

 

=={{header|OCaml}}==

 

Bin(leading 0b or 0B), Oct(leading 0o or 0O), Hex(leading 0x or 0X)

- : bool = true

# 727 = 0o1327;;

- : bool = true

# 12345 = 12_345 (* underscores are ignored; useful for keeping track of places *);;

 

Literals for the other built-in integer types:

=={{header|Oz}}==

To demonstrate the different numerical bases, we unify the identical values:

%% binary octal dec. hexadecimal

0b1011010111 = 01327 = 727 = 0x2d7

catch _ then

{Show unexpectedError}

 

Negative integers start with "~":

 

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

octal (with leading ampersand: &) and

binary (with leading percent sign: %) literals:

 

DEC_VALUE = 15;

OCTAL_VALUE = &017;

BINARY_VALUE = %1111;

 

=={{header|Perl}}==

 

727 == 01327 &&

727 == 0b1011010111 &&

12345 == 12_345 # underscores are ignored; useful for keeping track of places

 

=={{header|Phix}}==

The included mpfr/gmp library allows working with extremely large integers with arbitrary precision, very efficiently.

 

<span style="color: #0000FF;">?{</span><span style="color: #000000;">65</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#41</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'A'</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"55"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">),</span><span style="color: #000000;">0o10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(7)11</span><span style="color: #0000FF;">}</span>

 

{{out}}

=={{header|PHP}}==

 

if (727 == 0x2d7 &&

727 == 01327) {

$a = 0b11111111; // binary number (equivalent to 255 decimal)

$a = 1_234_567; // decimal number (as of PHP 7.4.0)

 

=={{header|PicoLisp}}==

In the strict sense of this task, PicoLisp reads only integers at bases which are a power of ten (scaled fixpoint numbers). This is controlled via the global variable '[http://software-lab.de/doc/refS.html#*Scl *Scl]':

-> 4

 

: 123.456789

However, the reader is normally augmented by read macros, which can read any

base or any desired format. Read macros are not executed at runtime, but

intially when the sources are read.

In addition to standard formats like

'[http://software-lab.de/doc/refH.html#hex hex]' (hexadecimal) and

 

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

12345

'b4'xn /* a hexadecimal literal integer. */

'ffff_ffff'xn /* a longer hexadecimal hexadecimal integer. */

1101b /* a binary integer, of value decimal 13. */

 

=={{header|PostScript}}==

Integer literals in PostScript can be either standard decimal literals or in the form ''base''<code>#</code>''number''. ''base'' can be any decimal integer between 2 and 36, ''number'' can then use digits from <code>0</code> to ''base''&nbsp;−&nbsp;1. Digits above <code>9</code> are replaced by <code>A</code> through <code>Z</code> and case does not matter.

8#1777 % 1023

16#FFFE % 65534

2#11011 % 27

 

=={{header|PowerShell}}==

PowerShell only supports base 10 and 16 directly:

Furthermore there are special suffices which treat the integer as a multiple of a specific power of two, intended to simplify file size operations:

3MB # 3145728

3GB # 3221225472

A number can be suffixed with <code>d</code> to make it a <code>decimal</code>. This doesn't work in conjunction with above suffixes, though:

<pre>PS> 4d.GetType().ToString()

=={{header|PureBasic}}==

PureBasic allows integer literals to be specified in base 10, base 2 by using the prefix '%', or base 16 by using the prefix '$'.

x = %1111 ;15 in base 2

An integer literal representing a character code can also be expressed by surrounding the character with single quotes. More than one character can be included in the single quotes (i.e. 'abc'). Depending on whether code is compiled in Ascii or Unicode mode this will result in the integer value being specified in base 256 or base 65536 respectively.

 

 

=={{header|Python}}==

{{works with|Python|3.0}}

Python 3.0 brought in the binary literal and uses 0o or 0O exclusively for octal.

>>> 0b1011010111 == 0o1327 == 727 == 0x2d7

True

{{works with|Python|2.6}}

Python 2.6 has the binary and new octal formats of 3.0, as well as keeping the earlier leading 0 octal format of previous 2.X versions for compatability.

>>> 0b1011010111 == 0o1327 == 01327 == 727 == 0x2d7

True

{{works with|Python|2.5}}

>>> 01327 == 727 == 0x2d7

True

 

In Python 2.x you may also specify a <tt>long</tt> literal by adding an <tt>l</tt> or <tt>L</tt> (the latter form is preferred as the former looks like a "1") to the end (ex: <tt>574298540721727L</tt>), but this is optional, as integer literals that are too large for an <tt>int</tt> will be interpreted as a <tt>long</tt>.

The default base can be overridden for a section of code using the compiler directive <code>now!</code> like this;

 

 

( The Quackery compiler now expects numeric literals to be in binary. )

 

( The Quackery compiler now expects numeric literals to be in whichever

 

If a new compiler directive akin to <code>hex</code> is required, say to allow occasional octal literals in the form <code>octal 7777</code>, the compiler can be extended like this;

 

nextword dup

$ '' = if

$ '" is not octal.'

join message put bail ]

 

=={{header|R}}==

0x or 0X followed by digits or the letters a-f denotes a hexadecimal number. The suffix L means that the number should be stored as an integer rather than numeric (floating point).

identical(0x2d7, 727) # TRUE

is.numeric(727) # TRUE

is.numeric(0x2d7) # TRUE

is.integer(0x2d7) # FALSE

For more information, see [http://cran.r-project.org/doc/manuals/R-lang.pdf Section 10.3.1 of the R Language definition] (PDF).

 

=={{header|Racket}}==

 

#lang racket

#b1011010111

#d727

#x2d7

 

Output:

(formerly Perl 6)

These all print 255.

say 0d255;

say 0xff;

say :4<3333>;

say :12<193>;

There is a specced form for bases above 36, but rakudo does not yet implement it.

 

=={{header|REBOL}}==

 

=={{header|Retro}}==

%100 ( binary )

$100 ( hex )

'c ( ascii character )

 

Numbers without a prefix are interpreted using the current '''base''', which is a variable Valid characters are stored in a string called '''numbers''', which can also be altered to allow for larger bases.

 

=={{header|REXX}}==

/*────────── expressing decimal numbers ──────────*/

ddd = 123 /*a decimal number (expressed as a literal). */

thingy8= ' + 123 ' /*╚══════════════════════════════════════════════╝*/

 

{{out|output}}

<pre>

 

=={{header|Ring}}==

see "Decimal literal = " + 1234 + nl

see "Hexadecimal literal = " + dec("4D2") + nl

end

return output

Output:

<pre>

</pre>

 

=={{header|Ruby}}==

 

727 == 0x2d7 # => true, hex

727 == 0o1327 # => true, octal

 

12345 == 12_345 # => true underscores are ignored; useful for keeping track of places

 

=={{header|Rust}}==

0b10 // Binary

0x10 // Hexadecimal

1_000 // Underscores may appear anywhere in the numeric literal for clarity

10_i32 // The type (in this case i32, a 32-bit signed integer) may also be appended.

 

=={{header|Scala}}==

 

binary: #b, octal: #o, decimal: #d (optional obviously), hex: #x

#t

> (= 727 #o1327)

#t

> (= 727 #x2d7)

 

=={{header|Seed7}}==

In [[Seed7]] integer literals may have the form <base>#<numeral>. Here <base> can be from the range 2..36. For example:

 

const proc: main is func

writeln(2#1011010111);

end func;

Sample output:

<pre>

 

=={{header|Sidef}}==

say 0xff;

say 0377;

{{out}}

<pre>255

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

binary, base-5, octal, decimal, binary, decimal (default).

Any base between 2 and 32 can be used (although only 2, 8, 10 and 16 are typically needed).

 

There is no size limit (except memory constraints), the runtime chooses an appropriate representation automatically:

"evaluates to true"

 

2r101010101011111100000011111000000111111111111111110101010101010101010100101000000000111111100000000111

 

=={{header|Standard ML}}==

 

Hex(leading 0x), Word (unsigned ints, leading 0w), Word Hex (leading 0wx)

val it = true : bool

- 727 = Word.toInt 0w727;

* worth mentioning because it's unusual

*)

 

=={{header|Stata}}==

 

=={{header|Swift}}==

let bin = 0b101111 // Binary

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

(This is an interactive tclsh session; <tt>expr</tt> is only called to evaluate the equality test.)

1

% expr 727 == 0o1327

1

% expr 727 == 0b1011010111

 

=={{header|TI-89 BASIC}}==

Binary, decimal, and hexadecimal are supported. The system base mode sets the default output base, but does not affect input; unmarked digits are always decimal.

 

 

=={{header|UNIX Shell}}==

The <tt>expr</tt> command accepts only decimal literals.

 

699

$ expr 0700 - 01

 

Some shells have arithmetic expansion. These shells may accept literals in other bases. This syntax only works in places that do arithmetic expansion, such as in <tt>$(( ))</tt>, or in Bash's <tt>let</tt> command.

 

{{works with|bash}}

oct=$(( 01327 ))

bin=$(( 2#1011010111 ))

# or e.g.

let bin=2#1011010111

 

{{works with|pdksh|5.2.14}}

oct=$(( 01327 ))

bin=$(( 2#1011010111 ))

# or e.g.

(( bin = 2#1011010111 ))

 

=={{header|Ursa}}==

Ursa supports signed, base-10 integers.

set i 123

 

=={{header|Ursala}}==

 

Natural numbers (i.e., unsigned integers) of any size are supported. Only decimal integer literals are recognized by the compiler, as in a declaration such as the following.

Signed integers are also recognized and are considered a separate type from natural numbers, but non-negative integers and natural numbers have compatible binary representations.

Signed rational numbers of unlimited precision are yet another primitive type and can be expressed

in conventional decimal form.

The forward slash in a rational literal is part of the syntax and not a division operator. Finally, a signed or unsigned integer with a trailing underscore, like this

is used for numbers stored in binary converted decimal format, also with unlimited precision, which may perform better in applications involving very large decimal numbers.

 

=={{header|Verbexx}}==

//

// If present, base prefix must be: 0b 0B (binary) 0o 0O (octal)

// no prefix, the numeric literal cannot begin with underscore:

 

 

=={{header|Visual Basic}}==

{{works with|VBA|7.1}}

Integer literals can be expressed in octal, decimal and hexadecimal form.

 

'Long: 4 Bytes (signed), type specifier = &

Debug.Assert b2 = b3

 

=={{header|Wren}}==

 

As the only difference between integers and other numbers is that the former do not have a decimal part, it is also possible to represent integers using scientific notation.

var b = 0xff

var c = 0255 // not an octal literal

var d = 2.55e2

 

{{out}}

 

=={{header|XPL0}}==

def A=123, B=$123, C=%11_0011, D=^A;

[IntOut(0, A); CrLf(0); \decimal

IntOut(0, C); CrLf(0); \binary

IntOut(0, D); CrLf(0); \ASCII

 

Output:

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

Numeric values can be defined in decimal, binary, or hexadecimal.

byte $42 ;hexadecimal 42

byte 33 ;decimal 33

 

=={{header|zkl}}==

Three int types the compiler understands: decimal, hex, binary. Other bases (2-36) require a method call.

0x123, 0x12|34