Auxiliary method.
9330
def __del_running_bp(self, tid, bp):
        ""
        self.__runningBP[tid].remove(bp)
        if not self.__runningBP[tid]:
            del self.__runningBP[tid]
928475
def kwargs_helper(kwargs):
    """"""

    args = []
    for param, value in kwargs.items():
        param = kw_subst.get(param, param)
        args.append((param, value))
    return args
122484
function (method) {
            if (this.subviews.length !== 0) {
                var params = slice.call(arguments);
                params.shift();
                _.each(this.subviews, function (s) {
                    if (s[method]) {
                        s[method].apply(s, params);
                    }
                });
            }
        }
83863
def extra(self, response):
        """"""
        if 'facets' in self.hits:
            response['_facets'] = self.hits['facets']
        if 'aggregations' in self.hits:
            response['_aggregations'] = self.hits['aggregations']
614925
def Indirect(self, off):
        """"""
        N.enforce_number(off, N.UOffsetTFlags)
        return off + encode.Get(N.UOffsetTFlags.packer_type, self.Bytes, off)
303135
def _call(self, x):
        """"""
        return (self.functional(x) +
                self.quadratic_coeff * x.inner(x) +
                x.inner(self.linear_term) + self.constant)
1036644
def AddMethod(self, function, name=None):
        
        method = MethodWrapper(self, function, name)
        self.added_methods.append(method)
200919
def _lt_from_gt(self, other):
    """"""
    op_result = self.__gt__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return not op_result and self != other
915229
def logical_and(self, other):
        """"""
        return self.operation(other, lambda x, y: int(x and y))
493592
private void augment(int v) {
        int n = buildPath(path, 0, v, NIL);
        for (int i = 2; i < n; i += 2) {
            matching.match(path[i], path[i - 1]);
        }
    }
1027336
public static void bodyContainsIllegalCode(Method method, Exception additionalInformation){
		Class<?> clazz = method.getClazz();
		if(isNull(clazz)) clazz = JMapper.class;
		
		String originalName = method.getOriginalName();
		if(isNull(originalName)) originalName = method.getName();
		
		String message = clazz != JMapper.class ? MSG.INSTANCE.message(conversionBodyIllegalCode,clazz.getSimpleName(),originalName,""+additionalInformation.getMessage())
				                                : MSG.INSTANCE.message(conversionBodyIllegalCode2,""+additionalInformation.getMessage());
		
		throw new ConversionBodyIllegalCodeException(message);
	}
1101111
def _add_sub(self, other, op):
        """"""
        if not isinstance(other, Number):
            return NotImplemented

        # If either side is unitless, inherit the other side's units.  Skip all
        # the rest of the conversion math, too.
        if self.is_unitless or other.is_unitless:
            return Number(
                op(self.value, other.value),
                unit_numer=self.unit_numer or other.unit_numer,
                unit_denom=self.unit_denom or other.unit_denom,
            )

        # Likewise, if either side is zero, it can auto-cast to any units
        if self.value == 0:
            return Number(
                op(self.value, other.value),
                unit_numer=other.unit_numer,
                unit_denom=other.unit_denom,
            )
        elif other.value == 0:
            return Number(
                op(self.value, other.value),
                unit_numer=self.unit_numer,
                unit_denom=self.unit_denom,
            )

        # Reduce both operands to the same units
        left = self.to_base_units()
        right = other.to_base_units()

        if left.unit_numer != right.unit_numer or left.unit_denom != right.unit_denom:
            raise ValueError("Can't reconcile units: %r and %r" % (self, other))

        new_amount = op(left.value, right.value)

        # Convert back to the left side's units
        if left.value != 0:
            new_amount = new_amount * self.value / left.value

        return Number(new_amount, unit_numer=self.unit_numer, unit_denom=self.unit_denom)
585387
def setup_auxiliary_weights(self):
        
        if self.fk.isAPF:
            self.logetat = self.fk.logeta(self.t - 1, self.X)
            self.aux = self.wgts.add(self.logetat)
        else:
            self.aux = self.wgts
978189
def _validate_other_add_sub(self, other):
        """"""
        if not isinstance(other, self.__class__):
            raise exceptions.IncompatibleSources(
                'Can only operate on {0}.'.format(self.__class__.__name__))
1197606
def _bld_op(self, op, num, **kwargs):
        """"""
        kwargs['other'] = num        
        setattr(self, op, {'mtype': pab, 'kwargs': kwargs})
836617
def method_missing(s, *a, &b)
      if s.to_s.end_with?('=')
      #  stop = s.to_s.chomp('=')
      #  if !SPECIAL_OPTIONS.include?(stop)
      #   (class << self; self; end).module_eval %{
      #      def station_#{stop}
      #        #{a.first}
      #      end
      #    }
      #  end
      else
        if @context.respond_to?(s)
          @context.__send__(s,*a,&b)
        else
          super(s, *a, &b)
        end
      end
    end
356093
def _gt_from_le(self, other):
    """"""
    op_result = self.__le__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return not op_result