def createLocalCodePolytope(self, jname, h, xvars):
"""Adds auxiliary variables and constraints for a local code polytope, given by the
local parity-check row *h* and the according variable dictionary *xvars*.
"""
d =h.size
codewords = []
auxVars = []
q = self.code.q
for i, localword in enumerate(itertools.product(list(range(q)),
repeat=d-1)):
modq = np.dot(localword, h[:-1]) % q
localword += (-modq * gfqla.inv(h[-1], q) % q,)
codewords.append(localword)
var = self.model.addVar(0, 1, name='w_{},{}'.format(jname, i))
auxVars.append(var)
self.numWvars += 1
self.model.update()
self.model.addConstr(gu.quicksum(auxVars),
gu.GRB.LESS_EQUAL, 1, name='auxSum{}'.format(jname))
for i in range(d):
for alpha in range(1, q):
if any(codeword[i] == alpha for codeword in codewords):
self.model.addConstr(gu.quicksum(auxVars[k] for k in range(len(auxVars)) if
codewords[k][i] == alpha), gu.GRB.EQUAL,
xvars[i, alpha], name='consis_{}_{}_{}'.format(jname, i,
alpha))
else:
print('no {} {} {}'.format(alpha, jname, i))
raise NotImplementedError()
def createLocalCodePolytope(self, jname, h, xvars):
"""Adds auxiliary variables and constraints for a local code polytope, given by the
local parity-check row *h* and the according variable dictionary *xvars*.
"""
d =h.size
codewords = []
auxVars = []
q = self.code.q
for i, localword in enumerate(itertools.product(list(range(q)),
repeat=d-1)):
modq = np.dot(localword, h[:-1]) % q
localword += (-modq * gfqla.inv(h[-1], q) % q,)
codewords.append(localword)
var = self.model.addVar(0, 1, name='w_{},{}'.format(jname, i))
auxVars.append(var)
self.numWvars += 1
self.model.update()
self.model.addConstr(gu.quicksum(auxVars),
gu.GRB.LESS_EQUAL, 1, name='auxSum{}'.format(jname))
for i in range(d):
for alpha in range(1, q):
if any(codeword[i] == alpha for codeword in codewords):
self.model.addConstr(gu.quicksum(auxVars[k] for k in range(len(auxVars)) if
codewords[k][i] == alpha), gu.GRB.EQUAL,
xvars[i, alpha], name='consis_{}_{}_{}'.format(jname, i,
alpha))
else:
print('no {} {} {}'.format(alpha, jname, i))
raise NotImplementedError()
def __init__(self, code, gurobiParams=None, gurobiVersion=None, name=None):
if name is None:
name = 'GurobiIPDecoder'
if utils.isStr(gurobiParams):
# allow to specify tuning set parameters using gurobiParams='tuning1' or similar
for i in ('1', '2', '3'):
if i in gurobiParams:
gurobiParams = getattr(self, 'tuningSet' + i)
break
elif gurobiParams is None:
gurobiParams = self.tuningSet1
gurobihelpers.GurobiDecoder.__init__(self, code, name, gurobiParams, gurobiVersion,
integer=True)
from gurobimh import GRB, quicksum
matrix = code.parityCheckMatrix
for i in range(code.blocklength):
self.model.addConstr(quicksum(self.x[i, k] for k in range(1, code.q)),
GRB.LESS_EQUAL, 1)
self.z = []
for i in range(matrix.shape[0]):
ub = np.sum(matrix[i]) * (code.q - 1) // code.q
self.z.append(self.model.addVar(0, ub, vtype=GRB.INTEGER, name='z{}'.format(i)))
self.model.update()
for z, row in zip(self.z, matrix):
self.model.addConstr(quicksum(row[i]*k*self.x[i, k] for k in range(1, code.q) for i
in np.flatnonzero(row)) - code.q * z, GRB.EQUAL, 0)
self.model.update()
self.mlCertificate = self.foundCodeword = True
def test_reset(self):
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar(lb=i, name='x'+str(i)) for i in range(10)]
m.reset()
y = [m.addVar(ub=1000*i, name='y'+str(i)) for i in range(5)]
m.update()
m.setObjective(grb.quicksum(x) - grb.quicksum(y))
m.optimize()
self.assertAlmostEqual(m.ObjVal, sum(range(10)) - 1000*sum(range(5)))
for var in x:
self.assertAlmostEqual(var.X, var.LB)
for var in y:
self.assertAlmostEqual(var.X, var.UB)
def test_reset(self):
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar(lb=i, name='x' + str(i)) for i in range(10)]
m.reset()
y = [m.addVar(ub=1000 * i, name='y' + str(i)) for i in range(5)]
m.update()
m.setObjective(grb.quicksum(x) - grb.quicksum(y))
m.optimize()
self.assertAlmostEqual(m.ObjVal, sum(range(10)) - 1000 * sum(range(5)))
for var in x:
self.assertAlmostEqual(var.X, var.LB)
for var in y:
self.assertAlmostEqual(var.X, var.UB)
def test_add_range(self):
for scale in [1, 10, 100]:
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(10)]
m.update()
thevars = m.getVars()
objective = grb.quicksum(x)
for i in [1, 2, 3, 4, 5]:
lb = i
ub = 10 - i
dummy_vars = [m.addVar() for j in range(i)]
constr = m.addRange(scale*objective, lb, ub)
extra_var = m.addVar(name="extra_var." + str(i))
m.update()
range_var = m.getVars()[-2-i]
self.assertEqual(range_var.VarName, "RgR" + str(i-1))
self.assertAlmostEqual(range_var.UB, 10 - 2*i)
for var in dummy_vars:
self.assertFalse(var.VarName.startswith('Rg'))
self.assertEquals(extra_var.VarName, "extra_var." + str(i))
m.setObjective(objective, sense=GRB.MINIMIZE)
m.optimize()
self.assertAlmostEqual(m.ObjVal, float(lb)/scale)
self.assertAlmostEqual(constr.Pi, 1.0/scale)
m.setObjective(objective, sense=GRB.MAXIMIZE)
m.optimize()
self.assertAlmostEqual(m.ObjVal, float(ub)/scale)
self.assertAlmostEqual(constr.Pi, 1.0/scale)
def test_add_range(self):
for scale in [1, 10, 100]:
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(10)]
m.update()
thevars = m.getVars()
objective = grb.quicksum(x)
for i in [1, 2, 3, 4, 5]:
lb = i
ub = 10 - i
dummy_vars = [m.addVar() for j in range(i)]
constr = m.addRange(scale * objective, lb, ub)
extra_var = m.addVar(name="extra_var." + str(i))
m.update()
range_var = m.getVars()[-2 - i]
self.assertEqual(range_var.VarName, "RgR" + str(i - 1))
self.assertAlmostEqual(range_var.UB, 10 - 2 * i)
for var in dummy_vars:
self.assertFalse(var.VarName.startswith('Rg'))
self.assertEquals(extra_var.VarName, "extra_var." + str(i))
m.setObjective(objective, sense=GRB.MINIMIZE)
m.optimize()
self.assertAlmostEqual(m.ObjVal, float(lb) / scale)
self.assertAlmostEqual(constr.Pi, 1.0 / scale)
m.setObjective(objective, sense=GRB.MAXIMIZE)
m.optimize()
self.assertAlmostEqual(m.ObjVal, float(ub) / scale)
self.assertAlmostEqual(constr.Pi, 1.0 / scale)
def test_unary_minus(self):
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(10)]
m.update()
expr1 = grb.quicksum(i*var for i, var in enumerate(x))
expr2 = -expr1
self.assertEqual(expr1.size(), expr2.size())
for i in range(expr2.size()):
self.assertEqual(expr2.getCoeff(i), -i)
self.assertEqual(expr2.getVar(i), x[i])
def test_unary_minus(self):
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(10)]
m.update()
expr1 = grb.quicksum(i * var for i, var in enumerate(x))
expr2 = -expr1
self.assertEqual(expr1.size(), expr2.size())
for i in range(expr2.size()):
self.assertEqual(expr2.getCoeff(i), -i)
self.assertEqual(expr2.getVar(i), x[i])
def test_linexpr_repeated_vars(self):
m = grb.Model()
m.setParam('OutputFlag', 0)
for i in range(1, 10):
for j in range(1, 10):
var = m.addVar()
m.update()
m.addConstr(grb.quicksum([var] * j) >= i)
m.setObjective(var)
m.optimize()
self.assertAlmostEqual(var.X, float(i) / float(j))
def test_linexpr_repeated_vars(self):
m = grb.Model()
m.setParam('OutputFlag', 0)
for i in range(1, 10):
for j in range(1, 10):
var = m.addVar()
m.update()
m.addConstr(grb.quicksum([var]*j) >= i)
m.setObjective(var)
m.optimize()
self.assertAlmostEqual(var.X, float(i)/float(j))
def get_knapsack_model(capacity, weights, values):
items = range(len(weights))
m = grb.Model()
m.setParam('OutputFlag', 0)
m.ModelSense = GRB.MAXIMIZE
m.ModelName = "knapsack"
item_selected = [m.addVar(ub=1, obj=values[item], name="item_selected." + str(item))
for item in items]
m.update()
m.addConstr(grb.quicksum(weights[item]*item_selected[item] for item in items) <= capacity,
name='knapsack')
m.update()
return m, item_selected
def test_scalar_multiply(self):
for c1 in range(1, 10):
for c2 in range(1, 10):
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(100)]
m.update()
expr = grb.quicksum(x)
constr = m.addConstr(c1 * expr >= 1)
expr *= c2
m.setObjective(expr)
m.optimize()
self.assertAlmostEqual(m.ObjVal, float(c2) / float(c1))
def test_scalar_multiply(self):
for c1 in range(1, 10):
for c2 in range(1, 10):
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(100)]
m.update()
expr = grb.quicksum(x)
constr = m.addConstr(c1*expr >= 1)
expr *= c2
m.setObjective(expr)
m.optimize()
self.assertAlmostEqual(m.ObjVal, float(c2)/float(c1))
def minimumDistance(self, hint=None):
"""Calculate the minimum distance of :attr:`code` via integer programming.
Compared to the decoding formulation, this adds the constraint :math:`|x| \\geq 1` and
minimizes :math:`\\sum_{i=1}^n x`.
"""
from gurobimh import quicksum, GRB
self.model.addConstr(quicksum(self.xlist), GRB.GREATER_EQUAL, 1, name='excludeZero')
self.model.setParam('MIPGapAbs', 1-1e-5)
self.setLLRs(np.ones(self.code.blocklength * (self.code.q - 1)))
self.solve()
self.model.remove(self.model.getConstrByName('excludeZero'))
self.model.update()
return int(round(self.objectiveValue))
def test_linexpr_get_value(self):
m = grb.Model()
m.setParam('OutputFlag', 0)
for n in [10, 100, 1000]:
x = [m.addVar(lb=i) for i in range(n)]
m.update()
expr = grb.quicksum(i*var for i, var in enumerate(x))
m.setObjective(expr)
m.optimize()
self.assertEqual(m.Status, grb.GRB.OPTIMAL)
self.assertEqual(m.Status, grb.GRB.status.OPTIMAL)
self.assertAlmostEqual(expr.getValue(), m.ObjVal)
self.assertAlmostEqual(expr.getValue(), m.getObjective().getValue())
self.assertAlmostEqual(expr.getValue(), sum(i*i for i in range(n)))
def test_linexpr_get_value(self):
m = grb.Model()
m.setParam('OutputFlag', 0)
for n in [10, 100, 1000]:
x = [m.addVar(lb=i) for i in range(n)]
m.update()
expr = grb.quicksum(i * var for i, var in enumerate(x))
m.setObjective(expr)
m.optimize()
self.assertEqual(m.Status, grb.GRB.OPTIMAL)
self.assertEqual(m.Status, grb.GRB.status.OPTIMAL)
self.assertAlmostEqual(expr.getValue(), m.ObjVal)
self.assertAlmostEqual(expr.getValue(),
m.getObjective().getValue())
self.assertAlmostEqual(expr.getValue(),
sum(i * i for i in range(n)))
def get_knapsack_model(capacity, weights, values):
items = range(len(weights))
m = grb.Model()
m.setParam('OutputFlag', 0)
m.ModelSense = GRB.MAXIMIZE
m.ModelName = "knapsack"
item_selected = [
m.addVar(ub=1, obj=values[item], name="item_selected." + str(item))
for item in items
]
m.update()
m.addConstr(grb.quicksum(weights[item] * item_selected[item]
for item in items) <= capacity,
name='knapsack')
m.update()
return m, item_selected
def test_add_empty_expression(self):
num_vars = 100
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(num_vars)]
m.update()
expr = grb.quicksum(x)
self.assertEquals((expr + grb.LinExpr()).size(), num_vars)
self.assertEquals((expr - grb.LinExpr()).size(), num_vars)
expr += grb.LinExpr()
self.assertEquals(expr.size(), num_vars)
expr -= grb.LinExpr()
self.assertEquals(expr.size(), num_vars)
expr += grb.LinExpr(100)
self.assertEquals(expr.getConstant(), 100)
expr -= grb.LinExpr(10)
self.assertEquals(expr.getConstant(), 90)
def test_add_empty_expression(self):
num_vars = 100
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(num_vars)]
m.update()
expr = grb.quicksum(x)
self.assertEquals((expr + grb.LinExpr()).size(), num_vars)
self.assertEquals((expr - grb.LinExpr()).size(), num_vars)
expr += grb.LinExpr()
self.assertEquals(expr.size(), num_vars)
expr -= grb.LinExpr()
self.assertEquals(expr.size(), num_vars)
expr += grb.LinExpr(100)
self.assertEquals(expr.getConstant(), 100)
expr -= grb.LinExpr(10)
self.assertEquals(expr.getConstant(), 90)
def isValid(self):
"""Check if this building block class induces valid inequalities."""
# qRange = np.arange(1, self.q)
# for loVals in itertools.product((0,1), repeat=self.q-1):
# maskModQ = np.dot(qRange, loVals) % self.q
# if maskModQ != 0:
# rhs = -np.dot(loVals, self.vals[self.lo, 1:])
# lhs = self.vals[0, self.q - maskModQ]
# if lhs > rhs:
# #print(mask, maskModQ, lhs, rhs)
# return False
# return True
import gurobimh as g
model = g.Model()
model.setParam('OutputFlag', 0)
zVars = [
model.addVar(vtype=g.GRB.INTEGER,
ub=self.vals[0, self.sigma],
name='y{}'.format(i)) for i in range(1, self.p)
]
xVars = [
model.addVar(vtype=g.GRB.BINARY, name='x{}'.format(i))
for i in range(1, self.p)
]
modQVar = model.addVar(vtype=g.GRB.INTEGER,
lb=-g.GRB.INFINITY,
ub=g.GRB.INFINITY,
name='z')
model.update()
model.addConstr(
g.LinExpr(self.vals[self.sigma, 1:], zVars) +
g.LinExpr(self.vals[0, 1:], xVars) >= 1)
model.addConstr(g.quicksum(xVars) == 1)
qRange = list(range(1, self.p))
model.addConstr(
g.LinExpr(qRange, zVars) + g.LinExpr(qRange, xVars) +
self.p * modQVar == 0)
model.optimize()
if model.Status == g.GRB.INFEASIBLE:
return True
else:
# print('invalid y/x:')
# print([x.X for x in xVars])
# print([y.X for y in zVars])
return False
