Round the quotient.

        :param quotient: current quotient
        :type quotient: list of int
        :param int divisor: the divisor
        :param int remainder: the remainder
        :param int base: the base
        :param method: the rounding method
        :raises BasesValueError:

        :returns: carry-out digit, non_repeating and repeating parts
        :rtype: tuple of int * list of int * list of int * int

        Complexity: O(len(quotient))

def _round(
       cls,
       quotient,
       divisor,
       remainder,
       base,
       method=RoundingMethods.ROUND_DOWN
    ):
        """
        Round the quotient.

        :param quotient: current quotient
        :type quotient: list of int
        :param int divisor: the divisor
        :param int remainder: the remainder
        :param int base: the base
        :param method: the rounding method
        :raises BasesValueError:

        :returns: carry-out digit, non_repeating and repeating parts
        :rtype: tuple of int * list of int * list of int * int

        Complexity: O(len(quotient))
        """
        # pylint: disable=too-many-return-statements
        # pylint: disable=too-many-arguments
        if method not in RoundingMethods.METHODS():
            raise BasesValueError(
               method,
               "method",
               "must be one of RoundingMethods.METHODS"
            )

        if remainder == 0: # pragma: no cover
            return (0, quotient, [], 0)

        if method is RoundingMethods.ROUND_DOWN:
            return (0, quotient, [], -1)
        if method is RoundingMethods.ROUND_TO_ZERO:
            return (0, quotient, [], -1)
        if method is RoundingMethods.ROUND_UP:
            (carry, quotient) = Nats.carry_in(quotient, 1, base)
            return (carry, quotient, [], 1)

        remainder = fractions.Fraction(remainder, divisor)
        middle = fractions.Fraction(base, 2)
        if remainder < middle:
            return (0, quotient, [], -1)
        if remainder > middle:
            (carry, quotient) = Nats.carry_in(quotient, 1, base)
            return (carry, quotient, [], 1)

        if method is RoundingMethods.ROUND_HALF_UP:
            (carry, quotient) = Nats.carry_in(quotient, 1, base)
            return (carry, quotient, [], 1)
        if method in \
           (RoundingMethods.ROUND_HALF_DOWN,
            RoundingMethods.ROUND_HALF_ZERO):
            return (0, quotient, [], -1)

        raise BasesValueError( # pragma: no cover
           method,
           "method",
           "must be one of RoundingMethods.METHODS"
        )