Non-decimal radices/Input: Difference between revisions

 

For general number base conversion, see [[Non-decimal radices/Convert]].

 

=={{header|Ada}}==

 

numbers.adb:

procedure Numbers is

package Int_IO is new Ada.Text_IO.Integer_IO (Integer);

Float_IO.Put (Float'Value ("16#F.FF#E+2"));

Ada.Text_IO.New_Line;

 

Output:

 

=={{header|Aime}}==

o_byte('\n');

o_integer(alpha("224000000", 5));

o_byte('\n');

o_integer(alpha("0xf4240", 0));

 

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

(

FILE fbuf; STRING sbuf;

printf(($gl$, ABS num)) # prints 666 #

Output:

<pre>

+666

</pre>

 

=={{header|AutoHotkey}}==

 

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

PRINT VAL("0")

PRINT VAL("123456789")

PRINT EVAL("%1111111111")

PRINT EVAL("&ABCD")

'''Output:'''

<pre>

 

In addition to <tt>strtol()</tt> described in the Number base conversion task, you could also use the <code>scanf</code> family of functions to parse un-prefixed hexadecimal, decimal, and octal numbers:

 

int main()

 

return 0;

 

The <code>strtol()</code> function can also parse prefixed hexadecimal, octal, and decimal strings based on the prefix, when passed a base of 0:

#include <stdlib.h>

#include <assert.h>

 

return 0;

 

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

 

class Program

}

}

Output:

100 in base 8 is 64 in base 10

100 in base 10 is 100 in base 10

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

#include <sstream>

 

 

return 0;

 

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

 

If <code>:radix</code> is omitted, it defaults to 10. If <code>:junk-allowed</code> is omitted, it defaults to <code>nil</code>, causing <code>#'parse-integer</code> to signal an error of type <code>parse-error</code> rather than just returning <code>nil</code> whenever the input string isn't a numeral possibly surrounded by whitespace.

=={{header|D}}==

{{trans|Python}}

 

