Literals/Integer

From Rosetta Code
Task
Literals/Integer
You are encouraged to solve this task according to the task description, using any language you may know.

Some programming languages have ways of expressing integer literals in bases other than the normal base ten.

Show how integer literals can be expressed in as many bases as your language allows.

Note: this should not involve the calling of any functions/methods but should be interpreted by the compiler or interpreter as an integer written to a given base.

Also show any other ways of expressing literals, e.g. for different types of integers.

Ada

In Ada integer literals may have the form <base>#<numeral>#. Here <base> can be from the range 2..16. For example: <lang ada> with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Test_Literals is begin 

  Put (16#2D7#);
  Put (10#727#);
  Put (8#1_327#);
  Put (2#10_1101_0111#);

end Test_Literals; </lang> Sample output: 

        727        727        727        727

ALGOL 68

Translation of: Fortran
Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386

Binary constants are of type BITS, and need to be converted to INT using the operator ABS. 

main:(
 
  INT dec = 727;
  INT hex = ABS 16r2d7;
  INT oct = ABS 8r1327;
  INT bin = ABS 2r1011010111;
 
  print((dec, hex, oct, bin, new line))
 
)

Output: 

       +727        +727        +727        +727

AmigaE

<lang amigae>PROC main() 

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

ENDPROC</lang>

AWK

<lang>BEGIN { 

   if ( (0x2d7 == 727) &&
        (01327 == 727) ) {
       print "true"
   }

}</lang>

C

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

<lang c>#include <stdio.h>

int main(void) { 

 printf("%s\n",
        ( (727 == 0x2d7) && 
          (727 == 01327)    ) ? "true" : "false");

 return 0;

}</lang>

C has no way of specifying integers in binary (if there's something like 0b..., it is not standard)

C++

The same comments apply as to the C example.

<lang c>#include <iostream>

int main() { 

 std::cout << ( (727 == 0x2d7) && 
                (727 == 01327)     ? "true" : "false")
           << std::endl;

 return 0;

}</lang>

Common Lisp

(This is an interactive common lisp session)

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

>(= 727 #b1011010111)
T
>(= 727 #o1327)
T
>(= 727 #x2d7)
T
>(= 727 #20r1g7)
T

D

D besides hexadecimal, and octal bases has also binary base. Additionaly you can use _ to separate digits in integer literals.

<lang D> import tango.io.Stdout;

int main(char[][] args) { 

   Stdout ("oct: ") (0777).newline;
   Stdout ("bin: ") (0b01011010).newline;
   Stdout ("hex: ") (0xBADF00D).newline;
   Stdout ("dec: ") (1000000000).newline;
   Stdout ("dec: ") (1_000_000_000).newline;
   Stdout.newline;
   Stdout (typeid(typeof(0))).newline;
   Stdout (typeid(typeof(0u))).newline;
   Stdout (typeid(typeof(0L))).newline;
   Stdout (typeid(typeof(0uL))).newline;
   Stdout (typeid(typeof(0LU))).newline;
   Stdout.newline;
   Stdout.formatln ("{:x}", 0xFEE1_BAD_CAFE_BABEuL);
   return 0;

}</lang>

Output: 

oct: 511
bin: 90
hex: 195948557
dec: 1000000000
dec: 1000000000

int
uint
long
ulong
ulong

fee1badcafebabe

E

<lang e> ? 256

  1. value: 256

? 0x100

  1. value: 256

? 0123

  1. syntax error: Octal is no longer supported: 0123

</lang>

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

HEX
FEEDFACE
2 BASE !
1011001
DECIMAL
1234
: mask  var @ [ base @ hex ] 3fff and [ base ! ] var ! ;

</lang> 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'). <lang forth> 

1234   ( n )
123.4  ( l h )
123e4  ( F: n )

</lang>

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

$feedface   \ hexadecimal
&1234       \ decimal
%1001101    \ binary
'a          \ base 256  (ASCII literal)

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

Fortran

<lang fortran>program IntegerLiteral 

 implicit none
 integer, parameter   :: dec = 727
 integer, parameter   :: hex = Z'2d7'
 integer, parameter   :: oct = O'1327'
 integer, parameter   :: bin = B'1011010111' 

 print *, dec, hex, oct, bin

end program IntegerLiteral</lang>

Outputs: 

         727         727         727         727

Groovy

Solution: <lang groovy>println 025 // octal println 25 // decimal println 0x25 // hexadecimal</lang>

Output: 

21
25
37

Metafont

<lang metafont>num1 := oct"100"; num2 := hex"100";</lang>

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

Modula-3

All numbers 2 to 16 are allowed to be bases. <lang modula3>MODULE Literals EXPORTS Main;

IMPORT IO;

BEGIN 

 IO.PutInt(16_2D7);
 IO.Put(" ");
 IO.PutInt(10_727);
 IO.Put(" ");
 IO.PutInt(8_1327);
 IO.Put(" ");
 IO.PutInt(2_1011010111);
 IO.Put("\n");

END Literals.</lang>

Haskell

(This is an interactive ghci session)

Oct(leading 0o or 0O), Hex(leading 0x or 0X) <lang haskell> Prelude> 727 == 0o1327 True Prelude> 727 == 0x2d7 True </lang>

Java

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

<lang java5>public class IntegerLiterals { 

   public static void main(String[] args) {
       System.out.println( 727 == 0x2d7 && 
                           727 == 01327   );
   }

}</lang>

Java has no way of specifying integers in binary.

You may also specify a long literal by adding an l or L (the latter form is preferred as the former looks like a "1") to the end (ex: long a = 574298540721727L), and this is required for numbers that are too large to be expressed as an int.

JavaScript

<lang javascript> if ( 727 == 0x2d7 && 

    727 == 01327 )
   window.alert("true");

</lang>

OCaml

(This is an interactive ocaml session)

Bin(leading 0b or 0B), Oct(leading 0o or 0O), Hex(leading 0x or 0X) <lang ocaml>

  1. 727 = 0b1011010111;;

- : bool = true

  1. 727 = 0o1327;;

- : bool = true

  1. 727 = 0x2d7;;

- : bool = true

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

- : bool = true </lang>

Literals for the other built-in integer types:

  • 727l - int32
  • 727L - int64
  • 727n - nativeint

Perl

<lang perl> print "true\n" if ( 727 == 0x2d7 && 

                   727 == 01327 &&
                   727 == 0b1011010111 &&
                   12345 == 12_345   # underscores are ignored; useful for keeping track of places
                 );

</lang>

PHP

<lang php><?php if ( 727 == 0x2d7 && 

    727 == 01327 )
   echo "true\n";

?></lang>

Python

Works with: Python version 3.0

Python 3.0 brought in the binary literal and uses 0o or 0O exclusively for octal. <lang python>>>> # Bin(leading 0b or 0B), Oct(leading 0o or 0O), Dec, Hex(leading 0x or 0X), in order: >>> 0b1011010111 == 0o1327 == 727 == 0x2d7 True >>> </lang>

Works with: Python version 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. <lang python>>>> # Bin(leading 0b or 0B), Oct(leading 0o or 0O, or just 0), Dec, Hex(leading 0x or 0X), in order: >>> 0b1011010111 == 0o1327 == 01327 == 727 == 0x2d7 True >>> </lang>

Works with: Python version 2.5

<lang python>>>> # Oct(leading 0), Dec, Hex(leading 0x or 0X), in order: >>> 01327 == 727 == 0x2d7 True >>> </lang>

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

Ruby

(This is an interactive irb session) 

irb(main):001:0> 727 == 0b1011010111
=> true
irb(main):002:0> 727 == 0x2d7
=> true
irb(main):003:0> 727 == 01327
=> true
irb(main):001:0> 12345 == 12_345 # underscores are ignored; useful for keeping track of places
=> true

Scheme

(This is an interactive scheme session)

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

> (= 727 #b1011010111)
#t
> (= 727 #o1327)
#t
> (= 727 #d727)
#t
> (= 727 #x2d7)
#t

Tcl

Works with: Tcl version 8.5

(This is an interactive tclsh session; expr is only called to evaluate the equality test.) <lang tcl>% expr 727 == 0x2d7 1 % expr 727 == 0o1327 1 % expr 727 == 01327 1 % expr 727 == 0b1011010111 1</lang>

UNIX Shell

Works with: bash

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 BASE#NUMBER can be used, with BASE going from 2 to 64, and the symbols used are digits, lowercase letters, uppercase letters, @ and _ in that order; 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. (From the info manual of the Bash). This syntax works only in some circumstances, i.e. in the shell expansion (e.g. inside $(( ))) or using let. 

dec=727
oct=$(( 01327 ))
bin=$(( 2#1011010111 ))
hex=$(( 0x2d7 ))
# or e.g.
let bin=2#1011010111
let "baseXX = 20#1g7"
Retrieved from "https://rosettacode.org/wiki/Literals/Integer?oldid=98145"