Metadata-Version: 1.1
Name: baseconvert
Version: 1.0.0a1
Summary: Convert numbers between bases.
Home-page: https://github.com/squdle/baseconvert.git
Author: Joshua Deakin
Author-email: contact@joshuadeakin.com
License: MIT
Description: baseconvert
        ===========
        
        Convert any rational number, from any (positive integer) base, to any
        (positive integer) base. Output numbers as tuple or string.
        
        -  Any rational number
        -  Arbitrary precision
        -  Fractions
        -  Recurring/repeating fractional digits.
        -  Input numbers as tuple or string or number.
        -  Output numbers as tuple or string.
        
        MIT License (MIT) Copyright (c) 2016 Joshua Deakin
        
        `github <https://github.com/squdle/baseconvert>`__
        
        contact@joshuadeakin.com
        
        Requires
        --------
        
        -  Python 3
        
        Install / Uninstall
        -------------------
        
        Install:
        
        ::
        
            pip install baseconvert
        
        Uninstall:
        
        ::
        
            pip uninstall baseconvert
        
        Quickstart
        ----------
        
        ::
        
            # base(number, input_base, output_base)
        
            >>> base((15, 15, 0, ".", 8), 16, 10)
            (4, 0, 8, 0, '.', 5)
        
            >>> base("FF0.8", 16, 10, string=True)
            '4080.5'
        
            >>> base("4080.5", 10, 16, string=True)
            'FF0.8'
        
        Or from command line
        
        ::
        
             $ echo 4080.5 | python -m baseconvert -i 10 -o 16
             FF0.8
        
             $ python -m baseconvert -n 4080.5 -i 10 -o 16
             FF0.8
        
        Tuple representation
        --------------------
        
        Numbers are represented as a sequence of digits. Each digit is a base-10
        integer value. The radix point, which separates the integer and
        fractional parts, is denoted by a string period.
        
        ::
        
             (int, int, int, ... , '.', ... , int, int, int)
             (   integer part    , '.',  fractional part   )
        
        String representation
        ---------------------
        
        String digits (after z the values are in ascending Unicode):
        
        ::
        
            0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
        
            |  Value  | Representation |
            |---------|----------------|
            |  0 -  9 |    0  -  9     |
            | 10 - 53 |    A  -  Z     |
            | 36 - 61 |    a  -  z     |
            | 62 +    | unicode 123 +  |
        
            For bases higher than 61 it's recommended to use tuple representation.
        
        Examples
        --------
        
        ::
        
            # base(number, input_base, output_base)
            >>> n = (15,15,".",0,8)
            >>> base(n, 16, 10)
            (2, 5, 5, '.', 0, 3, 1, 2, 5)
            >>> base(n, 16, 10, string=True)
            '255.03125'
        
            >>> base("FF.08", 16, 10) == base((15,15,".",0,8), 16, 10)
            True
        
            # A callable BaseConverter object can also be created.
            # This is useful for when several numbers need to be converted.
        
            >>> b = BaseConverter(input_base=16, output_base=8)
            >>> b("FF")
            (3, 7, 7)
            >>> b((15, 15))
            (3, 7, 7)
            >>> b("FF") == b((15,15))
            True
        
            >>> base(0.1, 3, 10, string=True)
            '0.[3]'
        
        Recurring digits
        ~~~~~~~~~~~~~~~~
        
        Recurring digits at the end of a fractional part will be enclosed by "["
        and "]" in both string and tuple representation. This behavior can be
        turned off by setting the recurring argument of base or BaseConverter
        object to False.
        
        ::
        
            >>> base("0.1", 3, 10, string=True)
            '0.[3]'
            >>> base("0.1", 3, 10, string=True, recurring=False)
            '0.3333333333'
        
        Max fractional depth
        ~~~~~~~~~~~~~~~~~~~~
        
        Integer parts are always of arbitrary size. Fractional depth (number of
        digits) can must be specified by setting the max\_depth argument of base
        or a BaseConverter object (default 10).
        
        ::
        
            >>> base("0.2", 10, 8)
            (0, '.', 1, 4, 6, 3, 1, 4, 6, 3, 1, 4)
            >>> base("0.2", 10, 8, max_depth=1)
            (0, '.', 1)
        
Keywords: base bases radix numeral system number hex dec bin hexidecimalbinary decimal fraction fractions integer convert
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.0
Classifier: Programming Language :: Python :: 3.1
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Topic :: Education
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Intended Audience :: Education
Classifier: License :: OSI Approved :: MIT License
