def problem_sol(name):
n_courses, n_profs, prereq, knowledge = input_reader(name)
course_list = list(range(n_courses))
prof_list = knowledge
neighbor_list = create_neibours(prereq, n_courses)
prof_course = dict()
for item in course_list:
prof_course[item] = prof_list
problem = csp.CSP(course_list, prof_course, neighbor_list, func)
answer = csp.tree_csp_solver(problem)
problem.display(answer)
log = ''
if answer is not None:
for key, value in answer.items():
log += str(key) + ' ' + str(prof_list.index(value)) + '\n'
# print('course:', key, '->', 'prof:', prof_list.index(value) + 1, '->', 'knowledge:', value[key])
else:
log += 'no assignment'
# print('no assignment')
return log
def build_csp(puzzle):
"""
Create a CSP object representing the puzzle.
:param puzzle (dictionary): The dictionary keys are tuples
(row, column) representing the filled puzzle squares and the values
are the corresponding numbers assigned to these squares.
:return: CSP object
"""
return csp.CSP(createDomains(puzzle), createNeighbors(puzzle),
createConstraints)
def build_csp(puzzle):
"""
Create a CSP object representing the puzzle.
:param puzzle (dictionary): The dictionary keys are tuples
(row, column) representing the filled puzzle squares and the values
are the corresponding numbers assigned to these squares.
:return: CSP object
"""
cells = combine(numbers, numbers)
domains = {
cell: [int(puzzle[cell])] if cell in puzzle else list(range(1, 10))
for cell in cells
}
neighbors = get_neighbors(cells)
return csp.CSP(domains, neighbors, check_constraint)
def CourseScheduler():
courses = "cs108 cs112 cs212 cs214 cs232 cs262 cs344".split()
variables = courses
professors = 'VanderLinden Norman, Adams, Bailey'.split()
times = 'mwf900 mwf1030 tth1130 tth1230'.split()
classrooms = 'nh253 sb382'.split()
possibleValues = list(itertools.product(classrooms, professors, times))
random.shuffle(possibleValues)
domains = {}
for course in variables:
domains[course] = possibleValues
#print(domains)
neighbors = {}
for course in variables:
courseCopyList = variables[:]
courseCopyList.remove(course)
neighborList = courseCopyList
neighbors[course] = neighborList
#print(neighbors)
def constraints(A, a, B, b):
#print("A " + str(A))
#print("a " + str(a))
#print("B " + str(B))
#print("b " + str(b))
# Room has space for one class at a time
one_class_per_room_per_time = True
# Faculty teaches 1 ting per time slot
one_faculty_per_time = True
# Course is taught by only one professor
one_faculty_per_class = True
# If the course is the same
if A == B:
# Then the same prof should be teaching it
one_faculty_per_class = a[1] == b[1]
# if the time is the same, but the course is not the same
if a[2] == b[2] and A != B:
# The same prof can't be teaching both classes
one_faculty_per_time = (a[1] != b[1])
# if the room is the same, and the time is the same
if a[0] == b[0] and a[2] == b[2]:
# then the class should be the same (no two courses in the same room at the same time)
one_class_per_room_per_time = (A == B)
return one_faculty_per_class and one_faculty_per_time and one_class_per_room_per_time
return csp.CSP(variables, domains, neighbors, constraints)
# }
neighbors = {
'Borean Tundra': {'Scholozar Basin', 'Wintergrasp', 'Dragonblight'},
'Dragonblight': {'Wintergrasp', 'Icecrown', 'Crystalsong', 'Zul Drak', 'Grizzly Hills'},
'Wintergrasp': {'Borean Tundra', 'Scholozar Basin', 'Icecrown', 'Dragonblight'},
'Scholozar Basin': {'Borean Tundra', 'Icecrown', 'Wintergrasp'},
'Crystalsong': {'Icecrown', 'Dragonblight', 'Storm Peaks', 'Zul Drak'},
'Icecrown': {'Scholozar Basin', 'Wintergrasp', 'Dragonblight', 'Crystalsong', 'Storm Peaks'},
'Storm Peaks': {'Icecrown', 'Crystalsong', 'Zul Drak'},
'Zul Drak': {'Storm Peaks', 'Crystalsong', 'Dragonblight', 'Grizzly Hills'},
'Grizzly Hills': {'Zul Drak', 'Dragonblight', 'Howling Fjord'},
'Howling Fjord': {'Grizzly Hills'}
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
myNorthrend = csp.CSP(variables, domains, neighbors, constraints)
myCSPs = [
{'csp': myNorthrend,
# 'select_unassigned_variable':csp.mrv,
}
]
string = 'K' + str(i) + str(j)
sys.stdout.write(str(dic[string]) + " ")
print()
if __name__ == '__main__':
"""Read first line from file"""
with open(sys.argv[1], 'r') as f:
size = int(f.readline())
lines = f.readlines()[1:]
f.close()
kenken = KenKen(size, lines)
game_kenken = csp.CSP(kenken.variables, kenken.domains, kenken.neighbors,
kenken.kenken_constraint)
if sys.argv[2] == "BT":
print("Using BT algorithm to solve the puzzle")
print()
kenken.display(csp.backtracking_search(game_kenken), size)
elif sys.argv[2] == "BT+MRV":
print("Using BT and MRV algorithms to solve the puzzle")
print()
kenken.display(
csp.backtracking_search(game_kenken,
select_unassigned_variable=csp.mrv), size)
elif sys.argv[2] == "FC":
print("Using FC algorithm to solve the puzzle")
print()
kenken.display(
def courses_scheduling():
# Defines the variables and values.
courses = 'cs108 cs112 cs212 cs214 cs232 cs262 cs344'.split()
faculty = 'adams vanderlinden plantinga wieringa norman'.split()
time_slots = 'mwf8:00-8:50 mwf9:00-9:50 mwf10:30-11:20 tth11:30-12:20 tth12:30-1:20'.split(
)
classrooms = 'nh253 sb382'.split()
if debug:
# Debug statements.
print('\ncourses list:' + str(courses))
print('faculty list:' + str(faculty))
print('time_slots list:' + str(time_slots))
print('classrooms list:' + str(classrooms))
variables = courses
values = faculty + time_slots + classrooms
if debug:
# Debug statements.
print('\nMy variables: ' + str(variables))
print('My values: ' + str(values))
# Combine values into triplets for use as part of domain.
value_triplets = []
for faculty in faculty:
for timeslots in time_slots:
for classroom in classrooms:
triplet = faculty + ' ' + timeslots + ' ' + classroom
value_triplets.append(triplet)
if debug:
# Debug statement.
print("\nContents of value_triplets: " + str(value_triplets) + "\n")
# Defines the domain.
domain = {}
for var in variables:
domain[var] = value_triplets
if debug:
# Debug statements.
for key, value in domain.items():
print("My domain key: " + key)
print("My domain values: " + str(value))
# Define neighbors of each variable.
neighbors = csp.parse_neighbors(
"""cs108: cs112 cs212 cs214 cs232 cs262 cs344;
cs112: cs108 cs212 cs214 cs232 cs262 cs344;
cs212: cs108 cs112 cs214 cs232 cs262 cs344;
cs214: cs108 cs112 cs212 cs232 cs262 cs344;
cs232: cs108 cs112 cs212 cs214 cs262 cs344;
cs262: cs108 cs112 cs212 cs214 cs232 cs344;
cs344: cs108 cs112 cs212 cs214 cs232 cs262""")
if debug:
# Debug statements.
print("\n\n")
for key, value in neighbors.items():
print("Neighbors Key:" + key)
print("Neighbors Values: " + str(value))
"""
The constraints are that:
each course should be offered exactly once by the assigned faculty member.
a faculty member can only teach one thing at a time.
a room can only have one class at each time.
"""
# Define the constraints on the variables.
# FIXME - WTB more documentation for AIMA code.
def scheduling_constraint(A, a, B, b):
if debug:
# Debug statement.
print("\nvalue of A: " + A)
print("value of B: " + B)
print("value of a: " + a)
print("value of b: " + b)
# Split "a" and "b" from triplets into singlets to test for same'ness.
a_split = str(a).split()
b_split = str(b).split()
if debug:
# Debug statement.
print("\na split contents: " + str(a_split))
print("b split contents: " + str(b_split))
# Important note: (faculty, timeslot, classroom) is the order of the split triplet!!!
if a_split[0] == b_split[0] and a_split[1] == b_split[1]:
return False
if a_split[1] == b_split[1] and a_split[2] == b_split[2]:
return False
# If no constraint violations, return true.
return True
# raise Exception('error')
return csp.CSP(variables, domain, neighbors, scheduling_constraint)
'Lazio': ['Tuscany', 'Umbria', 'Abruzzo', 'Molise', 'Campania'],
'Abruzzo': ['Marche', 'Lazio', 'Molise'],
'Molise': ['Abruzzo', 'Lazio', 'Campania', 'Apulia'],
'Campania': ['Lazio', 'Molise', 'Apulia', 'Basilicata'],
'Apulia': ['Molise', 'Campania', 'Basilicata'],
'Basilicata': ['Apulia', 'Campania', 'Calabria'],
'Calabria': ['Basilicata'],
}
vars = domains.keys()
domains = {}
for v in vars:
domains[v] = ['R', 'G', 'B', 'P', 'O', 'T', 'M']
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
myItalymap = csp.CSP(vars, domains, neighbors, constraints)
myCSPs = [{
'csp': myItalymap,
# 'select_unassigned_variable':csp.mrv,
}]
import scipy as sp
def classification(x, y, clf='lsvm'):
if clf == 'lsvm': model = svm.SVC(kernel='linear')
return ''
if __name__ == '__main__':
raw = np.load('data/comp_iva/epo.npz', allow_pickle=True)
data = raw['data']
x = data[0]['x']
y = data[0]['y']
x0 = []
x1 = []
x2 = []
x3 = []
for i in range(len(y)):
if y[i] == 0:
x0.append(x[i])
elif y[i] == 1:
x1.append(x[i])
elif y[i] == 2:
x2.append(x[i])
elif y[i] == 3:
x3.append(x[i])
abc = csp.CSP([x0, x1, x2, x3])
pass
import constants
import csp
import sudoku
import time
# ==================================================================================================
# MAIN
# ==================================================================================================
# Displaying the sudoku before the resolution
print("Sudoku is:")
S = sudoku.Sudoku.getSudokuFromFile("sudoku/1.txt")
S.display()
# Resolving the sudoku and keeping track of time
print("Trying to solve it...\n")
elapsedTime = -time.time()
CSP = csp.CSP(S)
solvedSudoku = CSP.backtrackingSearch()
elapsedTime += time.time()
# Displaying the solution
print("Finished in ", elapsedTime, "s, ", sep="", end="")
if (solvedSudoku != constants.FAILURE):
print("solved sudoku is:")
solvedSudoku.display()
else:
print("failed to solve the sudoku... :-(")
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = Gw
return False
return True
# swap comments bellow to swap between texas 3-color and 4 color map
#c2 = csp.CSP(v2, d2, n2, constraints)
#c2.label = 'Texas map'
c2 = csp.CSP(v3, d3, c3, constraints)
c2.label = '4 Color Map'
myCSPs = [
{
'csp' : c2,
# 'csp2' : c3,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp' : c2,
'select_unassigned_variable': csp.mrv,
# 'csp2' : c3,
'JS': ['SJ', 'QP', 'FX'],
'PD': ['FX', 'MH', 'XH', 'HP', 'HK', 'YP'],
'MH': ['XH', 'CN', 'FX', 'JD', 'QP', 'SJ'],
'BS': ['YP', 'PT', 'JD', 'ZB', 'HK'],
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
c2 = csp.CSP(v2, d2, sh, constraints)
c2.label = 'Really Lame'
myCSPs = [
{
'csp' : c2,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp' : c2,
'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
val = str(assignment[var])
print("%2s" % val, end=" ")
print()
else:
print("no solution found")
if __name__ == "__main__":
if len(sys.argv) < 2:
print(
"Insufficient arguments passed. Sample usage:\npython kenken.py <path-to-input-file>"
)
filename = sys.argv[1]
kenken = Kenken(filename)
kenken_csp = csp.CSP(kenken.variables, kenken.domains, kenken.neighbors,
kenken.constraints)
# 1. Basic backtracking
print("1. Running basic backtracking ...")
assignment1, node_count = csp.backtracking_search_with_assigment_count(
kenken_csp)
kenken.print_result(assignment1)
print("(1) no. of assignments:", node_count)
# 2. Improved backtacking: arc consistency (AC3) along with
# minimum remaining heuristic and forward checking inference
print("\n2. Improvement: AC3 along with mrv and forward_checking ...")
# arc consistency AC3 algorithm as per text book.
csp.AC3(kenken_csp)
assignment2, node_count = csp.backtracking_search_with_assigment_count(
a[0][sample_x][col][row] = x_data[sample_x +
sample_y][col][row]
sample_x += 1
else:
for col in range(240):
for row in range(2):
a[1][sample_y][col][row] = x_data[sample_x +
sample_y][col][row]
sample_y += 1
return a
#print (b)
train_csp_raw = csp_data(train_x_data, train_y_data, 30)
test_csp_raw = csp_data(test_x_data, test_y_data, 15)
train_csp = csp.CSP(train_csp_raw)
test_csp = csp.CSP(test_csp_raw)
train_x_data = train_csp
test_x_data = test_csp
train_x_data = train_x_data.reshape(train_x_data.shape[0], 480, 1,
1).astype(np.float32)
test_x_data = test_x_data.reshape(test_x_data.shape[0], 480, 1,
1).astype(np.float32)
#train_x_data = train_x_data.reshape(train_x_data.shape[0], 480, 1, 1).astype(np.float32)
#test_x_data = test_x_data.reshape(test_x_data.shape[0], 480, 1, 1).astype(np.float32)
#train_x_data = train_x_data.reshape(train_x_data.shape[0], train_x_data.shape[1], train_x_data.shape[2], 1).astype(np.float32)
#test_x_data = test_x_data.reshape(test_x_data.shape[0], test_x_data.shape[1], test_x_data.shape[2], 1).astype(np.float32)
variables = provinces.keys()
domains = {}
for v in variables:
domains[v] = ['R', 'G', 'B', 'Y']
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
colorChina = csp.CSP(variables, domains, provinces, constraints)
colorChina.label = 'China'
myCSPs = [
{
'csp' : colorChina,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp' : colorChina,
'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
'B': ['A', 'C', 'D'],
'C': ['A', 'B'],
'D': ['A', 'B']}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
c2 = csp.CSP(v2, d2, n2, constraints)
c2.label = 'Really Lame'
colors = ['R', 'G', 'B', 'Y']
domains = {
'Riften': colors,
'Eastmarch': colors,
'Falkreath': colors,
'Whiterun': colors,
'Winterhold': colors,
'ThePale': colors,
'Markarth': colors,
'Solitude': colors,
'Morthal': colors
}
"NT",
"SA",
"Q",
"NSW",
"V",
"T",
]
# Domains
domains = {var: ["red", "green", "blue"] for var in variables}
# Neighbors
neighbors = {
"WA": ["SA", "NT"],
"NT": ["WA", "SA", "Q"],
"SA": ["WA", "NT", "Q", "NSW", "V"],
"Q": ["NT", "SA", "NSW"],
"NSW": ["Q", "SA", "V"],
"V": ["SA", "NSW"],
"T": []
}
def constraintFunc(var1, val1, var2, val2):
return var2 not in neighbors[var1] or val1 != val2
problem = csp.CSP(variables, domains, neighbors, constraintFunc)
# print(csp.backtracking_search(problem))
print(csp.min_conflicts(problem, 100000))
'RetailRow' : ['WailingWoods', 'DustyDivot', 'SaltySprings', 'LonleyLodge'],
'LonleyLodge' : ['WailingWoods', 'RetailRow', 'SaltySprings', 'ParadisePalms'],
'ParadisePalms': ['LonleyLodge', 'SaltySprings', 'FatalFields', 'FlushFactory'],
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
fortnite = csp.CSP(v2, d2, n2, constraints)
fortnite.label = 'Fortnite'
myCSPs = [
{
'csp' : fortnite,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp' : fortnite,
'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
],
'I8': [
'I1', 'I2', 'I3', 'I4', 'I5', 'I6', 'I7', 'I9', 'A8', 'C8', 'D8', 'E8',
'F8', 'G8', 'H8', 'B8', 'G7', 'G9', 'H7', 'H9'
],
'I9': [
'I1', 'I2', 'I3', 'I4', 'I5', 'I6', 'I7', 'I8', 'A9', 'C9', 'D9', 'E9',
'F9', 'G9', 'H9', 'B9', 'G7', 'G8', 'H7', 'H8'
],
}
# def eliminateVariables(variablesTD):
# for x in variablesTD:
# domains.pop(x)
def constraints(A, a, B, b):
if A == B: # ex: A1 == A1
return True
if a == b: # ex: A1 == 1 while A2 == 1
return False
return True
solverMethod = csp.CSP(variables, domains, neighbors, constraints)
myCSPs = [{
'csp': solverMethod,
# 'select_unassigned_variable':csp.mrv,
}]
#'Kagawa': ['Tokushima', 'Ehime'],
#'Tokushima': ['Kagawa', 'Ehime', 'Kochi'],
#'Ehime': ['Kagawa', 'Tokushima', 'Kochi'],
#'Kochi': ['Ehime', 'Tokushima'],
#'Fukuoka': ['Oita', 'Kumamoto', 'Saga'],
#'Oita': ['Fukuoka', 'Kumamoto', 'Miyazaki'],
#'Miyazaki': ['Oita', 'Kumamoto', 'Kagoshima'],
#'Kagoshima': ['Miyazaki', 'Kumamoto'],
#'Kumamoto': ['Kagoshima', 'Miyazaki', 'Oita', 'Fukuoka'],
#'Saga': ['Nagasaki', 'Fukuoka'],
#'Nagasaki': ['Saga']
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
myJap = csp.CSP(variables, domains, neighbors, constraints)
myCSPs = [{
'csp': myJap,
# 'select_unassigned_variable':csp.mrv,
}]
'TG': ['M', 'K', 'S', 'T', 'KL'],
'KL': ['TG', 'T']
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
c2 = csp.CSP(v2, d2, Lithuania, constraints)
c2.label = 'Lithuania Map'
myCSPs = [
{
'csp': c2,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp': c2,
'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
import csp
def constraint(A, a, B, b):
if (A == 't1' and B == 't3'):
return (a > b)
elif (B == 't1' and A == 't3'):
return (b > a)
elif (A == 't3' and B == 't4'):
return (b > a)
elif (B == 't3' and A == 't4'):
return (a > b)
elif (A == 't3' and B == 't5'):
return (a > b)
elif (B == 't3' and A == 't5'):
return (b > a)
elif (A == 't1' and B == 't2') or (A == 't2' and B == 't1'):
return (abs(a - b) > 60)
elif (A == 't2' and B == 't4') or (A == 't4' and B == 't2'):
return (abs(a - b) > 60)
else:
print(A, a, B, b)
variables = ['t1', 't2', 't3', 't4', 't5']
domains = {var: [540, 600, 660] for var in variables}
domains['t4'] = [540, 660]
neighs = """t1: t2 t3;t2: t4;t4: t3;t3: t5"""
neighs = csp.parse_neighbors(neighs)
timecsp = csp.CSP(variables, domains, neighs, constraint)
'B': ['A', 'C', 'D'],
'C': ['A', 'B'],
'D': ['A', 'B'], }
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
c2 = csp.CSP(v2, d2, n2, constraints)
c2.label = 'Really Lame'
colors = ['R', 'G', 'B', 'Y']
domains = {
'Clatsop': colors, 'Columbia': colors, 'Multnomah': colors, 'Hood River': colors,
'Wasco': colors, 'Sherman': colors, 'Gilliam': colors, 'Morrow': colors, 'Umatilla': colors,
'Union': colors, 'Wallowa': colors, 'Tillamook': colors, 'Washington': colors, 'Clackamas': colors,
'Wheeler': colors, 'Grant': colors, 'Baker': colors, 'Yamhill': colors, 'Marion': colors,
'Jefferson': colors, 'Polk': colors, 'Lincoln': colors, 'Benton': colors, 'Linn': colors,
'Deschutes': 'R', 'Crook': colors, 'Lane': colors, 'Douglas': colors, 'Coos': colors,
'Curry': colors, 'Josephine': colors, 'Jackson': colors, 'Klamath': colors, 'Lake': colors,
'Harney': colors, 'Malheur': colors
}
'LOWER-SAXONY': [
'HOLSTEIN', 'ANHALT', 'WESTFALEN', 'HESSEN', 'THURINGEN',
'BRANDENBURG', 'VORPOMMERN'
],
'HOLSTEIN': ['VORPOMMERN', 'LOWER-SAXONY'],
'VORPOMMERN': ['BRANDENBURG', 'LOWER-SAXONY', 'HOLSTEIN'],
'SAARLAND': ['RHEINLAND']
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
germany = csp.CSP(cities, colors, map, constraints)
germany.label = 'GERMANY'
myCSPs = [{
'csp': germany,
'select_unassigned_variable': csp.mrv,
'order_domain_values': csp.lcv,
# 'inference': csp.mac,
'inference': csp.forward_checking,
}]
],
'Dodge': ['Washington', 'Waukesha', 'Jefferson'],
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
c2 = csp.CSP(v2, d2, wisconsin2d, constraints)
c2.label = 'Really Lame'
myCSPs = [
{
'csp': c2,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp': c2,
'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
# c2 = csp.CSP(v2, d2, n2, constraints)
# c2.label = 'Really Lame'
nigeria = csp.CSP(nigeria2v, nigeria2d, nigeria2, constraints)
nigeria.label = "Simplified Map of Nigeria"
myCSPs = [
{
'csp': nigeria,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp': nigeria,
'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
'C': ['BL', 'H'],
'H': ['C', 'RB']
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
myAus = csp.CSP(variables, domains, neighbors, constraints)
domainsNWAfrica = {
'WS': rgb,
'Mor': rgb,
'Alg': rgb,
'Tun': rgb,
'Maur': rgb,
'Sen': rgb,
'TheGam': rgb,
'Gui-Bis': rgb,
'Gui': rgb,
'SieLeo': rgb,
'Lib': rgb,
'Cot': rgb,
'Ghana': rgb,
'WA': ['OR', 'ID'],
'WI': ['MN', 'IA', 'MI', 'IL'],
'WV': ['OH', 'KY', 'PA', 'MD', 'VA'],
'WY': ['ID', 'UT', 'MT', 'SD', 'NE', 'CO'],
}
variables = neighbors.keys()
domains = {}
for v in variables:
domains[v] = ['R', 'G', 'B', 'K']
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
colorUS = csp.CSP(variables, domains, neighbors, constraints)
myCSPs = [{
'csp': colorUS,
#'select_unassigned_variable': csp.mrv,
#'order_domain_values': csp.lcv,
'inference': csp.mac,
}]
'G': ['N', 'B', 'C', 'SP', 'S'],
'S': ['G']
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
c2 = csp.CSP(v2, d2, n2, constraints)
c2.label = 'Mexico Culinary Map'
myCSPs = [
{
'csp': c2,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp': c2,
'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
754 : [239, 305, 561, 863],
561 : [754, 863, 772],
772 : [561, 863, 407, 321],
863 : [352, 407, 772, 561, 754, 239, 941, 813]
}
def constraints(A, a, B, b):
if A == B: # e.g. NSW == NSW
return True
if a == b: # e.g. WA = G and SA = G
return False
return True
FLAreaCodes = csp.CSP(v2, d2, n2, constraints)
FLAreaCodes.label = 'Florida Area Codes'
myCSPs = [
{
'csp' : FLAreaCodes,
# 'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
# 'inference': csp.forward_checking,
},
{
'csp' : FLAreaCodes,
'select_unassigned_variable': csp.mrv,
# 'order_domain_values': csp.lcv,
# 'inference': csp.mac,
