Though Maple provides routines to express integers or floating in different
integer bases the output looks not as nice as I want to have it.
And for example it does not work as expected using the 'simple ways' (while
for hex there is no simple way for floats):
Digits:=16; # for all the following
x:=frac(evalf(Pi)):
x:= x* SFloat(1,-14);
-14
x := 0.141592653589793 10
xxx:=convert(x, octal);
`error`[absolute, relative] = x -xxx, 1 - xxx/x;
-16
xxx := 0.3000000000000000 10
-14
error[absolute, relative] = 0.1385926535897930 10 , 0.9788124600822068
Very messy and for smaller values that would give 0 :-)
And (working with the classical interface) I always wanted a multiplication
in outputs, which I find more easy to read for humans (those who do not want
that will just omit the according step).
convert([183], 'bytes'): # ASCII 183
theDot:=parse(%); #lprint(%);
theDot := ·
Now (currently using Maple 12) the following seems to give me what I want,
converting a number (in base=10) into its presentation in a new base 'b'
in nice form (well, if it is not too long ... positives are enough):
convert_base:=proc(X::And(nonnegative,{float, integer, fraction}), b::posint)
global theDot;
local bName, L, intPart, fracPart, k, x, oldBase, newBase, n, p,m,M;
if b=1 then error "invalid base = %1 (must be larger than 2)", b end if;
bName:=convert(b, name);
# integer part
L:=convert(trunc(X), base, b);
intPart:= sum( 'L'[k]* bName^(k-1),k=1.. nops(L));
# convert first (=left) argument in multiplications to a name,
# then concatenate with theDot, finally multiply again
intPart:= subsindets(intPart, '`*`',
't -> cat(convert(op(1,t),name), theDot) * op(2,t)');
# fractional part
x:=frac(X);
if (x=0) then return intPart end if;
oldBase:=10;
newBase:=b;
n := ceil(ln(oldBase^Digits)/ln(newBase)); # new Digit length for new base
p:=floor( log[b](x/b^(n-1)) );
m:= floor( x/b^(p) );
M:=convert(m, base, b);
# here add gives the better sorting
fracPart:=bName^p * add( M[k]*bName^(k-1),k=1.. nops(M));
return intPart + sort(expand(fracPart));
end proc; #maplemint(%);
Converting such expressions back to decimal notation then is done by
convert_decimal:=proc(x_in_some_BASE)
global theDot;
convert(x_in_some_BASE, string):
StringTools:-SubstituteAll(%, theDot, ""):
StringTools:-SubstituteAll(%, "`", ""):
parse(%);
end proc;
For the above example that gives a correct transform:
convert_base(x, 8);
convert_decimal(%);
xx:=evalf(%);
`error`[absolute, relative] = x -xx, 1 - xx/x;
-14
xx := 0.1415926535897930 10
error[absolute, relative] = 0., 0.
Some more examples:
x:=3;
convert_base(x, 2);
convert_decimal(%);
x := 3
1 + 2
3
This is, because convert/name is used, so 1+2 not immediately gives 3
x:=0.125+10.^5-1;
convert_base(x, 32);
convert_decimal(%);
xx:=evalf(%);
`error`[absolute, relative] = x -xx, 1 - xx/x;
x := 99999.125
2 3 4
31 + 20· 32 + 32 + 3· 32 + ----
32
One sees some multiplication sign (but only, if it is not 1*term),
the error is zero (in that precision).
x:=frac(evalf(Pi));
convert_base(x, 16);
convert_decimal(%);
xx:=evalf(%);
`error`[absolute, relative] = x -xx, 1 - xx/x;
-15 -15
error[absolute, relative] = 0.1 10 , 0.7 10
Note that convert(x,hex) here would result in an error message.
And it works on fractions
x:=3 + 1/2^51;
convert_base(x, 2);
convert_decimal(%);
xx:=evalf(%);
`error`[absolute, relative] = x -xx, 1 - xx/x;
6755399441055745
x := ----------------
2251799813685248
1
1 + 2 + ---
51
2
6755399441055745
----------------
2251799813685248
xx := 3.000000000000000
-15
error[absolute, relative] = 0., 0.2 10
