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