Non-decimal radices/Input: Difference between revisions

The solutions may assume that the base of the number in the string is known. In particular, if your language has a facility to guess the base of a number by looking at a prefix (e.g. "0x" for hexadecimal) or other distinguishing syntax as it parses it, please show that.

 

 

=={{header|AutoHotkey}}==

There is no built in support for generic base parsing.<br>

 

=={{header|C}}==

 

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

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

 

 

 

 

180154659

8 baseN '7651'

4009

10 baseN '123459'

 

=={{header|Java}}==

 

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

The <code>parseInt(''string'',''radix'')</code> core function is the reverse of the <code>''number''.toString(''radix'')</code> method. The following is taken from [http://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Functions/parseInt#Example.3a_Using_parseInt Mozilla's JavaScript 1.5 reference].

 

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

echo hexdec("abcf123"), "\n"; // prints 180154659

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

 

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

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

hex2 = "abcf123"

oct3 = "7651"

bin4 = "101011001"

 

 

 

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

 

=={{header|Scheme}}==

180154659

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

4009

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

 

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