Mapytex/pymath/calculus/fraction.py

#!/usr/bin/env python
# encoding: utf-8

from .arithmetic import gcd
from .generic import isNumber, postfix_op
from .operator import op
from .expression import Expression
from .explicable import Explicable
from copy import copy


__all__ = ['Fraction']


class Fraction(Explicable):
    """Fractions!"""

    def __init__(self, num, denom=1):
        """To initiate a fraction we need a numerator and a denominator

        :param num: the numerator
        :param denom: the denominator

        """
        self._num = num
        if denom == 0:
            raise ZeroDivisionError("Can't create Fraction: division by zero")
        self._denom = denom

        self.isNumber = 1
        pstf_tokens = self.compute_postfix_tokens()
        super(Fraction, self).__init__(pstf_tokens)

    def simplify(self):
        """Simplify the fraction

        :returns: steps to simplify the fraction or the fraction if there is nothing to do

        >>> f = Fraction(3, 6)
        >>> f.simplify()
        < Fraction 1 / 2>
        >>> for i in f.simplify().explain():
        ...     print(i)
        \\frac{ 3 }{ 6 }
        \\frac{ 1 \\times 3 }{ 2 \\times 3 }
        \\frac{ 1 }{ 2 }
        >>> f = Fraction(6,9)
        >>> f.simplify()
        < Fraction 2 / 3>
        >>> for i in f.simplify().explain():
        ...     print(i)
        \\frac{ 6 }{ 9 }
        \\frac{ 2 \\times 3 }{ 3 \\times 3 }
        \\frac{ 2 }{ 3 }
        >>> f = Fraction(0,3)
        >>> f.simplify()
        0

        """
        ini_step = [Expression(self.postfix_tokens)]

        if self._num == 0:
            return Expression([0]).simplify()

        elif isinstance(self._num, Fraction) or isinstance(self._denom, Fraction):
            return self._num / self._denom

        elif self._denom < 0:
            n_frac = Fraction(-self._num, -self._denom)
            ans = n_frac.simplify()
            ans.this_append_before(ini_step)
            return ans

        gcd_ = gcd(abs(self._num), abs(self._denom))
        if gcd_ == self._denom:
            n_frac = self._num // gcd_
            return Expression([n_frac]).simplify()

        elif gcd_ != 1:
            n_frac = Fraction(self._num // gcd_, self._denom // gcd_)
            ini_step += [Expression([n_frac._num, gcd_, op.mul,
                                     n_frac._denom, gcd_, op.mul,
                                     op.div])]

            n_frac.this_append_before(ini_step)
            return n_frac

        else:
            return copy(self)

    def compute_postfix_tokens(self):
        """Postfix form of the fraction

        >>> f = Fraction(3, 5)
        >>> f.postfix_tokens
        [3, 5, /]

        """
        if self._denom == 1:
            return [self._num]
        else:
            return [self._num, self._denom, op.div]

    def __str__(self):
        return str(Expression(self.postfix_tokens))

    def __repr__(self):
        return "< Fraction {num} / {denom}>".format(
            num=self._num, denom=self._denom)

    def __float__(self):
        return self._num / self._denom

    def convert2fraction(self, other):
        """ Convert a other into a fraction """
        if isinstance(other, Fraction):
            # cool
            number = other
        else:
            number = Fraction(other)

        return number

    def __add__(self, other):
        """ overload +

        >>> f = Fraction(1, 2)
        >>> g = Fraction(2, 3)
        >>> f + g
        < Fraction 7 / 6>
        >>> print("\\n".join([repr(i) for i in (f+g).steps]))
        < Expression [1, 2, /, 2, 3, /, +]>
        < Expression [1, 3, *, 2, 3, *, /, 2, 2, *, 3, 2, *, /, +]>
        < Expression [3, 6, /, 4, 6, /, +]>
        < Expression [< Fraction 3 / 6>, < Fraction 4 / 6>, +]>
        < Expression [3, 6, /, 4, 6, /, +]>
        < Expression [3, 4, +, 6, /]>
        >>> f + 2
        < Fraction 5 / 2>
        >>> print("\\n".join([repr(i) for i in (f+2).steps]))
        < Expression [1, 2, /, 2, +]>
        < Expression [1, 1, *, 2, 1, *, /, 2, 2, *, 1, 2, *, /, +]>
        < Expression [1, 2, /, 4, 2, /, +]>
        < Expression [< Fraction 1 / 2>, < Fraction 4 / 2>, +]>
        < Expression [1, 2, /, 4, 2, /, +]>
        < Expression [1, 4, +, 2, /]>
        >>> f = Fraction(3, 4)
        >>> g = Fraction(5, 4)
        >>> f + g
        2
        >>> print("\\n".join([repr(i) for i in (f+g).steps]))
        < Expression [3, 4, /, 5, 4, /, +]>
        < Expression [3, 5, +, 4, /]>
        < Expression [8, 4, /]>
        >>> f+0
        < Fraction 3 / 4>
        >>> (f+0).steps
        []

        """

        if other == 0:
            return copy(self)

        number = self.convert2fraction(other)

        if self._denom == number._denom:
            com_denom = self._denom
            num1 = self._num
            num2 = number._num

            exp = Expression([num1, num2, op.add, com_denom, op.div])

        else:
            gcd_denom = gcd(self._denom, number._denom)
            coef1 = number._denom // gcd_denom
            coef2 = self._denom // gcd_denom

            exp = Expression([self._num,
                              coef1,
                              op.mul,
                              self._denom,
                              coef1,
                              op.mul,
                              op.div,
                              number._num,
                              coef2,
                              op.mul,
                              number._denom,
                              coef2,
                              op.mul,
                              op.div,
                              op.add])

        ans = exp.simplify()
        ini_step = Expression(self.postfix_tokens +
                              number.postfix_tokens + [op.add])
        ans.this_append_before([ini_step])
        return ans

    def __radd__(self, other):
        if other == 0:
            return Expression(self.postfix_tokens)

        number = self.convert2fraction(other)

        return number + self

    def __sub__(self, other):
        """ overload -

        >>> f = Fraction(1, 2)
        >>> g = Fraction(2, 3)
        >>> f - g
        < Fraction -1 / 6>
        >>> print("\\n".join([repr(i) for i in (f-g).steps]))
        < Expression [1, 2, /, 2, 3, /, -]>
        < Expression [1, 3, *, 2, 3, *, /, 2, 2, *, 3, 2, *, /, -]>
        < Expression [3, 6, /, 4, 6, /, -]>
        < Expression [< Fraction 3 / 6>, < Fraction 4 / 6>, -]>
        < Expression [3, 6, /, 4, 6, /, -]>
        < Expression [3, 4, -, 6, /]>
        >>> f - 0
        < Fraction 1 / 2>
        >>> (f-0).steps
        []

        """
        if other == 0:
            return copy(self)

        number = self.convert2fraction(other)

        if self._denom == number._denom:
            com_denom = self._denom
            num1 = self._num
            num2 = number._num

            exp = Expression([num1, num2, op.sub, com_denom, op.div])

        else:
            gcd_denom = gcd(self._denom, number._denom)
            coef1 = number._denom // gcd_denom
            coef2 = self._denom // gcd_denom

            exp = Expression([self._num,
                              coef1,
                              op.mul,
                              self._denom,
                              coef1,
                              op.mul,
                              op.div,
                              number._num,
                              coef2,
                              op.mul,
                              number._denom,
                              coef2,
                              op.mul,
                              op.div,
                              op.sub])

        ini_step = Expression(self.postfix_tokens +
                              number.postfix_tokens + [op.sub])
        ans = exp.simplify()
        ans.this_append_before([ini_step])
        return ans

    def __rsub__(self, other):
        if other == 0:
            return copy(self)

        number = self.convert2fraction(other)

        return number - self

    def __neg__(self):
        """ overload - (as arity 1 operator)

        >>> f = Fraction(1, 2)
        >>> -f
        < Fraction -1 / 2>
        >>> (-f).steps
        []
        >>> f = Fraction(1, -2)
        >>> f
        < Fraction 1 / -2>
        >>> -f
        < Fraction 1 / 2>
        >>> (-f).steps
        [< Expression [-1, -2, /]>]

        """
        f = Fraction(-self._num, self._denom)
        ans = f.simplify()

        return ans

    def __mul__(self, other):
        """ overload *

        >>> f = Fraction(1, 2)
        >>> g = Fraction(2, 3)
        >>> f*g
        < Fraction 1 / 3>
        >>> print("\\n".join([repr(i) for i in (f*g).steps]))
        < Expression [< Fraction 1 / 2>, < Fraction 2 / 3>, *]>
        < Expression [1, 2, *, 2, 3, *, /]>
        < Expression [1, 3, /]>
        >>> f * 0
        0
        >>> (f*0).steps
        [< Expression [< Fraction 1 / 2>, 0, *]>]
        >>> f*1
        < Fraction 1 / 2>
        >>> (f*1).steps
        [< Expression [< Fraction 1 / 2>, 1, *]>]
        >>> f*4
        2
        >>> print("\\n".join([repr(i) for i in (f*4).steps]))
        < Expression [< Fraction 1 / 2>, 4, *]>
        < Expression [1, 2, *, 2, *, 1, 2, *, /]>
        < Expression [1, 2, *, 1, /]>
        < Expression [2, 1, /]>

        """
        steps = [Expression([self, other, op.mul])]

        if other == 0:
            exp = Expression([0])
        elif other == 1:
            exp = copy(self)

        elif isinstance(other, int):
            gcd1 = gcd(other, self._denom)
            if gcd1 != 1:
                num_s = [self._num] + \
                    [int(other / gcd1), op.mul] * (int(other / gcd1) != 1) + \
                    [gcd1, op.mul]
                denom_s = [int(self._denom / gcd1), gcd1, op.mul]
                steps.append(Expression(num_s + denom_s + [op.div]))

                num = [self._num] + [int(other / gcd1), op.mul] * (int(other / gcd1) != 1)
                denom = [int(self._denom / gcd1)]
            else:
                num = [self._num, other, op.mul]
                denom = [self._denom]

            exp = Expression(num + denom + [op.div])

        else:
            number = self.convert2fraction(other)

            gcd1 = gcd(self._num, number._denom)
            if gcd1 != 1:
                num1_s = [gcd1] + [int(self._num / gcd1), op.mul] * (int(self._num / gcd1) != 1)
                denom2_s = [gcd1] + [int(number._denom / gcd1), op.mul] * (int(number._denom / gcd1) != 1)

                num1 = [int(self._num / gcd1)] * (int(self._num / gcd1) != 1)
                denom2 = [int(number._denom / gcd1)] * (int(self._denom / gcd1) != 1)
            else:
                num1_s = [self._num]
                denom2_s = [number._denom]

                num1 = [self._num]
                denom2 = [number._denom]

            gcd2 = gcd(self._denom, number._num)
            if gcd2 != 1:
                num2_s = [gcd2] + [int(number._num / gcd2), op.mul] * (int(number._num / gcd2) != 1)
                denom1_s = [gcd2] + [int(self._denom / gcd2), op.mul] * (int(self._denom / gcd2) != 1)

                num2 = [int(number._num / gcd2)] * (int(number._num / gcd2) != 1)
                denom1 = [int(self._denom / gcd2)] * (int(number._denom / gcd2) != 1)
            else:
                num2_s = [number._num]
                denom1_s = [self._denom]

                num2 = [number._num]
                denom1 = [self._denom]

            steps.append(Expression(num1_s + num2_s + [op.mul] +
                denom1_s + denom2_s + [op.mul, op.div]))

            exp = Expression(postfix_op(num1 + num2, op.mul, 1) +
                             postfix_op(denom1 + denom2, op.mul, 1) +
                             [op.div])

        ans = exp.simplify()
        ans.steps = steps + ans.steps
        return ans

    def __rmul__(self, other):
        return self * other

    def __truediv__(self, other):
        """ overload /

        >>> f = Fraction(1,2)
        >>> g = Fraction(3,4)
        >>> f / 0
        Traceback (most recent call last):
        ...
        ZeroDivisionError: division by zero
        >>> f / 1
        < Fraction 1 / 2>
        >>> (f/1).steps
        []
        >>> f / g
        < Fraction 2 / 3>

        """
        if other == 0:
            raise ZeroDivisionError("division by zero")
        elif other == 1:
            return copy(self)

        number = self.convert2fraction(other)

        ini_step = Expression(self.postfix_tokens +
                              number.postfix_tokens + [op.div])

        number = Fraction(number._denom, number._num)
        ans = self * number

        ans.this_append_before([ini_step])
        return ans

    def __rtruediv__(self, other):
        number = self.convert2fraction(other)

        return number / self

    def __pow__(self, power):
        """ overload **

        >>> f = Fraction(3, 4)
        >>> f**0
        1
        >>> (f**0).steps
        [< Expression [< Fraction 3 / 4>, 0, ^]>]
        >>> f**1
        < Fraction 3 / 4>
        >>> (f**1).steps
        [< Expression [< Fraction 3 / 4>, 1, ^]>]
        >>> f**3
        < Fraction 27 / 64>
        >>> print("\\n".join([repr(i) for i in (f**3).steps]))
        < Expression [< Fraction 3 / 4>, 3, ^]>
        < Expression [3, 3, ^, 4, 3, ^, /]>
        < Expression [27, 64, /]>
        >>> f = Fraction(6, 4)
        >>> f**3
        < Fraction 27 / 8>
        >>> print("\\n".join([repr(i) for i in (f**3).steps]))
        < Expression [< Fraction 6 / 4>, 3, ^]>
        < Expression [6, 3, ^, 4, 3, ^, /]>
        < Expression [216, 64, /]>
        < Expression [216, 64, /]>
        < Expression [27, 8, *, 8, 8, *, /]>

        """
        if not isinstance(power, int):
            raise ValueError(
                "Can't raise fraction to power {}".format(
                    str(power)))

        ini_step = Expression([self, power, op.pw])
        if power == 0:
            exp = Expression([1])
        elif power == 1:
            exp = copy(self)
        else:
            exp = Expression(
                [self._num, power, op.pw, self._denom, power, op.pw, op.div])

        ans = exp.simplify()
        ans.this_append_before([ini_step])
        return ans

    def __xor__(self, power):
        """ overload ^

        Work like **

        >>> f = Fraction(3, 4)
        >>> f^0
        1
        >>> f^1
        < Fraction 3 / 4>
        >>> f^3
        < Fraction 27 / 64>
        """

        return self.__pow__(power)

    def __abs__(self):
        return Fraction(abs(self._num), abs(self._denom))

    def __eq__(self, other):
        """ == """
        if isNumber(other):
            number = self.convert2fraction(other)

            return self._num * number._denom == self._denom * number._num
        else:
            return 0

    def __lt__(self, other):
        """ < """
        return float(self) < float(other)

    def __le__(self, other):
        """ <= """
        return float(self) <= float(other)

    def __gt__(self, other):
        """ > """
        return float(self) > float(other)

    def __ge__(self, other):
        """ >= """
        return float(self) >= float(other)

    def __copy__(self):
        """ Copying the fraction removing steps where it is from """
        return Fraction(self._num, self._denom)


# -----------------------------
# Reglages pour 'vim'
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
# cursor: 16 del