parameters: (self, other, modulo, context=None)
return_statement: return _dec_from_triple(sign, str(base), 0)
docstring: Three argument version of __pow__
docstring_summary: Three argument version of __pow__
docstring_tokens: Three argument version of __pow__
function: 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 xrange(exponent.exp):
              base = pow(base, 10, modulo)
          base = pow(base, exponent.int, modulo)
  
          return _dec_from_triple(sign, str(base), 0)
function_tokens: 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 xrange ( exponent . exp ) : base = pow ( base , 10 , modulo ) base = pow ( base , exponent . int , modulo ) return _dec_from_triple ( sign , str ( base ) , 0 )