def make_constraints_d(csp_obj, vars_list, nWorkersMat, day, cstr):
'''
:param csp_obj:
:param vars_mat: row of all employees by day-
E1D1, E2D1, E3D1, E4D1, .. EnD1
E1D2, E2D2, E3D2, E4D2, ..
...
...
E1D7.......................EnD7
:param: nWorkersList a matrix of the num of workers for each shift.
:return: constraint list
'''
constraints_list = []
for s in range(1,4):
cur_scope = []
for ed, v in enumerate(vars_list):
if v.in_cur_domain(s):
cur_scope.append(v)
name = 'S{}D{}'.format(s, day+1)
new_con = Constraint(name, cur_scope)
sat_tuples = create_sat_tuples(cur_scope,s,nWorkersMat[day][s-1],day+1, cstr)
new_con.add_satisfying_tuples(sat_tuples)
constraints_list.append(new_con)
csp_obj.add_constraint(new_con)
return constraints_list
def binary_ne_grid(kenken_grid):
n = kenken_grid[0][0]
variables, constraints = [], []
for i in range(n):
variables.append([
Variable("%d%d" % (i, j), domain=list(range(1, n + 1)))
for j in range(n)
])
tuples = [t for t in permutations(list(range(1, n + 1)), 2)]
for i in range(n):
for j in range(n):
for k in range(j + 1, n):
cons = Constraint("r%d%d%d" % (i, j, k),
[variables[i][j], variables[i][k]])
cons.add_satisfying_tuples(tuples)
constraints.append(cons)
cons = Constraint("c%d%d%d" % (i, j, k),
[variables[j][i], variables[k][i]])
cons.add_satisfying_tuples(tuples)
constraints.append(cons)
csp = CSP("binary_ne_grid", [v for row in variables for v in row])
for cons in constraints:
csp.add_constraint(cons)
return csp, variables
def kenken_csp_model(kenken_grid):
n = kenken_grid[0][0]
csp, variables = nary_ad_grid(kenken_grid)
csp.name = 'kenken_csp_model'
operations = {
0: lambda x, y: x + y,
1: lambda x, y: x - y,
2: lambda x, y: x // y,
3: lambda x, y: x * y,
}
for raw_constraint in kenken_grid[1:]:
if len(raw_constraint) == 2:
i, j = getij(raw_constraint[0])
cons = Constraint(str(raw_constraint), [variables[i][j]])
tuples = [[raw_constraint[1]]]
else:
vars, tuples = [], []
for x in raw_constraint[:-2]:
i, j = getij(x)
vars.append(variables[i][j])
cons = Constraint(str(raw_constraint), vars)
for l in product(list(range(1, n + 1)),
repeat=len(raw_constraint) - 2):
if reduce(operations[raw_constraint[-1]],
l) == raw_constraint[-2]:
for per in permutations(l):
if per not in tuples:
tuples.append(per)
cons.add_satisfying_tuples(tuples)
csp.add_constraint(cons)
return csp, variables
def binary_ne_grid(kenken_grid):
# Initialize
dim = kenken_grid[0][0]
Vars = []
Vars_1d = []
cons = []
# construct list of lists of Variable objects
for i in range(dim):
Vars.append([])
for j in range(dim):
var = Variable("Cell_r%i_c%i"%(i+1,j+1), domain = [z for z in range(1, dim+1)])
Vars_1d.append(var)
Vars[i].append(var)
# construct csp
for i in range(dim):
for j in range(dim-1):
for k in range(j+1, dim):
#for row
con = Constraint("ConstraintRow_r%i_c%i_c%i"%(i+1,j+1,k+1), [Vars[i][j],Vars[i][k]])
tuples = []
for Tuple in permutations(list(range(1,dim+1)),2):
tuples.append(Tuple)
con.add_satisfying_tuples(tuples)
cons.append(con)
#for col
con = Constraint("ConstraintCol_c%i_r%i_r%i"%(i+1,j+1,k+1), [Vars[j][i],Vars[k][i]])
tuples = []
for Tuple in permutations(list(range(1,dim+1)),2):
tuples.append(Tuple)
con.add_satisfying_tuples(tuples)
cons.append(con)
csp = CSP("binary_ne_grid", Vars_1d)
for con in cons:
csp.add_constraint(con)
return csp, Vars
def nary_ad_grid(kenken_grid):
# Get the size of the grid and buid the domain of each variable
size = kenken_grid[0][0]
domain = list(range(1, size + 1))
# Instantiate all variables in size x size list and instantiate csp
vars = []
for i in domain:
vars.append([Variable(str(i) + str(j), domain) for j in domain])
csp = CSP('kenken', [var for row in vars for var in row])
# Create n-ary constraints
valid = list(permutations(domain, size))
for i in range(size):
cons_x = Constraint('r' + str(i), vars[i])
cons_y = Constraint('c' + str(i), [v[i] for v in vars])
cons_x.add_satisfying_tuples(valid)
cons_y.add_satisfying_tuples(valid)
csp.add_constraint(cons_x)
csp.add_constraint(cons_y)
return csp, vars
def kenken_csp_model(kenken_grid):
size = kenken_grid[0][0]
domain = list(range(1, size + 1))
csp, vars = nary_ad_grid(kenken_grid)
for i, cage in enumerate(kenken_grid[1:]):
if len(cage) == 2:
# Forced value constraint
cons = Constraint('g{} f'.format(i), [get_var(vars, cage[0])])
cons.add_satisfying_tuples([(cage[1],)])
else:
# Extract relevant data
n_vars = len(cage) - 2
target = cage[-2]
operation = cage[-1]
# Determine scope of the constraint and initialize
vars_i = [get_var(vars, c) for c in cage[:-2]]
cons = Constraint('g{} {}{}'.format(i, target, ops[operation]),
vars_i)
# Determine satisfying tuples
valid = []
if operation == 0: # Addition
valid = valid_given_op(n_vars, target, domain,
operator.add)
elif operation == 1: # Subtraction
valid = valid_given_op(n_vars, target, domain,
operator.sub, True)
elif operation == 2: # Division
valid = valid_given_op(n_vars, target, domain,
operator.floordiv, True)
elif operation == 3: # Multiplication
valid = valid_given_op(n_vars, target, domain,
operator.mul)
cons.add_satisfying_tuples(valid)
csp.add_constraint(cons)
return csp, vars
def binary_ne_grid(kenken_grid):
# Get the size of the grid and buid the domain of each variable
size = kenken_grid[0][0]
domain = list(range(1, size + 1))
# Instantiate all variables in size x size list and instantiate csp
vars = []
for i in domain:
vars.append([Variable(str(i) + str(j), domain) for j in domain])
csp = CSP('kenken', [var for row in vars for var in row])
# Create binary constraints
valid = list(permutations(domain, 2))
for i in range(size):
for j in range(size):
for k in range(j + 1, size):
cons_x = Constraint('{0}{1}-{0}{2}'.format(i, j, k),
[vars[i][j], vars[i][k]])
cons_y = Constraint('{1}{0}-{2}{0}'.format(i, j, k),
[vars[j][i], vars[k][i]])
cons_x.add_satisfying_tuples(valid)
cons_y.add_satisfying_tuples(valid)
csp.add_constraint(cons_x)
csp.add_constraint(cons_y)
return csp, vars
def kenken_csp_model(kenken_grid):
'''
Use nary_ad_grid
'''
# Initialize
dim = kenken_grid[0][0]
Vars = []
Vars_1d = []
cons = []
# construct list of lists of Variable objects
for i in range(dim):
Vars.append([])
for j in range(dim):
var = Variable("Cell_r%i_c%i"%(i+1,j+1), domain = [z for z in range(1, dim+1)])
Vars_1d.append(var)
Vars[i].append(var)
# nary_ad_grid
for i in range(dim):
#for row
con = Constraint("ConstraintRow_r%i"%i, Vars[i])
tuples = []
for Tuple in permutations(list(range(1, dim+1))):
tuples.append(Tuple)
con.add_satisfying_tuples(tuples)
cons.append(con)
#for col
con = Constraint("ConstraintCol_r%i"%i, [(Vars[row][i]) for row in range(dim)])
tuples = []
for Tuple in permutations(list(range(1, dim+1))):
tuples.append(Tuple)
con.add_satisfying_tuples(tuples)
cons.append(con)
# construct kenken constraints
for idx, element in enumerate(kenken_grid[1:]):
if len(element) == 2:
con = Constraint("KenKen_%i"%idx, [(Vars[(element[0]//10)-1][(element[0]%10)-1])])
tuples = [[element[1]]]
else:
con = Constraint("KenKen_%i"%idx, [(Vars[(i//10)-1][(i%10)-1]) for i in element[:-2]])
tuples = []
for comb in product(list(range(1,dim+1)), repeat = (len(element)-2)):
if element[-1] == 0:
oper = operator.add
elif element[-1] == 1:
oper = operator.sub
elif element[-1] == 2:
oper = operator.truediv
elif element[-1] == 3:
oper = operator.mul
if reduce(oper, comb) == element[-2]:
for permu in permutations(comb):
if permu not in tuples:
tuples.append(permu)
con.add_satisfying_tuples(tuples)
cons.append(con)
csp = CSP("kenken_csp_model", Vars_1d)
for con in cons:
csp.add_constraint(con)
return csp, Vars