return True if value ``x`` is in the invertible domain of
        variable ``i``
342391
def is_feasible_i(self, x, i):
        
        lb = self._lb[self._index(i)]
        ub = self._ub[self._index(i)]
        al = self._al[self._index(i)]
        au = self._au[self._index(i)]
        return lb - al < x < ub + au
921670
def _ite(test: str, in1: str, in0: str, output: str = None):
    "
    assert len({test, in0, in1}) == 3

    true_out = bit_flipper([test]) >> or_gate([test, in1], 'true_out')
    false_out = or_gate([test, in0], 'false_out')
    return (true_out | false_out) >> and_gate(['true_out', 'false_out'],
                                              output)
373300
def _call(self, x, out):
        """"""
        if self.domain.is_real:
            # Real domain, multiply separately
            out.real = self.scalar.real * x
            out.imag = self.scalar.imag * x
        else:
            # Complex domain
            out.lincomb(self.scalar, x)
159838
def _call(self, x, out=None):
        """"""
        if out is None:
            return self.operator(x) * self.vector
        else:
            self.operator(x, out=out)
            out *= self.vector
671671
private boolean voltConvertBinaryIntegerLiteral(Session session, Expression lhs, Expression rhs) {
        Expression nonIntegralExpr;
        int whichChild;
        if (lhs.dataType.isIntegralType()) {
            nonIntegralExpr = rhs;
            whichChild = RIGHT;
        }
        else if (rhs.dataType.isIntegralType()) {
            nonIntegralExpr = lhs;
            whichChild = LEFT;
        } else {
            return false;
        }

        return ExpressionValue.voltMutateToBigintType(nonIntegralExpr, this, whichChild);
    }
61996
def _turbo_isomorphic(q, g, check_varprops=True):
    
    # first some quick checks
    if len(q.eps()) != len(g.eps()): return False
    if len(q.variables()) != len(g.variables()): return False
    #if len(a.hcons()) != len(b.hcons()): return False
    try:
        next(_isomorphisms(q, g, check_varprops=check_varprops))
        return True
    except StopIteration:
        return False
1091378
private boolean isVarEscaped(char[] array, int currentIndex)
    {
        int i = currentIndex - 1;

        while (i >= 0 && array[i] == '\\') {
            --i;
        }

        return (currentIndex - i) % 2 == 0;
    }
1153242
def isOrigin(self):
        
        for name, value in self.items():
            if isinstance(value, tuple):
                if (value < (-_EPSILON,) * len(value)
                        or value > (_EPSILON,) * len(value)):
                    return False
            if value < -_EPSILON or value > _EPSILON:
                return False
        return True
106380
def inv(self):
        
        if self.det == 0:
            raise ValueError("SquareTensor is non-invertible")
        return SquareTensor(np.linalg.inv(self))
930318
def can_convert(x):
        
        if len(x.shape) < 2 or len(x.shape) > 3:
            return False
        dtype = x.dtype
        height = x.shape[0]
        width = x.shape[1]
        channels = 1
        if len(x.shape) == 3:
            channels = x.shape[2]
        if channels > 4:
            return False
        return True
765582
private final boolean cvc(int i) {
        if (i < 2 || !isConsonant(i) || isConsonant(i - 1) || !isConsonant(i - 2)) {
            return false;
        }
        {
            int ch = b[i];
            if (ch == 'w' || ch == 'x' || ch == 'y') {
                return false;
            }
        }
        return true;
    }
1006421
def asinh(x, context=None):
    
    return _apply_function_in_current_context(
        BigFloat,
        mpfr.mpfr_asinh,
        (BigFloat._implicit_convert(x),),
        context,
    )
535417
private final boolean isConsonant(int i) {
        switch (b[i]) {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                return false;
            case 'y':
                return (i == 0) ? true : !isConsonant(i - 1);
            default:
                return true;
        }
    }
170831
function (x1, x2) {
		var D = x1.length;
		var d = 0;
		for (var i = 0; i < D; i++) {
			var x1i = x1[i];
			var x2i = x2[i];
			d += (x1i - x2i) * (x1i - x2i);
		}
		return d;
	}
127032
def operator_is(u):
    """"""
    global _aux
    if np.ndim(u) == 2:
        P = _P2
    elif np.ndim(u) == 3:
        P = _P3
    else:
        raise ValueError("u has an invalid number of dimensions "
                         "(should be 2 or 3)")
    
    if u.shape != _aux.shape[1:]:
        _aux = np.zeros((len(P),) + u.shape)
    
    for _aux_i, P_i in zip(_aux, P):
        _aux_i[:] = binary_dilation(u, P_i)
    
    return _aux.min(0)
826112
def is_in(allowed_values  # type: Set
          ):
    
    def is_in_allowed_values(x):
        if x in allowed_values:
            return True
        else:
            # raise Failure('is_in: x in ' + str(allowed_values) + ' does not hold for x=' + str(x))
            raise NotInAllowedValues(wrong_value=x, allowed_values=allowed_values)

    is_in_allowed_values.__name__ = 'is_in_{}'.format(allowed_values)
    return is_in_allowed_values
1286731
function(x) {
  return _.isUndefined(x) || _.isNull(x) || _.isNaN(x);
}