Converting float from arbitrary base to arbitrary base I needed to write a small program to convert floats from any base to any other base. The thing is, it got big. I know there are other ways to implement the conversions (such as doing subtractions instead of divisions), but isn't there a more simple way to do the whole process? I feel like I'm missing something. Any optimization tips are welcome as well.

import string
symbols = string.digits + string.uppercase

def _int_from_base(number, original_base):

    return int(number, original_base)

def _int_to_base(number, new_base):

    # Uses "the division method"
    sign = -1 if number &lt; 0 else 1
    number *= sign
    ans = ''
    while number:
        ans += symbols[number % new_base]
        number //= new_base
    if sign == -1:
        ans += '-'
    return ans[::-1]

def _fractional_from_base(number, original_base):

    # The value of a symbol at position i after the decimal point is, by 
    # definition, the value of that symbol * b^-i
    ans = 0
    for i in xrange(1, len(number)+1):
        ans += symbols.index(number[i-1]) * original_base**-i
    return ans

def _fractional_to_base(number, new_base, precision=5):

    # I don't know what this method is called
    ans = ''
    for i in xrange(precision):
        tmp = number * new_base
        itmp = int(tmp)
        ans += str(symbols[itmp])
        number = tmp - itmp
    return ans

def convert(number, original_base, new_base, precision=None):
    """Converts any number from any base to any other base (2 &lt;= base &lt;= 36).

    number should be a string representing a float in any base, e.g. '1.23'.

    original_base, new_base should be integers representing the desired bases.

    precision should be an integer representing how many digits after the 
    decimal point will be calculated on the conversion. Default is the same 
    number as the number of digits after the decimal point on number.
    """

    try:
        integer_part, fractional_part = number.split('.')
        precision = len(fractional_part) if precision is None else precision
        integer_part = _int_to_base(
            _int_from_base(integer_part, original_base),
            new_base
        )
        fractional_part = _fractional_to_base(
            _fractional_from_base(fractional_part, original_base),
            new_base,
            precision
        )
        return integer_part+'.'+fractional_part
    except ValueError:      # number was a str representing an int not a float
        return _int_to_base(_int_from_base(number, original_base), new_base)


I didn't test it thoroughly but it seems to work. A few test cases:

&gt;&gt;&gt; a = convert('632.6442', 10, 2);a # Loss of info. is expected
'1001111000.1010'
&gt;&gt;&gt; convert(a, 2, 10)
'632.6250'

&gt;&gt;&gt; b = convert('222.0', 3, 16);b
'1A.0'
&gt;&gt;&gt; convert(b, 16, 3)
'222.0'
It is not necessary to deal separately with the integral and fractional parts.


When converting from string, remove the point, convert as integer and scale according to the position where the point was.
When converting to string, scale to integer, convert and insert point in the right place.


Here's how you can implement convert with _int_to_base as the only helper function:

def convert(number, original_base, new_base, precision=None):
    #from original_base
    integral, point, fractional = number.strip().partition('.')
    num = int(integral + fractional, original_base) * original_base ** -len(fractional)

    #to new_base
    precision = len(fractional) if precision is None else precision
    s = _int_to_base(int(round(num / new_base ** -precision)), new_base)
    if precision:
        return s[:-precision] + '.' + s[-precision:]
    else:
        return s