(self, other, modulo, context=None)
return _dec_from_triple(sign, str(base), 0)
Three argument version of __pow__
Three argument version of __pow__
Three argument version of __pow__
def _power_modulo(self, other, modulo, context=None):
        """Three argument version of __pow__"""

        # if can't convert other and modulo to Decimal, raise
        # TypeError; there's no point returning NotImplemented (no
        # equivalent of __rpow__ for three argument pow)
        other = _convert_other(other, raiseit=True)
        modulo = _convert_other(modulo, raiseit=True)

        if context is None:
            context = getcontext()

        # deal with NaNs: if there are any sNaNs then first one wins,
        # (i.e. behaviour for NaNs is identical to that of fma)
        self_is_nan = self._isnan()
        other_is_nan = other._isnan()
        modulo_is_nan = modulo._isnan()
        if self_is_nan or other_is_nan or modulo_is_nan:
            if self_is_nan == 2:
                return context._raise_error(InvalidOperation, 'sNaN',
                                        self)
            if other_is_nan == 2:
                return context._raise_error(InvalidOperation, 'sNaN',
                                        other)
            if modulo_is_nan == 2:
                return context._raise_error(InvalidOperation, 'sNaN',
                                        modulo)
            if self_is_nan:
                return self._fix_nan(context)
            if other_is_nan:
                return other._fix_nan(context)
            return modulo._fix_nan(context)

        # check inputs: we apply same restrictions as Python's pow()
        if not (self._isinteger() and
                other._isinteger() and
                modulo._isinteger()):
            return context._raise_error(InvalidOperation,
                                        'pow() 3rd argument not allowed '
                                        'unless all arguments are integers')
        if other < 0:
            return context._raise_error(InvalidOperation,
                                        'pow() 2nd argument cannot be '
                                        'negative when 3rd argument specified')
        if not modulo:
            return context._raise_error(InvalidOperation,
                                        'pow() 3rd argument cannot be 0')

        # additional restriction for decimal: the modulus must be less
        # than 10**prec in absolute value
        if modulo.adjusted() >= context.prec:
            return context._raise_error(InvalidOperation,
                                        'insufficient precision: pow() 3rd '
                                        'argument must not have more than '
                                        'precision digits')

        # define 0**0 == NaN, for consistency with two-argument pow
        # (even though it hurts!)
        if not other and not self:
            return context._raise_error(InvalidOperation,
                                        'at least one of pow() 1st argument '
                                        'and 2nd argument must be nonzero ;'
                                        '0**0 is not defined')

        # compute sign of result
        if other._iseven():
            sign = 0
        else:
            sign = self._sign

        # convert modulo to a Python integer, and self and other to
        # Decimal integers (i.e. force their exponents to be >= 0)
        modulo = abs(int(modulo))
        base = _WorkRep(self.to_integral_value())
        exponent = _WorkRep(other.to_integral_value())

        # compute result using integer pow()
        base = (base.int % modulo * pow(10, base.exp, modulo)) % modulo
        for i in range(exponent.exp):
            base = pow(base, 10, modulo)
        base = pow(base, exponent.int, modulo)

        return _dec_from_triple(sign, str(base), 0)
def _power_modulo ( self , other , modulo , context = None ) : # if can't convert other and modulo to Decimal, raise # TypeError; there's no point returning NotImplemented (no # equivalent of __rpow__ for three argument pow) other = _convert_other ( other , raiseit = True ) modulo = _convert_other ( modulo , raiseit = True ) if context is None : context = getcontext ( ) # deal with NaNs: if there are any sNaNs then first one wins, # (i.e. behaviour for NaNs is identical to that of fma) self_is_nan = self . _isnan ( ) other_is_nan = other . _isnan ( ) modulo_is_nan = modulo . _isnan ( ) if self_is_nan or other_is_nan or modulo_is_nan : if self_is_nan == 2 : return context . _raise_error ( InvalidOperation , 'sNaN' , self ) if other_is_nan == 2 : return context . _raise_error ( InvalidOperation , 'sNaN' , other ) if modulo_is_nan == 2 : return context . _raise_error ( InvalidOperation , 'sNaN' , modulo ) if self_is_nan : return self . _fix_nan ( context ) if other_is_nan : return other . _fix_nan ( context ) return modulo . _fix_nan ( context ) # check inputs: we apply same restrictions as Python's pow() if not ( self . _isinteger ( ) and other . _isinteger ( ) and modulo . _isinteger ( ) ) : return context . _raise_error ( InvalidOperation , 'pow() 3rd argument not allowed ' 'unless all arguments are integers' ) if other < 0 : return context . _raise_error ( InvalidOperation , 'pow() 2nd argument cannot be ' 'negative when 3rd argument specified' ) if not modulo : return context . _raise_error ( InvalidOperation , 'pow() 3rd argument cannot be 0' ) # additional restriction for decimal: the modulus must be less # than 10**prec in absolute value if modulo . adjusted ( ) >= context . prec : return context . _raise_error ( InvalidOperation , 'insufficient precision: pow() 3rd ' 'argument must not have more than ' 'precision digits' ) # define 0**0 == NaN, for consistency with two-argument pow # (even though it hurts!) if not other and not self : return context . _raise_error ( InvalidOperation , 'at least one of pow() 1st argument ' 'and 2nd argument must be nonzero ;' '0**0 is not defined' ) # compute sign of result if other . _iseven ( ) : sign = 0 else : sign = self . _sign # convert modulo to a Python integer, and self and other to # Decimal integers (i.e. force their exponents to be >= 0) modulo = abs ( int ( modulo ) ) base = _WorkRep ( self . to_integral_value ( ) ) exponent = _WorkRep ( other . to_integral_value ( ) ) # compute result using integer pow() base = ( base . int % modulo * pow ( 10 , base . exp , modulo ) ) % modulo for i in range ( exponent . exp ) : base = pow ( base , 10 , modulo ) base = pow ( base , exponent . int , modulo ) return _dec_from_triple ( sign , str ( base ) , 0 )