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))