def solve(A, rhs, ct=None, logLevel=0): s = CyClpSimplex() s.logLevel = logLevel lp_dim = A.shape[1] x = s.addVariable('x', lp_dim) A = np.matrix(A) rhs = CyLPArray(rhs) s += A * x >= rhs s += x[lp_dim - 1] >= 0 s.objective = x[lp_dim - 1] nnz = np.count_nonzero(A) logging.debug(f"TASK SIZE XCOUNT: {lp_dim} GXCOUNT: {len(rhs)}") s.primal() k = list(s.primalConstraintSolution.keys())[0] k2 = list(s.dualConstraintSolution.keys())[0] q = s.dualConstraintSolution[k2] logging.debug(f"{s.getStatusString()} objective: {s.objectiveValue}") logging.debug( f"nonzeros rhs: {np.count_nonzero(s.primalConstraintSolution[k])}") logging.debug( f"nonzeros dual: {np.count_nonzero(s.dualConstraintSolution[k2])}") basis = s.getBasisStatus() print("Basis[0]") print(basis[0]) print("basis[1]") print(basis[1]) np.savetxt("out", basis[1]) print("#" * 100) s = CyClpSimplex() s.logLevel = logLevel lp_dim = A.shape[1] x = s.addVariable('x', lp_dim) A = np.matrix(A) rhs = CyLPArray(rhs) s += A * x >= rhs s += x[lp_dim - 1] >= 0 s.objective = x[lp_dim - 1] nnz = np.count_nonzero(A) logging.debug(f"TASK SIZE XCOUNT: {lp_dim} GXCOUNT: {len(rhs)}") s.setBasisStatus(*basis) s.primal() return s.primalVariableSolution['x']
def _base_branch(self: T, idx: int) -> Dict[str, T]: """ Creates two new copies of the node with new bounds placed on the variable with index <idx>, one with the variable's lower bound set to the ceiling of its current value and another with the variable's upper bound set to the floor of its current value. :param idx: index of variable to branch on :return: dict of Nodes with the new bounds keyed by direction they branched """ assert self.lp_feasible, 'must solve before branching' assert idx in self._integerIndices, 'must branch on integer index' b_val = self.solution[idx] assert self._is_fractional( b_val), "index branched on must be fractional" # get end basis to warm start the kiddos # appears to be tuple (variable statuses, slack statuses) basis = self._lp.getBasisStatus() # when branching down set floor as upper bound for given index u = self._lp.variablesUpper.copy() u[idx] = floor(b_val) down_lp = CyClpSimplex() down_lp.loadProblem(self._lp.matrix, self._lp.variablesLower, u, self._lp.objective, self._lp.constraintsLower, self._lp.constraintsUpper) down_lp.setBasisStatus(*basis) # warm start # when branching up set ceiling as lower bound for given index l = self._lp.variablesLower.copy() l[idx] = ceil(b_val) up_lp = CyClpSimplex() up_lp.loadProblem(self._lp.matrix, l, self._lp.variablesUpper, self._lp.objective, self._lp.constraintsLower, self._lp.constraintsUpper) up_lp.setBasisStatus(*basis) # warm start # return instances of the subclass that calls this function return { 'down': type(self)(down_lp, self._integerIndices, self.objective_value, idx, 'down', b_val, self.depth + 1), 'up': type(self)(up_lp, self._integerIndices, self.objective_value, idx, 'up', b_val, self.depth + 1) }