logic.py

def ln(number, *, precision=20):
    """
    This function calculates the natural logarithm of a number using the properties of logarithms and the Taylor series.
    The input number is decomposed into a product of a scaling factor and a power of two using the decomposer function.
    The Taylor series is then used to calculate the natural logarithm of the scaling factor, and the natural logarithm of the power of two is added to this result.
    """
    exponent, scalingFactor = decomposer(number)
    def HornersScheme(num):
        output = 0
        for iteration in range(precision, 0, -1):
            output = num * (1 / iteration - output)
        return output
    return exponent * 0.6931471805599453 + HornersScheme(scalingFactor - 1)

def decomposer(number):
    """
    Decomposes the input into a power of two if it's larger than 1/2.
    """
    exponent = 0
    while (abs(number) > 1):
        number /=2
        exponent += 1
    return exponent, number


def lnOptimized(num, *, precision=20):
    """
    Computes the natural logarithm. [precision] determines the number of terms included in the Taylor series to approximate
    the ln function.
    """
    fraction = (num - 1) / (num + 1)
    return sum([2 / (2 * n + 1) * fraction**(2 * n + 1) for n in range(precision)])

def logBase(number, base, *, precision=20):
    """
    This function calculates the logarithm of a number to any base using the properties of logarithms and the Taylor series.
    The input number is decomposed into a product of a scaling factor and a power of two using the decomposer function.
    The Taylor series is then used to calculate the natural logarithm of the scaling factor, and the natural logarithm of the power of two is added to this result.
    Finally, it uses the change of base formula to calculate the logarithm to the desired base.
    """
    return lnOptimized(number, precision=precision) / lnOptimized(base, precision=precision)