Non-decimal radices/Convert: Difference between revisions

The programs may be limited by the word size or other such constraint of a given language. There is no need to do error checking for negatives, bases less than 2, or inappropriate digits.

<br><br>

 

=={{header|ACL2}}==

(cond ((and (char>= chr #\0)

(char<= chr #\9))

 

(defun show-num (num base)

 

=={{header|Ada}}==

Ada provides built-in capability to convert between all bases from 2 through 16. This task requires conversion for bases up to 36. The following program demonstrates such a conversion using an iterative solution.

with Ada.Strings.Fixed;

With Ada.Strings.Unbounded;

Put_Line("26 converted to base 16 is " & To_Base(26, 16));

Put_line("1a (base 16) is decimal" & Integer'image(To_Decimal("1a", 16)));

 

=={{header|Aime}}==

o_byte('\n');

o_text(bfxa(0, 0, 5, 1000000));

o_byte('\n');

o_integer(alpha("11110100001001000000", 2));

 

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

a numbers base.

 

BITS to bits;

 

reset(f);

getf(f, (hex repr, to bits));

Output:

<pre>

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

 

PROC raise value error = ([]STRING args)VOID: (

INT i = int(s,16); # returns the integer 26 #

print((k," => ", s, " => ", i, new line))

Output:

<pre>

 

=={{header|ALGOL W}}==

% returns with numberInBase set to the number n converted to a string in %

% the specified base. Number must be non-negative and base must be in %

write( 35, i, baseNumber, " ", convertFromBase( baseNumber, i ) );

end

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}

For more flexibility with digit variants (upper and lower case hex, digits in other languages/scripts etc) we can define '''toBase'''(intBase, n) in terms of a more general '''inBaseDigits'''(strDigits, n) which derives the base from the number of digits to be used:

on toBase(intBase, n)

if (intBase < 36) and (intBase > 0) then

end script

end if

{{Out}}

 

=={{header|AutoHotkey}}==

MsgBox % parse(200, 16) ; 512

 

}

Return result

alternate implementation contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276241.html#276241 forum]

MsgBox % ToBase(255,16)

 

FromBase(s,b) { ; convert base b number s=strings of 0..9,a..z, to AHK number

Return (L:=StrLen(s))=0 ? "":(L>1 ? FromBase(SubStr(s,1,L-1),b)*b:0) + ((c:=Asc(SubStr(s,0)))>57 ? c-87:c-48)

 

=={{header|AWK}}==

{

symbols = "0123456789abcdefghijklmnopqrstuvwxyz"

print strtol("7b", 16)

print ltostr(123, 16)

 

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

PRINT " 26 (decimal) -> " FNtobase(26, 16) " (base 16)"

PRINT "383 (decimal) -> " FNtobase(383, 16) " (base 16)"

A$ = MID$(A$,2)

UNTIL A$ = ""

'''Output:'''

<pre>

101111111 (base 2) -> 383 (decimal)

</pre>

 

=={{header|Bracmat}}==

=

. !arg:<10

& get$:~/#>1:~>36:?b

& out$(!n " in base " !b " is " str$(base$(!n.!b)))

 

=={{header|C}}==

#include <string.h>

#include <stdio.h>

char *to_base(int64_t num, int base)

{

 

 

 

 

}

 

long from_base(const char *num_str, int base)

{

}

 

int main()

{

<pre>-9223372036854775808 in base 2: -1000000000000000000000000000000000000000000000000000000000000000

383 in base 16: 17f</pre>

 

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

public static class BaseConverter {

 

 

}

 

=={{header|Caché ObjectScript}}==

 

{

 

ClassMethod ConvertBase10ToN(pNum As %Integer = "", pBase As %Integer = "", pBaseStr As %String = "", pPos As %Integer = 0) As %String

{

}

 

ClassMethod ConvertBaseNTo10(pStr As %String = "", pBase As %Integer = "", pBaseStr As %String = "", pPos As %Integer = 0) As %Integer

{

}

 

ClassMethod ConvertBase(pStr As %String = "", pFrom As %Integer = 10, pTo As %Integer = 10, pBaseStr As %String = "", pLen As %Integer = 0) As %String

{

}

 

ClassMethod PadStr(pStr As %String, pLen As %Integer, pZero As %String = 0) As %String [ Private ]

{

}

 

{{out|Examples}}

<pre>

 

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

 

Alternative implementation using FORMAT's ~R directive and #nR reader macro

(format nil (format nil "~~~dr" base) number))

 

(defun base-n-to-decimal (number &key (base 16))

 

Yet another approach uses FORMAT's ~R in conjunction with ~V for passing arguments to directives (this assumes input as string)

 

=={{header|D}}==

===Using Standard Functions===

 

void main() {

writeln(60_272_032_366.to!string(36, LetterCase.lower), ' ',

591_458.to!string(36, LetterCase.lower));

{{out}}

<pre>109517

 

===One Implementation===

 

immutable string mDigits = digits ~ lowercase;

writeln(itoaRadix(60_272_032_366, 36), " ",

itoaRadix(591_458, 36));

{{out}}

<pre>'1ABcdxyz???' (base 16) = 109517 Converted only: '1ABcd'

===Alternative Implementation===

{{trans|Haskell}}

 

alias Digits = ubyte[];

void main() {

"1ABcd".toDigits.fromBase(16).writeln;

{{out}}

109517

 

=={{header|E}}==

def integerToString(i :int, base :int) {

return i.toString(base)

 

# value: 512

 

? integerToString(200, 16)

 

=={{header|Elixir}}==

65535

iex(2)> Integer.to_string(255, 2)

"11111111"

iex(3)> String.to_integer("NonDecimalRadices", 36)

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

integer rem

sequence s

end for

return i

 

=={{header|Factor}}==

 

12345 16 >base .

 

=={{header|Forth}}==

Forth has a global user variable, BASE, which determines the radix used for parsing, interpretation, and printing of integers. This can handle bases from 2-36, but there are two words to switch to the most popular bases, DECIMAL and HEX.

2 base !

. \ 101010

hex

. \ 2A

 

Many variants of Forth support literals in some bases, such as hex, using a prefix

 

=={{header|Fortran}}==

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

IMPLICIT NONE

CHARACTER(36) :: alphanum = "0123456789abcdefghijklmnopqrstuvwxyz"

WRITE (*,*) ToBase(16, 26)

 

 

=={{header|FreeBASIC}}==

 

Function min(x As Integer, y As Integer) As Integer

Print

Print "Press any key to quit"

 

{{out}}

=={{header|FunL}}==

Converting from integer to string:

 

{{out}}

 

Converting from string to integer:

 

{{out}}

The standard <code>strconv</code> package functions <code>ParseInt</code>, <code>ParseUint</code>, <code>FormatInt</code>, <code>FormatUint</code>,

and the standard <code>math/big</code> package method <code>SetString</code>,

 

Note, there is no equivalent formatting function provided for a <code>big.Int</code>, only the standard bases are available via <code>fmt</code> integer formatting verbs

(binary <code>%b</code>, octal <code>%o</code>, decimal <code>%d</code>, and hexidecimal <code>%x</code> or <code>%X</code>).

 

import (

fmt.Println(b)

}

 

=={{header|Groovy}}==

Solution:

 

Test Program:

(2..Character.MAX_RADIX).each { radix ->

def value = radixParse(numString, radix)

assert valM2str == biggestDigit + biggestDigit

printf ("%3s (%2d) - 2 (10) == %4s (%2d)\n", numString, radix, valM2str, radix)

 

Output:

Using built-in functions to convert integer into string, and vice versa, at any base up to 16:

 

"2a"

Prelude> fst $ head $ Numeric.readInt 16 Char.isHexDigit Char.digitToInt "2a"

 

It's actually more useful to represent digits internally as numbers instead of characters, because then one can define operations that work directly on this representation.

So conversion to and from digits represented as 0-9 and a-z is done in an additional step.

 

import Data.Char

 

convert c | isDigit c = ord c - ord '0'

| isUpper c = ord c - ord 'A' + 10

 

Example:

 

"2a"

*Main> fromBase 16 $ fromAlphaDigits $ "2a"

 

 

If we want to assume a default character set, then a general '''toBase''' (Int -> Int -> String) can be also be derived from '''inBaseDigits'''.

 

 

inBaseDigits ds n =

let base = length ds

in reverse $

unfoldr

n

 

inLowerHex :: Int -> String

inLowerHex = inBaseDigits "0123456789abcdef"

inUpperHex :: Int -> String

inUpperHex = inBaseDigits "0123456789ABCDEF"

inBinary :: Int -> String

inBinary = inBaseDigits "01"

inOctal :: Int -> String

inOctal = inBaseDigits "01234567"

inDevanagariDecimal :: Int -> String

inDevanagariDecimal = inBaseDigits "०१२३४५६७८९"

inHinduArabicDecimal :: Int -> String

inHinduArabicDecimal = inBaseDigits "٠١٢٣٤٥٦٧٨٩"

toBase :: Int -> Int -> String

main :: IO ()

main =

, inHinduArabicDecimal

] <*>

 

{{Out}}

 

=={{header|HicEst}}==

 

num = 36^7 -1 ! 7836416410

temp = INT(temp / base)

ENDDO

 

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

Icon and Unicon natively take integers in radix form for bases 2 through 36. There is no need to convert to integer as the value will be coerced when needed. However, a conversion routine is needed to convert integers back into radix form.

 

every ( ns := "16r5a" | "-12r1a" ) &

( b := 8 | 12 | 16 ) do {

return p || reverse(s)

}

 

{{libheader|Icon Programming Library}}

=={{header|J}}==

J supports direct specification of native precision integers by base. The numbers are expressed as the base to be used (using base 10), the letter b, followed by the number itself. Following the initial letter b, other (lower case) letters represent "digts" 10 (a) through 35 (z), as in these examples:

 

Additionally, J has primitives [http://www.jsoftware.com/help/dictionary/d401.htm #.] and [http://www.jsoftware.com/help/dictionary/d402.htm #:] for dealing with base conversion issues.

 

Here are programs for conversion of numeric values to literals, and of literals to numbers:

baseNtoL=: numerals {~ #.inv

Examples of use:

1100100

1100101

1a

36 baseLtoN 'zy'

These may be combined so the conversion performed is derived from the type of argument received.

16 base 'aa'

170

16 base 170

See also primary verbs [http://www.jsoftware.com/help/dictionary/d401.htm Base] and [http://www.jsoftware.com/help/dictionary/d402.htm Antibase].

 

=={{header|Java}}==

for long's:

return Long.parseLong(num, oldBase); //takes both uppercase and lowercase letters

}

public static String tenToBase(long num, int newBase){

return Long.toString(num, newBase);//add .toUpperCase() for capital letters

 

for BigInteger's:

return new BigInteger(num, oldBase); //takes both uppercase and lowercase letters

}

public static String tenBigToBase(BigInteger num, int newBase){

return num.toString(newBase);//add .toUpperCase() for capital letters

 

=={{header|JavaScript}}==

===ES5===

s = k.toString(16) //gives 1a

i = parseInt('1a',16) //gives 26

//optional special case for hex:

 

Converts a number of arbitrary length from any base to any base

Limitation: Any base or number that causes accumulator to overflow will lose precision!!

Debugging or following the process is easy as it is kept in the expected base string format and order.

var baselist = "0123456789abcdefghijklmnopqrstuvwxyz", listbase = [];

for(var i = 0; i < baselist.length; i++) listbase[baselist[i]] = i; // Generate baselist reverse

return to.join('');

}

Using BigInteger, can convert any base.

// Tom Wu jsbn.js http://www-cs-students.stanford.edu/~tjw/jsbn/

var baselist = "0123456789abcdefghijklmnopqrstuvwxyz", listbase = [];

return to.join('');

}

 

===ES6===

For more flexibility with digit variants (upper and lower case hex, digits in other languages/scripts etc) we can define '''toBase'''(intBase, n) in terms of a more general '''inBaseDigits'''(strDigits, n) which derives the base from the number of digits to be used.

 

'use strict';

 

devanagariDecimal: inDevanagariDecimal(n)

}));

 

{{Out}}

"devanagariDecimal": "२४०"

}</pre>

 

=={{header|jq}}==

def convert(base):

def stream:

| if base < 10 then map(tostring) | join("")

elif base <= 36 then map(if . < 10 then 48 + . else . + 87 end) | implode

else error("base too large")

 

# input string is converted from "base" to an integer, within limits

# state: [power, ans]

([1,0]; (.[0] * base) as $b | [$b, .[1] + (.[0] * $c)])

'''Example''':

("ff" | to_i(16)),

{{Out}}

$jq -M -r -n -f Non-decimal_radices.jq

 

=={{header|Julia}}==

<pre>

</pre>

 

An approach from first principles rather than using Java library functions:

{{trans|FreeBASIC}}

 

fun min(x: Int, y: Int) = if (x < y) x else y

println("36 base $f = ${s.padEnd(6)} -> base $f = ${convertToDecimal(s, b)}")

}

 

{{out}}

 

Converting decimal numbers 26 and 3000 in LFE, using some different mechanisms:

> (: erlang list_to_integer '"1a" 16)

26

> (: erlang integer_to_list 3000 2)

"101110111000"

 

=={{header|Liberty BASIC}}==

 

global alphanum$

next i

end function

 

=={{header|Lua}}==

Only had to write 'dec2base' as the reverse is provided by the in-built function 'tonumber'

result = digit .. result

return result

end

local x = dec2base(16, 26)

print(x) --> 1a

 

=={{header|M4}}==

define(`frombase',`eval(0r$2:$1)')

 

Output:

 

=={{header|Maple}}==

to_base := proc(num, based)

end proc:

 

#find the location of char in chart

find_digit := proc(char)

end proc:

 

#converts a string with given base to a number

from_base := proc(str, base)

{{Out|Usage}}

<pre>

</pre>

 

Use the built-in functions IntegerString[] and FromDigits[]:

<pre>"1a"

26</pre>

 

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

Use the built-in functions base2dec() and dec2base():

 

Output:

=={{header|МК-61/52}}==

<pre>

</pre>

 

=={{header|NetRexx}}==

In NetRexx numbers are held as Rexx strings so you can take advantage of Java's BigInteger to do radix conversions.

options replace format comments java crossref symbols nobinary

 

bi = BigInteger(val.toString(), 10)

return bi.toString(radix)

'''Output:'''

<pre>

Error -- Input: z, radix: 37

java.lang.NumberFormatException: Radix out of range

</pre>

 

=={{header|Nim}}==

 

proc reverse(a: string): string =

 

for i in first .. str.high:

result = result * base + digits.find c

 

 

echo 26.toBase 16

Output:

<pre>1a

 

=={{header|OCaml}}==

match n with

| 16 -> int_of_string("0x" ^ str)

| 16 -> Printf.sprintf "%x" d

| 8 -> Printf.sprintf "%o" d

 

# basen_of_int 16 26 ;;

- : int = 26

 

 

in

 

Example:

<pre>

</pre>

 

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

my(s="",t);

while(n,

);

t

 

=={{header|Pascal}}==

{{libheader| Math SysUtils}}

{{works with|Free_Pascal}}

 

uses

writeln ('26: ', ToBase(16, 26));

end.

Output:

<pre>% ./Convert

=={{header|Perl}}==

For base 2 and 16, we can do this entirely with language features:

sub to16 { sprintf "%x", shift; }

sub from2 { unpack("N", pack("B32", substr("0" x 32 . shift, -32))); }

 

Small functions will handle arbitrary base conversions for bases 2-36:

my($n,$b) = @_;

my $s = "";

}

sub base_from {

}

$t;

 

There are a plethora of modules that perform base conversion.

 

The core [https://metacpan.org/pod/distribution/perl/ext/POSIX/lib/POSIX.pod POSIX] module includes strtol (and strtoul) which is simple and fast, but only does conversions from a base. On some platforms the function may be limited to 32-bit even with a 64-bit Perl.

my ($num, $n_unparsed) = strtol('1a', 16);

$n_unparsed == 0 or die "invalid characters found";

 

The [https://metacpan.org/pod/ntheory ntheory] module includes functions that will perform base conversion, and is fast. It supports bases up to 36 and bigints.{{libheader|ntheory}}

my $n = 65261;

my $n16 = todigitstring($n, 16) || 0;

my $n10 = fromdigits($n16, 16);

 

Other modules include but are not limited to:

 

The module [https://metacpan.org/pod/Math::Fleximal Math::Fleximal] not only does very arbitrary base conversion, but allows computations in different bases.

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|PHP}}==

PHP has a base_convert() function that directly converts between strings of one base and strings of another base:

 

If you want to convert a string to an integer, the intval() function optionally takes a base argument when given a string:

 

To go the other way around, I guess you can use base_convert() again; I am unaware of a better way:

 

In addition, there are specialized functions for converting certain bases:

decbin(26); // returns "11010"

// converts int to octal string

octdec("32"); // returns 26

// converts hex string to int

 

=={{header|PicoLisp}}==

(default Base 10)

(let L NIL

(prinl (numToString 26 16))

(prinl (stringToNum "1a" 16))

Output:

<pre>"1a"

26

"byw97um9s91dlz68tsi"</pre>

 

=={{header|Pop11}}==

built-in procedures:

 

radix_apply(n, '%p', sprintf, base);

 

In input base optionally preceeds the number, for example

to prepend base prefix and read number from string:

 

incharitem(stringin(base >< ':' >< s))();

=={{header|PureBasic}}==

#maxIntegerBitSize = SizeOf(Integer) * 8

Input()

CloseConsole()

Sample output:

<pre>26

===Python: string to number===

Converting from string to number is straight forward:

 

===Python: number to string===

;Recursive:

 

 

;Iterative:

 

 

def baseN(num, b):

result = []

num, d = divmod(num, b)

 

;Sample run from either:

<pre>In [1: baseN(26, 16)

Out[1]: '1a'</pre>

 

=={{header|R}}==

 

 

int2str <- function(x, b) {

}

 

str2int <- function(s, b) {

}

 

str2int("1a", 16)

 

 

=={{header|Racket}}==

 

#lang racket

 

(printf "~s -> ~a#~a -> ~a => ~a\n" N S r M (if (= M N) 'OK 'BAD)))

;; (random-test)

 

=={{header|REXX}}==

 

No &nbsp; ''number-conversion'' &nbsp; BIFs &nbsp; (<u>B</u>uilt-<u>I</u>n <u>F</u>unctions) &nbsp; were used in this REXX program.

@abc = 'abcdefghijklmnopqrstuvwxyz' /*lowercase (Latin or English) alphabet*/

parse upper var @abc @abcU /*uppercase a version of @abc. */

/* [↑] all characters must be viewable*/

numeric digits 3000 /*what da hey, support gihugeic numbers*/

parse arg x toB inB 1 ox . 1 sigX 2 x2 . /*obtain: three args, origX, sign ··· */

else sigX= /*Nope. No leading sign for the X value*/

if x=='' then call erm /*if no X number, issue an error msg.*/

#=0 /*result of converted X (in base 10).*/

do j=1 for length(x) /*convert X: base inB ──► base 10. */

if _==0 | _>inB then call erd x /*is _ character an illegal numeral? */

end /*j*/ /* [↑] this also verifies digits. */

y= /*the value of X in base B. */

do while # >= toB /*convert #: base 10 ──► base toB.*/

end /*while*/ /* [↑] algorithm may leave a residual.*/

/* [↓] Y is the residual. */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

erd: call ser 'illegal digit/numeral ['?"] in: " x

erm: call ser 'no argument specified.'

<pre>

7fffffff (base 16) is 2147483647 (base 10)

</pre>

<pre>

4095 (base 10) is 111111111111 (base 2)

</pre>

<pre>

100 (base 2) is 11 (base 3)

</pre>

<pre>

</pre>

 

=={{header|Ring}}==

# Project : Non-decimal radices/Convert

 

next

return binsum

Output:

<pre>

17f (base 16) -> 383 (decimal)

101111111 (base 2) -> 383 (decimal)

</pre>

 

=={{header|Ruby}}==

This converts strings from any base to any base up to base 36.

def convert_base(from, to)

Integer(self, from).to_s(to)

p "50664".convert_base(7, 10) # =>"12345"

p "1038334289300125869792154778345043071467300".convert_base(10, 36) # =>"zombieseatingdeadvegetables"

 

=={{header|Run BASIC}}==

basCvt$ ="0123456789abcdefghijklmnopqrstuvwxyz"

html "<table border=1><tr bgcolor=wheat align=center><td>Decimal</td><td>To Base</td><td>Num</td><td>to Dec</td></tr>"

toDecimal = toDecimal * b + instr(basCvt$,mid$(s$,i,1),1) -1

next i

<table border=1>

<tr bgcolor=wheat align=center><td>Decimal</td><td>To Base</td><td>Num</td><td>to Dec</td></tr>

<tr align=right><td> 71</td><td> 34</td><td>23</td><td>71</td></tr>

<tr align=right><td> 61</td><td> 23</td><td>2f</td><td>61</td></tr></table>

 

=={{header|Scala}}==

 

 

=={{header|Seed7}}==

for corresponding purposes.

 

include "bigint.s7i";

writeln(bigInteger("rosetta", 36)); # Convert string to bigInteger

writeln(integer("code", 36)); # Convert string to integer

 

{{out}}

=={{header|Sidef}}==

Built-in:

 

User-defined:

{{trans|Perl}}

static from = Hash(to.pairs.map{@|_}.flip...)

 

 

say base_from("rosetta", 36) # string to number

 

=={{header|Slate}}==

 

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

{{trans|Haskell}}

 

fun toBase' (a, 0) = a

| toBase' (a, v) = toBase' (v mod b :: a, v div b)

in

map convert o explode

 

Example:

=={{header|Swift}}==

Converting integer to string:

 

Converting string to integer:

func string2int(s: String, radix: Int) -> Int {

return strtol(s, nil, Int32(radix))

// there is also strtoul() for UInt, and strtoll() and strtoull() for Int64 and UInt64, respectively

}

 

=={{header|Tcl}}==

Tcl <code>scan</code> and <code>format</code> commands can convert between decimal, octal and hexadecimal, but this solution can convert between any arbitrary bases.

variable chars "0123456789abcdefghijklmnopqrstuvwxyz"

namespace export baseconvert

baseconvert 12345 10 23 ;# ==> 107h

baseconvert 107h 23 7 ;# ==> 50664

 

=={{header|Ursala}}==

A function parameterized by the base b performs the conversion in each direction.

Folding (=>), iteration (->), and reification (-:) operators among others are helpful.

#import nat

 

num_to_string "b" = ||'0'! (-: num digits--letters)*+ @NiX ~&r->l ^|rrPlCrlPX/~& division\"b"

 

This test program performs the conversions in both directions for a selection of numbers

in base 8 and base 32.

 

#cast %sLnLUL

string_to_num32* num_to_string32* test_data,

num_to_string8* test_data,

output:

<pre>

 

=={{header|VBA}}==

Dim digits As String, result As String

Dim i As Integer, digit As Integer

Public Sub Non_decimal_radices_Convert()

Debug.Print "26 decimal in base 16 is: "; to_base(26, 16); ". Conversely, hexadecimal 1a in decimal is: "; from_base("1a", 16)

=={{header|Wolframalpha}}==

input box: 1801 decimal to base 16<br>

input box: (99 base 12)+(77 base 8)<br>

This is Mathematica but is worth showing distinctly. Result provides endian choice and other bases typically.

 

=={{header|XPL0}}==

string 0; \use zero-terminated string convention

 

IntOut(0, Str2Num("1a", 16)); CrLf(0);

IntOut(0, Str2Num("deadbeef", 16)); CrLf(0);

 

Output:

=={{header|zkl}}==

The toInt(base) and toString(base) methods do this. base is 2..36

In addition, string format is able to convert to a base: