Literals/Integer: Difference between revisions

=={{header|Ada}}==

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

 

procedure Test_Literals is

Put (8#1_327#);

Put (2#10_1101_0111#);

Sample output:

<pre>

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

to INT using the operator ABS.

INT dec = 727;

print((dec, hex, oct, bin, new line))

Output:

 

=={{header|AmigaE}}==

ENDPROC</lang>

=={{header|AutoHotkey}}==

 

=={{header|AWK}}==

 

if ( (0x2d7 == 727) &&

(01327 == 727) ) {

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

 

 

int main()

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|Common Lisp}}==

 

 

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

T

>(= 727 #o1327)

T

>(= 727 #20r1g7)

 

=={{header|D}}==

integer literals.

 

 

int main(char[][] args)

=={{header|E}}==

 

# value: 256

 

 

? 0123

 

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

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

 

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

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

 

 

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

True

Prelude> 727 == 0x2d7

 

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

 

 

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 with arbitrary base literals.

 

 

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.

=={{header|JavaScript}}==

 

727 == 01327 )

 

=={{header|M4}}==

eval(010) # base 8

eval(0x10) # base 16

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

...

 

Output:

 

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

 

727 == 01327 &&

727 == 0b1011010111 &&

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

 

=={{header|PHP}}==

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

<lang python>>>> # Oct(leading 0), Dec, Hex(leading 0x or 0X), in order:

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

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

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

 

(This is an interactive irb session)

 

=> true

irb(main):002:0> 727 == 0x2d7

=> true

irb(main):001:0> 12345 == 12_345 # underscores are ignored; useful for keeping track of places

 

=={{header|Scheme}}==

 

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

#t

> (= 727 #o1327)

#t

> (= 727 #x2d7)

 

=={{header|Slate}}==

 

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

 

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

val it = true : bool

- 727 = Word.toInt 0w727;

val it = true : bool

- ~727; (* negative number; ~ is the unary negation operator for all numbers, including reals and ints; worth mentioning because it's unusual *)

 

=={{header|Tcl}}==

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

As manual states, 0x or 0X is the prefix for hexadecimal numbers, while 0 is the one for octal, and nothing means the number is decimal. But the sintax <tt>BASE#NUMBER</tt> can be used, with BASE going from 2 to 64, and the symbols used are digits, lowercase letters, uppercase letters, @ and _ <cite>in that order</cite>; <cite>if the BASE is less than or equal to 36, lowercase and uppercase letters can be used interchangeably to represent number from 10 and 35.</cite> (From the info manual of the Bash). This syntax works only in some circumstances, i.e. in the shell expansion (e.g. inside <tt>$(( ))</tt>) or using <tt>let</tt>.

 

oct=$(( 01327 ))

bin=$(( 2#1011010111 ))

# or e.g.

let bin=2#1011010111

 

=={{header|Ursala}}==