Non-decimal radices/Convert: Difference between revisions

=={{header|11l}}==

Converting from string to number:

 

Converting from number to string:

 

=={{header|8086 Assembly}}==

Be it a bug or otherwise "unintended" behavior, the <code>AAD</code> instruction, which was meant to convert unpacked binary-coded decimal values to hex to allow for division, has a "secret" operand that most assemblers did not support at the time. Typing <code>AAD</code> into your assembler would place the hex values <code>D5 0A</code> in your program. The <code>0A</code> (hexadecimal equivalent of decimal 10) actually represents the base, and can be used to convert between bases in a roundabout way. Unpacked binary-coded decimal (also known as ASCII binary coded decimal) only uses the bottom four bits of each byte, so for example a number like <code>0x0103</code> represents decimal 13.

 

mov al,00h ;this is the unpacked encoding of octal "20" aka 10 in hexadecimal, 16 in decimal. Ignore the leading zeroes.

 

The result is that <code>AX</code> now equals <code>0x0010</code>.

The <code>AAM</code> instruction (ASCII Adjust for Multiplication) has a similar "feature." You'll need to inline the bytecode <code>D4 ??</code> where ?? is your desired base. These two can be used in combination to switch from hexadecimal to binary coded decimal without needing a lookup table or multiplication.

 

aam

 

The result is that <code>AX = 0x0016</code>. This effectively lets us convert a hexadecimal value to one that "looks like" its decimal equivalent, albeit the logic only holds for 8-bit values. (This is a useful technique for printing numbers to the screen in decimal.)

 

=={{header|ACL2}}==

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

(char<= chr #\9))

 

(defun show-num (num base)

 

=={{header|Action!}}==

 

PROC CheckBase(BYTE b)

PrintF("%U -> base %B %S -> %U%E",v,b,s,v2)

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Non-decimal_radices_convert.png Screenshot from Atari 8-bit computer]

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

 

if base=2 [ return from.binary x ]

if base=8 [ return from.octal x ]

print ["101 => from base2:" fromBase "101" 2 "from base8:" fromBase "101" 8 "from base16:" fromBase "101" 16]

print ["123 => from base8:" fromBase "123" 8 "from base16:" fromBase "123" 16]

 

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

 

=={{header|BCPL}}==

 

// Reverse a string

for base=10 to 36 do

writef("Base %I2: %N*N", base, atoi("25", base))

{{out}}

<pre style='height:50ex;'>1234 in bases 2-36:

 

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

printf("%lld in base 16: %s\n", x, to_base(x, 16));

return 0;

<pre>-9223372036854775808 in base 2: -1000000000000000000000000000000000000000000000000000000000000000

383 in base 16: 17f</pre>

 

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

public static class BaseConverter {

 

 

}

 

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

#include <cstdlib>

#include <algorithm>

result = result * base + digits.find(num_str[pos]);

return result;

 

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

 

{

 

}

 

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

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

 

import Data.List (unfoldr)

import Data.Tuple (swap)

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

@show string(185, base=2)

@show string(185, base=3)

@show string(185, base=15)

@show string(185, base=16)

<pre>

string(185, base = 2) = "10111001"

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

Module Checkit {

k$=lambda$ (m, b as integer=16) -> {

}

Checkit

Output:

<pre>

 

=={{header|M4}}==

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

 

Output:

 

=={{header|Maple}}==

to_base := proc(num, based)

local i;

end do;

return result;

{{Out|Usage}}

<pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

{{out}}

<pre>"1a"

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

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

 

Output:

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

 

=={{header|Nim}}==

 

proc reverse(a: string): string =

 

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:

 

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

 

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

convert: procedure (N, base) returns (character (64) varying) recursive;

declare N fixed binary (31), base fixed binary;

return (s || table(mod(N, base)) );

end convert;

 

=={{header|PL/M}}==

 

/* CONVERT A NUMBER TO A GIVEN BASE */

 

CALL EXIT;

{{out}}

<pre style='height:50ex;'>1234 IN BASES 2-36:

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:

 

def baseN(num, b):

 

;Iterative:

 

 

def baseN(num, b):

result.append(digits[d])

result.append(digits[num])

 

;Sample run from either:

=={{header|Quackery}}==

 

 

number$

base release

witheach

 

 

{{out}}

 

 

 

 

=={{header|R}}==

 

 

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

(formerly Perl 6)

+":$base\<$str>";

}

sub to-base(Real $num, Int $base) {

$num.base($base);

 

=={{header|REXX}}==

└─┐ of 10 to be used. The limits of bases are: 2 ──► 90. ┌─┘

└────────────────────────────────────────────────────────────────────┘

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

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

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

erm: call ser 'no argument specified.'

{{out|output|text=&nbsp; when input is expressed in hexadecimal &nbsp; (maximum positive integer in a signed 32-bit word): &nbsp; &nbsp; <tt> 7fffffff &nbsp; , &nbsp; 16 </tt>}}

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

and hexadecimal base).

 

assert!(2 <= radix && radix <= 36);

 

println!("{}", u32::from_str_radix("DeadBeef", 16)?);

Ok(())

 

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

Integer readFrom:'1A' radix:16 -> 26

 

'radix %2d: %s\n' printf:{radix . 100 printStringRadix:radix } on:Transcript.

].

{{out}}

<pre>radix 2: 1100100

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

{{libheader|Wren-fmt}}

The methods Conv.itoa and Conv.atoi in the above module provide the required functionality.

 

System.print(Conv.itoa(26, 16))

 

{{out}}

 

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