def as_domain(cls, r, x): """Builds a conic domain. Input arguments take the same form as those of the conic constraint, but in place of each variable, one can optionally supply a constant, linear expression, or None. Returns ------- block A block object with the core conic constraint (block.q) expressed using auxiliary variables (block.r, block.x) linked to the input arguments through auxiliary constraints (block.c). """ b = block() b.r = variable(lb=0) b.x = variable_tuple( [variable() for i in range(len(x))]) b.c = _build_linking_constraints([r] + list(x), [b.r] + list(b.x)) b.q = cls(r=b.r, x=b.x) return b
def __init__(self, *args, **kwds): super(piecewise_nd_cc, self).__init__(*args, **kwds) ndim = len(self.input) nsimplices = len(self.triangulation.simplices) npoints = len(self.triangulation.points) pointsT = list(zip(*self.triangulation.points)) # create index objects dimensions = range(ndim) simplices = range(nsimplices) vertices = range(npoints) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_tuple( variable(lb=0) for v in vertices) y = self.v['y'] = variable_tuple( variable(domain=Binary) for s in simplices) lmbda_tuple = tuple(lmbda) # create constraints self.c = constraint_list() clist = [] for d in dimensions: clist.append(linear_constraint( variables=lmbda_tuple + (self.input[d],), coefficients=tuple(pointsT[d]) + (-1,), rhs=0)) self.c.append(constraint_tuple(clist)) del clist self.c.append(linear_constraint( variables=lmbda_tuple + (self.output,), coefficients=tuple(self.values) + (-1,))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append(linear_constraint( variables=lmbda_tuple, coefficients=(1,)*len(lmbda_tuple), rhs=1)) # generate a map from vertex index to simplex index, # which avoids an n^2 lookup when generating the # constraint vertex_to_simplex = [[] for v in vertices] for s, simplex in enumerate(self.triangulation.simplices): for v in simplex: vertex_to_simplex[v].append(s) clist = [] for v in vertices: variables = tuple(y[s] for s in vertex_to_simplex[v]) clist.append(linear_constraint( variables=variables + (lmbda[v],), coefficients=(1,)*len(variables) + (-1,), lb=0)) self.c.append(constraint_tuple(clist)) del clist self.c.append(linear_constraint( variables=y, coefficients=(1,)*len(y), rhs=1))
def __init__(self, *args, **kwds): super(piecewise_dlog, self).__init__(*args, **kwds) breakpoints = self.breakpoints values = self.values if not is_positive_power_of_two(len(breakpoints) - 1): raise ValueError("The list of breakpoints must be " "of length (2^n)+1 for some positive " "integer n. Invalid length: %s" % (len(breakpoints))) # create branching schemes L = log2floor(len(breakpoints) - 1) assert 2**L == len(breakpoints) - 1 B_LEFT, B_RIGHT = self._branching_scheme(L) # create indexers polytopes = range(len(breakpoints) - 1) vertices = range(len(breakpoints)) def polytope_verts(p): return xrange(p, p + 2) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_dict(((p, v), variable(lb=0)) for p in polytopes for v in polytope_verts(p)) y = self.v['y'] = variable_tuple( variable(domain=Binary) for i in range(L)) # create piecewise constraints self.c = constraint_list() self.c.append( linear_constraint( variables=(self.input, ) + tuple(lmbda[p, v] for p in polytopes for v in polytope_verts(p)), coefficients=(-1, ) + tuple(breakpoints[v] for p in polytopes for v in polytope_verts(p)), rhs=0)) self.c.append( linear_constraint( variables=(self.output, ) + tuple(lmbda[p, v] for p in polytopes for v in polytope_verts(p)), coefficients=(-1, ) + tuple(values[v] for p in polytopes for v in polytope_verts(p)))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append( linear_constraint(variables=tuple(lmbda.values()), coefficients=(1, ) * len(lmbda), rhs=1)) clist = [] for i in range(L): variables = tuple(lmbda[p, v] for p in B_LEFT[i] for v in polytope_verts(p)) clist.append( linear_constraint(variables=variables + (y[i], ), coefficients=(1, ) * len(variables) + (-1, ), ub=0)) self.c.append(constraint_tuple(clist)) del clist clist = [] for i in range(L): variables = tuple(lmbda[p, v] for p in B_RIGHT[i] for v in polytope_verts(p)) clist.append( linear_constraint(variables=variables + (y[i], ), coefficients=(1, ) * len(variables) + (1, ), ub=1)) self.c.append(constraint_tuple(clist))
def __init__(self, *args, **kwds): super(piecewise_mc, self).__init__(*args, **kwds) # create indexers polytopes = range(len(self.breakpoints) - 1) # create constants (using future division) # these might also be expressions if the breakpoints # or values lists contain mutable objects slopes = tuple((self.values[p+1] - self.values[p]) / \ (self.breakpoints[p+1] - self.breakpoints[p]) for p in polytopes) intercepts = tuple(self.values[p] - \ (slopes[p] * self.breakpoints[p]) for p in polytopes) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_tuple(variable() for p in polytopes) lmbda_tuple = tuple(lmbda) y = self.v['y'] = variable_tuple( variable(domain=Binary) for p in polytopes) y_tuple = tuple(y) # create piecewise constraints self.c = constraint_list() self.c.append( linear_constraint(variables=lmbda_tuple + (self.input, ), coefficients=(1, ) * len(lmbda) + (-1, ), rhs=0)) self.c.append( linear_constraint(variables=lmbda_tuple + y_tuple + (self.output, ), coefficients=slopes + intercepts + (-1, ))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 clist1 = [] clist2 = [] for p in polytopes: clist1.append( linear_constraint(variables=(y[p], lmbda[p]), coefficients=(self.breakpoints[p], -1), ub=0)) clist2.append( linear_constraint(variables=(lmbda[p], y[p]), coefficients=(1, -self.breakpoints[p + 1]), ub=0)) self.c.append(constraint_tuple(clist1)) self.c.append(constraint_tuple(clist2)) self.c.append( linear_constraint(variables=y_tuple, coefficients=(1, ) * len(y), rhs=1))
def __init__(self, *args, **kwds): super(piecewise_cc, self).__init__(*args, **kwds) # create index sets polytopes = range(len(self.breakpoints) - 1) vertices = range(len(self.breakpoints)) def vertex_polys(v): if v == 0: return [v] if v == len(self.breakpoints) - 1: return [v - 1] else: return [v - 1, v] # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_tuple( variable(lb=0) for v in vertices) y = self.v['y'] = variable_tuple( variable(domain=Binary) for p in polytopes) lmbda_tuple = tuple(lmbda) # create piecewise constraints self.c = constraint_list() self.c.append( linear_constraint(variables=lmbda_tuple + (self.input, ), coefficients=self.breakpoints + (-1, ), rhs=0)) self.c.append( linear_constraint(variables=lmbda_tuple + (self.output, ), coefficients=self.values + (-1, ))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append( linear_constraint(variables=lmbda_tuple, coefficients=(1, ) * len(lmbda), rhs=1)) clist = [] for v in vertices: variables = tuple(y[p] for p in vertex_polys(v)) clist.append( linear_constraint(variables=variables + (lmbda[v], ), coefficients=(1, ) * len(variables) + (-1, ), lb=0)) self.c.append(constraint_tuple(clist)) self.c.append( linear_constraint(variables=tuple(y), coefficients=(1, ) * len(y), rhs=1))
def __init__(self, *args, **kwds): super(piecewise_nd_cc, self).__init__(*args, **kwds) ndim = len(self.input) nsimplices = len(self.triangulation.simplices) npoints = len(self.triangulation.points) pointsT = list(zip(*self.triangulation.points)) # create index objects dimensions = range(ndim) simplices = range(nsimplices) vertices = range(npoints) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_tuple( variable(lb=0) for v in vertices) y = self.v['y'] = variable_tuple( variable(domain_type=IntegerSet, lb=0, ub=1) for s in simplices) lmbda_tuple = tuple(lmbda) # create constraints self.c = constraint_list() clist = [] for d in dimensions: clist.append(linear_constraint( variables=lmbda_tuple + (self.input[d],), coefficients=tuple(pointsT[d]) + (-1,), rhs=0)) self.c.append(constraint_tuple(clist)) del clist self.c.append(linear_constraint( variables=lmbda_tuple + (self.output,), coefficients=tuple(self.values) + (-1,))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append(linear_constraint( variables=lmbda_tuple, coefficients=(1,)*len(lmbda_tuple), rhs=1)) # generate a map from vertex index to simplex index, # which avoids an n^2 lookup when generating the # constraint vertex_to_simplex = [[] for v in vertices] for s, simplex in enumerate(self.triangulation.simplices): for v in simplex: vertex_to_simplex[v].append(s) clist = [] for v in vertices: variables = tuple(y[s] for s in vertex_to_simplex[v]) clist.append(linear_constraint( variables=variables + (lmbda[v],), coefficients=(1,)*len(variables) + (-1,), lb=0)) self.c.append(constraint_tuple(clist)) del clist self.c.append(linear_constraint( variables=y, coefficients=(1,)*len(y), rhs=1))
def __init__(self, *args, **kwds): super(piecewise_dcc, self).__init__(*args, **kwds) # create index sets polytopes = range(len(self.breakpoints)-1) vertices = range(len(self.breakpoints)) def polytope_verts(p): return range(p,p+2) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_dict( ((p,v), variable(lb=0)) for p in polytopes for v in vertices) y = self.v['y'] = variable_tuple( variable(domain_type=IntegerSet, lb=0, ub=1) for p in polytopes) # create piecewise constraints self.c = constraint_list() self.c.append(linear_constraint( variables=tuple(lmbda[p,v] for p in polytopes for v in polytope_verts(p)) + \ (self.input,), coefficients=tuple(self.breakpoints[v] for p in polytopes for v in polytope_verts(p)) + \ (-1,), rhs=0)) self.c.append(linear_constraint( variables=tuple(lmbda[p,v] for p in polytopes for v in polytope_verts(p)) + \ (self.output,), coefficients=tuple(self.values[v] for p in polytopes for v in polytope_verts(p)) + (-1,))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 clist = [] for p in polytopes: variables = tuple(lmbda[p,v] for v in polytope_verts(p)) clist.append( linear_constraint( variables=variables + (y[p],), coefficients=(1,)*len(variables) + (-1,), rhs=0)) self.c.append(constraint_tuple(clist)) self.c.append(linear_constraint( variables=tuple(y), coefficients=(1,)*len(y), rhs=1))