void main() {

writefln("String '%s' in base %d is %d in base 10" ,

text, base, to!int(text, base));

{{out}}

<pre>String '100' in base 2 is 4 in base 10

String '100' in base 19 is 361 in base 10

String '100' in base 20 is 400 in base 10</pre>

 

=={{header|E}}==

[[Category:E examples needing attention]] <!-- Is it appropriate to explicitly use __makeInt in this situation, or should it be preferred to import? Does the answer to this change in the presence of a module system? -->

 

# value: 512

 

? __makeInt("200", 10)

 

=={{header|Elixir}}==

base: 2 .. 36

1000

iex(2)> String.to_integer("1000",2)

4096

iex(5)> String.to_integer("ffff",16)

 

=={{header|Erlang}}==

78300

</pre>

 

=={{header|Factor}}==

99

Note that these words are very simple : for example, here's oct> :

Also, fractions are handled transparently :

( scratchpad ) "1+F/2" hex> .

( scratchpad ) "11.1101" bin> .

11.1101

=={{header|Forth}}==

Arbitrary base 2-36 parsing is supported by the same mechanism as [[User Input#Forth|decimal parsing]]: set the user variable BASE to the desired base, then scan the number. There are two convenience words for setting the base to DECIMAL or HEX.

0. 2SWAP DUP >R >NUMBER NIP NIP

R> <> DUP 0= IF NIP THEN ;

 

: base# ( str len base -- u true | false )

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

write(*,*) num ! Prints 666

 

=={{header|Go}}==

 

import (

fmt.Sscanf("15", "%o", &z)

fmt.Println(&z)

Output is all 13s.

 

=={{header|Haskell}}==

Haskell's <tt>read</tt> can parse strings with the same prefix used for literals in Haskell (0x or 0X for hex, 0o or 0O for octal):

123459

Prelude> read "0xabcf123" :: Integer

180154659

Prelude> read "0o7651" :: Integer

 

=={{header|HicEst}}==

READ(Text=" abcf123 ", Format="Z10") hex ! 180154659

READ(Text=" 7651 ", Format="o10") oct ! 4009

 

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

Icon allows numbers to be defined as 'root' + "R" + 'number', where 'root' is a base from 2 to 36, and 'number' is a string of digits or letters, using 'A' to 'Z' as appropriate for the base; case is ignored. Strings are automatically parsed into numbers when needed, using the procedure 'integer'.

 

procedure convert (str)

write (left(str, 10) || " = " || integer(str))

write ("2r1001" + "36r1Z") # shows type conversion, string->integer

end

 

Output:

=={{header|J}}==

 

180154659

8 baseN '7651'

4009

10 baseN '123459'

'''Note''':

 

However you can use digits larger than the radix:

 

 

And you can use bases where not all digits are representable:

 

 

Letters used for digits have base 10 values ranging from 10 (a) to 35 (z).

 

You must know the base that the String is in before you scan it. Create a <tt>Scanner</tt> in the usual way, but then set its radix to that base (obviously, the default is 10):

sc.useRadix(base); //any number from Character.MIN_RADIX (2) to CHARACTER.MAX_RADIX (36)

Later you can call <tt>sc.reset()</tt> or <tt>sc.useRadix(10)</tt> to undo this change.

 

Another option using the <tt>Integer</tt> class:

The base here has the same restrictions as the <tt>Scanner</tt> example. A similar method is available in the <tt>Long</tt> class. Use no second argument for base 10.

 

If you have a prefixed string ("0x", "0X", or "#" for hex; "0" for octal; otherwise decimal), you can use the <tt>.decode()</tt> utility method to parse the number based on the base indicated by the prefix (note: this returns an Integer object, not a primitive int):

Integer.decode("07651"); // octal

<tt>Long</tt>, <tt>Short</tt>, and <tt>Byte</tt> also have a <tt>.decode()</tt> method, to decode to the appropriate number object type.

 

=={{header|JavaScript}}==

For base 10 and 16 ("0x"-prefixed), (but not 8), it is fastest to parse strings using the unary plus (+) operator:

+"0xabcf123"; // 180154659

 

// also supports negative numbers, but not for hex:

+"-0123459"; // -123459

See http://www.jibbering.com/faq/notes/type-conversion/#tcNumber for more information.

 

<div style='height:40ex; overflow:scroll'>The following examples all return 15:

 

parseInt(" F", 16);

parseInt("17", 8);

parseInt("15e2", 10);

parseInt("15px", 10);

 

The following examples all return NaN:

 

 

The following examples all return -15:

 

parseInt("-0F", 16);

parseInt("-0XF", 16);

parseInt("-1111", 2);

parseInt("-15e1", 10);

 

The following example returns 224:

 

 

Although it is optional, most implementations interpret a numeric string beginning with a leading '0' as octal. The following may have an octal result.

 

=={{header|Lua}}==

Lua supports bases between 2 and 36.

print( tonumber("a5b0", 16) )

print( tonumber("011101", 2) )

 

 

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

Output:

<pre>val =

9

17</pre>

 

=={{header|Nim}}==

 

echo parseInt "10" # 10

 

echo parseOctInt "0o120" # 80

Output:

<pre>10

=={{header|OCaml}}==

The <code>int_of_string</code> function can parse hexadecimal, octal, and binary numbers that have the same prefix that is used to specify OCaml constants ("0x", "0o", and "0b", respectively):

- : int = 123459

# int_of_string "0xabcf123";;

- : int = 4009

# int_of_string "0b101011001";;

The <code>Int32.of_string</code>, <code>Int64.of_string</code>, and <code>Nativeint.of_string</code> functions also can understand the above prefixes when parsing into their appropriate types.

 

 

You could also use the <code>Scanf</code> module to parse un-prefixed hexadecimal, decimal, and octal numbers (binary not supported):

- : int = 123459

# Scanf.sscanf "abcf123" "%x" (fun x -> x);;

- : int = 180154659

# Scanf.sscanf "7651" "%o" (fun x -> x);;

 

=={{header|Oz}}==

<code>String.toInt</code> understands the usual prefixes. If a string cannot be parsed, an exception will be thrown.

= {String.toInt "0x2a"} %% hexadecimal

= {String.toInt "052"} %% octal

 

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

Binary conversion is built in to PARI/GP, this script can convert from bases2-36 to bases 2-36. I've had help with this script at http:\\mersenneforums.org . The main flaw in this script I see is that it doesn't allow 36^x-1 type strings, I'll have to add that on later.

my(B=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"],a=0,c="");

numb1=Vec(Str(numb1));

);

c

 

=={{header|Perl}}==

The <tt>hex()</tt> function parses hexadecimal strings. The <tt>oct()</tt> function parses octal strings, as well as hexadecimal, octal, or binary strings with the appropriate prefix ("0x", "0", and "0b", respectively). There is no need to parse decimal strings because in Perl decimal strings and numbers are interchangeable.

my $hex_noprefix = "abcf123";

my $hex_withprefix = "0xabcf123";

print oct($oct_withprefix), "\n"; # => 4009

print oct($bin_withprefix), "\n"; # => 345

 

=={{header|Phix}}==

 

=={{header|PHP}}==

The <tt>hexdec(), octdec(), bindec()</tt> function parses hexadecimal, octal, and binary strings, respectively. They skip any invalid characters, so a prefix will be ignored. There is no need to parse decimal strings because in PHP decimal strings and numbers are interchangeable.

echo +"0123459", "\n"; // prints 123459

echo intval("0123459"), "\n"; // prints 123459

echo octdec("7651"), "\n"; // prints 4009

echo bindec("101011001"), "\n"; // prints 345

 

An undocumented feature of <tt>intval()</tt> is that it can parse prefixed strings when given the base 0:

echo intval("123459", 0), "\n"; // prints 123459

echo intval("0xabcf123", 0), "\n"; // prints 180154659

echo intval("07651", 0), "\n"; // prints 4009

 

In addition, for hexadecimals, if you have a "0x"-prefixed string, you can just use it in a numeric operation, and it gets converted to the number automatically:

echo +"0xabcf123", "\n"; // prints 180154659

# This does not work for octals, however:

echo +"07651", "\n"; // prints 7651

 

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

get edit (N) (A(7)); /* decimal input of 7 columns */

put skip list (N);

declare BS bit (32);

get edit (BS) (B(32)); /* Binary input of 32 binary digits. */

<pre>

23

</pre>

 

 

 

; decimal numbers have no prefix, hexadecimal needs a prefix of '$', binary needs a prefix of '%'

Val("1024102410241024") ; => 1024102410241024

Val("$10FFFFFFFF") ; => 73014444031

 

=={{header|Python}}==

The [http://docs.python.org/library/functions.html#int int] function will interpret strings as numbers expressed to some base:

>>> for base in range(2,21):

print ("String '%s' in base %i is %i in base 10"

% (text, base, int(text, base)))

 

String '100' in base 2 is 4 in base 10

String '100' in base 3 is 9 in base 10

String '100' in base 18 is 324 in base 10

String '100' in base 19 is 361 in base 10

 

In addition, if you give a base of 0, it will try to figure out the base from the prefix, with the same syntax as a numeric literal in Python:

</pre>

Python 2.6 supports both the above formats, because it supports both types of literals.

 

=={{header|R}}==

as.numeric("20") # 20

# parse a hex-string to decimal

as.hexmode(as.numeric("32")) # "20"

# parse a string to octal

 

=={{header|Racket}}==

 

#lang racket

 

(string->number "1111011" 2))

;; -> '(123 123 123 123 123 123 123 123)

 

=={{header|REXX}}==

╚══════════════════════════════════════════════════════════════════════════════════╝

</pre>

a=123 /*all of these assignments are identical: */

b='123'

dd=' + 123'

ee=0000123

gg=001.23E0002

hh=1230e-1

b2d: return x2d(b2x(arg(1))) /*convert bin──►dec*/

b2c: return x2c(b2x(arg(1))) /*convert bin──►chr*/

 

=={{header|Ruby}}==

The String class has methods to coerce a string into another form:

hex2 = "abcf123"

oct3 = "7651"

p hex2.hex # => 180154659

p oct3.oct # => 4009

 

The String class has '''to_i(base)''' method ( base : 2 .. 36 ).

Invalid characters past the end of a valid number are ignored.

(This method never raises an exception when base is valid.)

p hex2.to_i(16) # => 180154659

p oct3.to_i(8) # => 4009

p bin4.to_i(2) # => 345

 

The '''Integer()''' method can parse a string, provided the string has the right prefix:

p Integer(dec1.sub(/^0+/,"")) # => 123459

p Integer("0d" + dec1) # => 123459

p Integer("0" + oct3) # => 4009

p Integer("0o" + oct3) # => 4009

 

So can the <code>.to_i(0)</code> method, which never raises an exception:

p ("0d" + dec1).to_i(0) # => 123459

p ("0x" + hex2).to_i(0) # => 180154659

p ("0" + oct3).to_i(0) # => 4009

p ("0o" + oct3).to_i(0) # => 4009

 

And then there's the poorly documented Scanf module in the Ruby stdlib, that seems to wrap the matched value in an array:

p dec1.scanf("%d") # => [123459]

p hex2.scanf("%x") # => [180154659]

p oct3.scanf("%o") # => [4009]

 

=={{header|Scheme}}==

180154659

> (string->number "123459" 10) ; decimal, the "10" is optional

4009

> (string->number "101011001" 2) ; binary

 

=={{header|Seed7}}==

converts a numeric string, with a specified radix, to an [http://seed7.sourceforge.net/manual/types.htm#integer integer].

 

const proc: main is func

writeln(integer("tplig0", 32));

writeln(integer("gc0uy9", 36));

 

{{out}}

 

=={{header|Sidef}}==

var hex_noprefix = 'abcf123';

var hex_withprefix = '0xabcf123';

say oct_withprefix.oct; # => 4009

say bin_noprefix.bin; # => 345

 

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

val it = SOME 123459 : int option

- StringCvt.scanString (Int.scan StringCvt.HEX) "0xabcf123";

val it = SOME 4009 : int option

- StringCvt.scanString (Int.scan StringCvt.BIN) "101011001";

 

=={{header|Tcl}}==

 

# The strings to parse

 

# Print out what happened

This produces this output:

<pre>0123459->123459 abcf123->180154659 7651->4009 101011001->345</pre>

 

For a general parser up to base 36, a little function can be written:

set res 0

set digits {0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z}

}

return $res

Example:

<pre>% scanbase 255 19

% scanbase $dec1 8

bad digit 9</pre>

 

=={{header|XPL0}}==

int N; real R;

[Text(8, "123_456");

R:= RlIn(8);

RlOut(0, R); CrLf(0);

{{out}}

<pre>

=={{header|zkl}}==

The compiler knows numbers like 0x123, 0b1|101, 0d1_000 but the number conversion functions don't.

ns:=[20..30].pump(List,T("toString",base));

ns.println();

ns.pump(List,T("toInt",base)).println("\n")

}

Print 20 .. 30 in binary, decimal, hex & base 19 (or any base 2 .. 32) and parse them to decimal:

{{out}}