Inequality functions values at X.
774304
protected DoubleMatrix1D getFi(DoubleMatrix1D X){
		final ConvexMultivariateRealFunction[] fis = request.getFi();
		if(fis==null){
			return null;
		}
		final double[] ret = new double[fis.length];
		final double[] x = X.toArray();
		for(int i=0; i<fis.length; i++){
			final ConvexMultivariateRealFunction fi = fis[i];
			final double fix = fi.value(x);
			ret[i] = fix;
		}
		return F1.make(ret);
	}
1174182
def Kdiag(self, X):
        """"""
        X_prod = self._comp_prod(X)
        return self.variance*four_over_tau*np.arcsin(X_prod/(X_prod+1.))
1001725
def X(self, value):
        """"""
        if isinstance(value, (int, float,
                              long, types.NoneType)):
            self._x = value
1374683
def _call(self, x):
        """"""

        sum_constr = abs(x.ufuncs.sum() / self.diameter - 1) <= self.sum_rtol

        nonneq_constr = x.ufuncs.greater_equal(0).asarray().all()

        if sum_constr and nonneq_constr:
            return 0
        else:
            return np.inf
680762
def h_function(self, x, xsquare):
        
        return invert(self.l_function(powmod(self.public_key.g, x - 1, xsquare),x), x)
237261
def obfn_f(self, X=None):
        
        """
        if X is None:
            X = self.X

        return 0.5 * np.linalg.norm((self.D.dot(X) - self.S).ravel())**2
532060
function cubicEaseInOut (p) {
    if(p < 0.5) {
        return 4 * p * p * p;
    } else {
        var f = ((2 * p) - 2);
        return 0.5 * f * f * f + 1;
    }
}
164006
function(k, j, P, A, L) {
            	var maxIndex = 0;
            	var maxValue = 0;

            	for(var i = k; i <= A.rows(); i++) {
            	    if(Math.abs(A.e(i, j)) > maxValue) {
            		maxValue = Math.abs(A.e(k, j));
            		maxIndex = i;
            	    }
            	}

            	if(maxIndex != k) {
            	    var tmp = A.elements[k - 1];
            	    A.elements[k - 1] = A.elements[maxIndex - 1];
            	    A.elements[maxIndex - 1] = tmp;
            	    
            	    P.elements[k - 1][k - 1] = 0;
            	    P.elements[k - 1][maxIndex - 1] = 1;
            	    P.elements[maxIndex - 1][maxIndex - 1] = 0;
            	    P.elements[maxIndex - 1][k - 1] = 1;
            	}
            	
            	return P;
                }
599086
def function(x, ax, ay):
    '''
    
    '''
    with np.errstate(invalid='ignore'):
        return ay * (x - ax)**0.5
579150
function f(x) {
                var m = c0 * Math.pow(x, 4) + c1 * Math.pow(x, 3) + c2 * Math.pow(x, 2) + c3 * x + c4;
                if (m < 0) {
                    m = 0;
                }
                return Math.pow(m, .5);
            }
845291
def optimize(self, x0, target):
        """"""
        x = x0
        for _ in range(self.maxiter):
            delta = np.linalg.solve(self.h(x, target), -self.g(x, target))
            x = x + delta
            if np.linalg.norm(delta) < self.tol:
                break
        return x
1062329
def strictly_increasing(values):
    """"""
    return all(x < y for x, y in zip(values, values[1:]))
902545
function equals($x)
    {
        switch (MATH_BIGINTEGER_MODE) {
            case self::MODE_GMP:
                return gmp_cmp($this->value, $x->value) == 0;
            default:
                return $this->value === $x->value && $this->is_negative == $x->is_negative;
        }
    }
5491
def _call(self, x):
        """"""
        return sum(fi(xi) for xi, fi in zip(x, self.functionals))
1264657
def pow2(x: int, p: int) -> int:
    """"""
    while p > 0:
        x = x * x % q
        p -= 1
    return x
17453
function ( x, a1, a2, b1, b2 ) {

		return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );

	}
457364
def somenan(self, x, fun, p=0.1):
        """"""
        if np.random.rand(1) < p:
            return np.NaN
        else:
            return fun(x)