Expression exclusive nor (XNOR) operator

    If *simplify* is ``True``, return a simplified expression.
357694
def Xnor(*xs, simplify=True):
    
    xs = [Expression.box(x).node for x in xs]
    y = exprnode.not_(exprnode.xor(*xs))
    if simplify:
        y = y.simplify()
    return _expr(y)
1262830
def p_expression_uxnor(self, p):
        ''
        p[0] = Uxnor(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
622075
def _notin(expr, values):
    

    if isinstance(expr, SequenceExpr):
        return NotIn(_input=expr, _values=values, _data_type=types.boolean)
    elif isinstance(expr, Scalar):
        return NotIn(_input=expr, _values=values, _value_type=types.boolean)
807698
public static function not(Expr $operand) : Expr
    {
        if ($operand instanceof self) {
            if ($operand->getOperator() === self::IS_NULL) {
                return self::isNotNull($operand->getOperand());
            } elseif ($operand->getOperator() === self::IS_NOT_NULL) {
                return self::isNull($operand->getOperand());
            } elseif ($operand->getOperator() === self::NOT) {
                return $operand->getOperand();
            }
        }

        return new self(self::NOT, $operand, new Boolean());
    }
387013
def And(*xs, simplify=True):
    
    xs = [Expression.box(x).node for x in xs]
    y = exprnode.and_(*xs)
    if simplify:
        y = y.simplify()
    return _expr(y)
622224
private boolean validBooleanExpression(Node expr) {
    if (isBooleanOperation(expr)) {
      return validBooleanOperation(expr);
    }

    if (!isOperation(expr)) {
      warnInvalidExpression("boolean", expr);
      return false;
    }
    if (!isValidPredicate(getCallName(expr))) {
      warnInvalid("boolean predicate", expr);
      return false;
    }
    Keywords keyword = nameToKeyword(getCallName(expr));
    if (!checkParameterCount(expr, keyword)) {
      return false;
    }
    switch (keyword.kind) {
      case TYPE_PREDICATE:
        return validTypePredicate(expr, getCallParamCount(expr));
      case STRING_PREDICATE:
        return validStringPredicate(expr, getCallParamCount(expr));
      case TYPEVAR_PREDICATE:
        return validTypevarPredicate(expr, getCallParamCount(expr));
      default:
        throw new IllegalStateException("Invalid boolean expression");
    }
  }
533449
def notin(arg, values):
    
    op = ops.NotContains(arg, values)
    return op.to_expr()
1344640
def Unequal(*xs, simplify=True):
    
    xs = [Expression.box(x).node for x in xs]
    y = exprnode.not_(exprnode.eq(*xs))
    if simplify:
        y = y.simplify()
    return _expr(y)
590601
public static function not(Expr $operand) : Expr
    {
        if ($operand instanceof BinOp && $operand->getOperator() === BinOp::EQUAL) {
            return self::notEqual($operand->getLeft(), $operand->getRight());
        }

        return UnaryOp::not($operand);
    }
238801
def _isna_compat(arr, fill_value=np.nan):
    
    dtype = arr.dtype
    if isna(fill_value):
        return not (is_bool_dtype(dtype) or
                    is_integer_dtype(dtype))
    return True
1010665
@NonNull
    public static Expression not(@NonNull Expression expression) {
        if (expression == null) {
            throw new IllegalArgumentException("expression cannot be null.");
        }
        return negated(expression);
    }
1341536
def _replace_nan(a, val):
    
    mask = isnull(a)
    return where_method(val, mask, a), mask
406540
def Nand(*xs, simplify=True):
    
    xs = [Expression.box(x).node for x in xs]
    y = exprnode.not_(exprnode.and_(*xs))
    if simplify:
        y = y.simplify()
    return _expr(y)
78248
def logical_not_expr(self):
        
        if self.token.nature == Nature.NOT:
            token = self.token
            self._process(Nature.NOT)
            return UnaryOperation(op=token, right=self.logical_not_expr())
        else:
            return self.comparison()
669984
def simplify_scalar(self, func=sympy.simplify):
        """"""

        def element_simplify(v):
            if isinstance(v, sympy.Basic):
                return func(v)
            elif isinstance(v, QuantumExpression):
                return v.simplify_scalar(func=func)
            else:
                return v

        return self.element_wise(element_simplify)
1137209
def expr(obj, simplify=True):
    """"""
    if isinstance(obj, Expression):
        return obj
    # False, True, 0, 1
    elif isinstance(obj, int) and obj in {0, 1}:
        return _CONSTS[obj]
    elif isinstance(obj, str):
        ast = pyeda.parsing.boolexpr.parse(obj)
        ex = ast2expr(ast)
        if simplify:
            ex = ex.simplify()
        return ex
    else:
        return One if bool(obj) else Zero
552729
def p_expr_ternary_op(p):
    ''
    p[0] = ast.TernaryOp(p[1], p[3], p[5], lineno=p.lineno(2))