Whether solution is unbounded
195273
def unbounded(self):
        """"""
        self._check_valid()
        if self._ret_val != 0:
            return self._ret_val == swiglpk.GLP_ENODFS
        return swiglpk.glp_get_status(self._problem._p) == swiglpk.GLP_UNBND
800521
function isInbound(network, id) {
  for( var i = 0; i < network.edge.in.length; i++ ) {
    if(id === network.edge.out[i].properties.hobbes.id) {
      return true;
    }
  }

  return false;
}
347600
def p_unbound_segments(self, p):
        """"""
        p[0] = p[1]
        if len(p) > 2:
            p[0].extend(p[3])
282828
def is_feasible(self, solution):
        
        newvars = solution.new.keys()
        for newvar in newvars:
            for c in self._constraints_for_var.get(newvar, []):
                values = c.extract_values(solution, use_defaults=True)
                if not c(*values):
                    return False
        return True
413220
public boolean isClosed() {
		if (isEmpty()) {
			return false;
		}
		if (getNumPoints() == 1) {
			return false;
		}
		Coordinate[] coordinates = getCoordinates();
		return coordinates[0].equals(coordinates[coordinates.length - 1]);
	}
1266579
public boolean isBound()
    {
        //
        // Constrained properties are implicitly bound.  Refer to section 7.4.3 of the JavaBeans
        // spec for the rationale.
        //
        PropertyInfo propInfo = getPropertyInfo();
        return propInfo != null && (propInfo.bound() || propInfo.constrained());
    }
1114277
private boolean hasLeapMonth(long m0, long m) {
        return (
            (m >= m0)
            && (this.hasNoMajorSolarTerm(m) || this.hasLeapMonth(m0, this.newMoonBefore(m)))
        );
    }
408420
private boolean isSolvable(int method) throws NullPointerException {
    if(solved) {
      return solvable;
    }

    if(!reducedRowEchelonForm) {
      reducedRowEchelonForm(method);
    }

    // test if rank(coeff) == rank(coeff|rhs)
    for(int i = rank; i < rhs.length; i++) {
      if(Math.abs(rhs[row[i]]) > DELTA) {
        solvable = false;
        return false; // not solvable
      }
    }

    solvable = true;
    return true;
  }
245935
def is_solved(self):
        
        for side in "LUFDRB":
            sample = self.cube[side].facings[side]
            for square in sum(self.cube.get_face(side), []):
                if square != sample:
                    return False
        return True
384699
def save_solution(status)
      status = case status
               when LPSolve::OPTIMAL
                 :optimized
               when LPSolve::INFEASIBLE, LPSolve::UNBOUNDED,
                    LPSolve::DEGENERATE
                 :invalid
               else
                 :unknown
               end

      if status == :optimized
        objective_value = LPSolve.get_objective @ptr
        rows = LPSolve.get_Nrows(@ptr)
        variable_values = [nil]
        @variables.each do |var|
          variable_values << LPSolve.get_var_primalresult(@ptr,
                                                          rows + var.index)
        end
      else
        objective_value = nil
        variable_values = []
      end

      @solution = Solution.new status, objective_value, variable_values
    end
1179931
function solveLinearIntersect(a,b, c,  d,e, f) {
	// ax + by = c;
	// dx + ey = d;
	console.log('WORKED: ', arguments);
	if(a === 0) {
		var y = c/b;
		var x = (d-e*y)/x;
		return [x, y];
	}
	var denom = e-d/a * b;
	if(denom === 0) {
		// Either infinite solutions or no solutions
		return [undefined, undefined];
	}
	var y = (f-d*c/a)/denom;
	var x = (c-b*y) / a;
	return [x, y];
}
686751
function growBounding(bounding, x, y) {
        if (x < bounding[0]) {
            bounding[0] = x;
        } else if (x > bounding[2]) {
            bounding[2] = x;
        }

        if (y < bounding[1]) {
            bounding[1] = y;
        } else if (y > bounding[3]) {
            bounding[3] = y;
        }
    }
418407
private boolean isIntroducingFixedConflict(Sudoku sudoku,
                                               int row,
                                               int fromIndex,
                                               int toIndex)
    {
        return columnFixedValues[fromIndex][sudoku.getValue(row, toIndex) - 1]
               || columnFixedValues[toIndex][sudoku.getValue(row, fromIndex) - 1]
               || subGridFixedValues[convertToSubGrid(row, fromIndex)][sudoku.getValue(row, toIndex) - 1]
               || subGridFixedValues[convertToSubGrid(row, toIndex)][sudoku.getValue(row, fromIndex) - 1];
    }
670184
public boolean hasSolution(Pattern p, BioPAXElement ... ele)
	{
		Match m = new Match(p.size());
		for (int i = 0; i < ele.length; i++)
		{
			m.set(ele[i], i);
		}

		return !search(m, p).isEmpty();
	}
1101505
def unbounded(self):
        
        unbounded_dims = []
        # Dimensioned streams do not need to be bounded
        stream_params = set(util.stream_parameters(self.streams))
        for kdim in self.kdims:
            if str(kdim) in stream_params:
                continue
            if kdim.values:
                continue
            if None in kdim.range:
                unbounded_dims.append(str(kdim))
        return unbounded_dims
1183832
def wasSolvedBy(self, user):
        
        thisExercise = _Solution.what == self
        byThisUser = _Solution.who == user
        condition = q.AND(thisExercise, byThisUser)
        return self.store.query(_Solution, condition, limit=1).count() == 1
959562
def is_bound(method):
    
    @functools.wraps(method)
    def wrapper(self, *args, **kwargs):
        if not self._is_bound:
            raise ValueError("%r must be bound to call %s()" % (self, method.__name__))
        return method(self, *args, **kwargs)
    return wrapper