Implements two's complement negation.
18147
def negate_gate(wordlen, input='x', output='~x'):
    """"""
    neg = bitwise_negate(wordlen, input, "tmp")
    inc = inc_gate(wordlen, "tmp", output)
    return neg >> inc
1026175
def nein(x):
    "'"
    if not isinstance(x,(bool,ThreeVL)): raise TypeError(type(x))
    return not x if isinstance(x,bool) else ThreeVL(dict(t='f',f='t',u='u')[x.value])
555590
function dfl(a, b, c) {
        switch (arguments.length) {
            case 2: return a != null ? a : b;
            case 3: return a != null ? a : b != null ? b : c;
            default: throw new Error("Implement me");
        }
    }
688400
def selectisnot(table, field, value, complement=False):
    """"""

    return selectop(table, field, value, operator.is_not, complement=complement)
1000034
function () {
                var negate, p = input.charAt(i + 1);

                if (input.charAt(i) === '-' && (p === '@' || p === '(')) { negate = $('-') }
                var o = $(this.sub) || $(this.entities.dimension) ||
                        $(this.entities.color) || $(this.entities.variable) ||
                        $(this.entities.call);
                return negate ? new(tree.Operation)('*', [new(tree.Dimension)(-1), o])
                              : o;
            }
1130434
def Then2(self, f, arg1, *args, **kwargs):
        
        args = (arg1,) + args
        return self.ThenAt(2, f, *args, **kwargs)
649259
@Beta
    public static <T> Predicate<T> nor(Predicate<? super T> first, Predicate<? super T> second) {
        return com.google.common.base.Predicates.not(com.google.common.base.Predicates.or(first, second));
    }
21286
def neg(self, value, name=''):
        
        return self.sub(values.Constant(value.type, 0), value, name=name)
1293121
def _doublec(self, word):
        """"""
        if len(word) < 2:
            return False
        if (word[-1] != word[-2]):
            return False
        return self._cons(word, len(word)-1)
282002
public NumberExpression<T> negate() {
        if (negation == null) {
            negation = Expressions.numberOperation(getType(), Ops.NEGATE, mixin);
        }
        return negation;
    }
312025
public boolean negates( IAssertion other)
    {
    Assert assertion =
      other != null && other.getClass().equals( Assert.class)
      ? (Assert) other
      : null;

    return
      assertion != null
      && assertion.getProperty().equals( getProperty());
    }
578146
def p_conditional_expr(self, p):
        
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = self.asttypes.Conditional(
                predicate=p[1], consequent=p[3], alternative=p[5])
            p[0].setpos(p, 2)
1107975
function(){
    var node = this.supportsNegation()
      || this.supportsOp();
    if (!node) {
      this.cond = true;
      node = this.expression();
      this.cond = false;
    }
    return node;
  }
507241
function _not(expr) {
      var state = this.bt.current_state();
      try { var r = expr.call(this) } 
      catch (f) {
        this.bt.catch_mismatch(f);
        this.bt.restore(state);
        return true
      }
      this.bt.mismatch("Negative lookahead didn't match got " + r);
    }
1246204
function complement(Set $that) {
        $complement = $this->cloneEmpty();

        if ($that === $this) {
            return $complement;
        }

        $this->addIf($complement, $that, negate([$this, 'has']));

        return $complement;
    }
218955
function not(pred, thisArg) {
    function notPred() {
        return !(notPred.pred.apply(notPred.thisArg, arguments));
    }
    notPred.pred = pred;
    notPred.thisArg = thisArg;
    return notPred;
}
1251794
def negated(self):
        
        op = QueryCompound.Op.And if self.__op == QueryCompound.Op.Or else QueryCompound.Op.Or
        return QueryCompound(*self.__queries, op=op)