Coverage for /home/simon/Git/preflibtools/preflibtools/instances/sanity.py: 0%
69 statements
« prev ^ index » next coverage.py v6.4.4, created at 2022-09-22 11:34 +0200
« prev ^ index » next coverage.py v6.4.4, created at 2022-09-22 11:34 +0200
1import os.path
4def my_assert(condition, error, error_list):
5 try:
6 assert condition
7 except AssertionError:
8 print("ERROR: " + str(error))
9 error_list.append(error)
12def metadata(instance):
13 """ Checks that the basic metadata are in line with the content of the instance.
15 :param instance: The instance to test.
16 :type instance: :class:`preflibtools.instances.preflibinstance.PrefLibInstance`
17 """
19 error_list = []
21 my_assert(instance.data_type == os.path.splitext(instance.file_name)[1][1:],
22 "Data type {} is not aligned with file extension {}".format(
23 instance.data_type, os.path.splitext(instance.file_name)[1][1:]),
24 error_list)
26 my_assert(instance.num_alternatives == len(instance.alternatives_name),
27 "Number of alternatives {} differs from number of alternative names {}".format(
28 instance.num_alternatives, len(instance.alternatives_name)),
29 error_list)
31 my_assert(len(set(instance.alternatives_name.values())) == instance.num_alternatives,
32 "Some alternatives have the same name: {} != {}".format(
33 len(set(instance.alternatives_name.values())), instance.num_alternatives),
34 error_list)
37def orders(instance):
38 """ Checks that the orders are consistent.
40 :param instance: The instance to draw.
41 :type instance: :class:`preflibtools.instances.preflibinstance.OrdinalInstance`
42 """
44 error_list = []
46 my_assert(len(instance.orders) == len(instance.multiplicity),
47 "len(orders) {} differs from len(order_multiplicity) {}".format(
48 len(instance.orders), len(instance.multiplicity)),
49 error_list)
51 my_assert(instance.num_voters == sum(multiplicity for multiplicity in instance.multiplicity.values()),
52 "Number of voters {} and number of orders seem different {}".format(
53 instance.num_voters, sum(multiplicity for multiplicity in instance.multiplicity.values())),
54 error_list)
56 my_assert(instance.num_unique_orders == len(instance.orders),
57 "Number of unique order {} differs from len(orders) {}".format(
58 instance.num_unique_orders, len(instance.orders)),
59 error_list)
61 alternatives = set(alt for order in instance.orders for indif_class in order for alt in indif_class)
62 my_assert(len(alternatives) <= instance.num_alternatives,
63 "More alternatives appear in the orders {} than in the header {}".format(
64 len(alternatives), instance.num_alternatives),
65 error_list)
67 my_assert(0 not in alternatives,
68 "0 appears as an alternative",
69 error_list)
71 my_assert(instance.data_type == instance.infer_type(),
72 "Data type {} is not the same as the one inferred {}".format(instance.data_type, instance.infer_type()),
73 error_list)
75 my_assert(len(set(instance.orders)) == len(instance.orders),
76 "Some orders appear several times: {} != {}".format(len(set(instance.orders)), len(instance.orders)),
77 error_list)
79 if len(set(instance.orders)) != len(instance.orders):
80 for i in range(len(instance.orders)):
81 order1 = instance.orders[i]
82 for j in range(len(instance.orders)):
83 if i != j:
84 order2 = instance.orders[j]
85 my_assert(order1 != order2,
86 "Order {} at position {} is the same than order {} at position {}".format(
87 order1, i, order2, j),
88 error_list)
90 for i in range(len(instance.orders)):
91 order = instance.orders[i]
92 alternatives_appearing = [alt for indif_class in order for alt in indif_class]
93 num_alt_appearing = len(alternatives_appearing)
94 num_unique_alt_appearing = len(set(alternatives_appearing))
96 my_assert(num_alt_appearing <= instance.num_alternatives,
97 "Order {} at position {} has too many alternatives".format(order, i),
98 error_list)
100 my_assert(num_alt_appearing <= num_unique_alt_appearing,
101 "Some alternatives appear several times in order {} at position {}".format(order, i),
102 error_list)
104 if instance.data_type in ["soc", "toc"]:
105 my_assert(num_unique_alt_appearing <= instance.num_alternatives,
106 "Order {} at position {} does not seem complete".format(order, i),
107 error_list)
109 if instance.data_type in ["soc", "soi"]:
110 my_assert(max(len(indif_class) for indif_class in order) == 1,
111 "Order {} at position {} does not seem strict".format(order, i),
112 error_list)
114 return error_list
117def categories(instance):
118 """ Checks that the preferences and categories are consistent.
120 :param instance: The instance to draw.
121 :type instance: :class:`preflibtools.instances.preflibinstance.CategoricalInstance`
122 """
124 error_list = []
126 my_assert(len(instance.categories_name) == instance.num_categories,
127 "Number of category names {} differs from number of categories {}".format(
128 len(instance.categories_name), instance.num_categories),
129 error_list)
131 my_assert(len(instance.preferences) == len(instance.multiplicity),
132 "len(preferences) {} differs from len(multiplicity) {}".format(
133 len(instance.preferences), len(instance.multiplicity)),
134 error_list)
136 my_assert(instance.num_voters == sum(multiplicity for multiplicity in instance.multiplicity.values()),
137 "Number of voters {} and number of preferences seem different {}".format(
138 instance.num_voters, sum(multiplicity for multiplicity in instance.multiplicity.values())),
139 error_list)
141 my_assert(instance.num_unique_preferences == len(instance.preferences),
142 "Number of unique preferences {} differs from len(preferences) {}".format(
143 instance.num_unique_preferences, len(instance.preferences)),
144 error_list)
146 alternatives = set(alt for order in instance.preferences for indif_class in order for alt in indif_class)
147 my_assert(len(alternatives) <= instance.num_alternatives,
148 "More alternatives appear in the preference {} than in the header {}".format(
149 len(alternatives), instance.num_alternatives),
150 error_list)
152 my_assert(0 not in alternatives,
153 "0 appears as an alternative",
154 error_list)
156 my_assert(len(set(instance.preferences)) == len(instance.preferences),
157 "Some preferences appear several times: {} != {}".format(len(set(instance.preferences)),
158 len(instance.preferences)),
159 error_list)
161 if len(set(instance.preferences)) != len(instance.preferences):
162 for i in range(len(instance.preferences)):
163 pref1 = instance.preferences[i]
164 for j in range(len(instance.preferences)):
165 if i != j:
166 pref2 = instance.preferences[j]
167 my_assert(pref1 != pref2,
168 "Preference {} at position {} is the same than preference {} at position {}".format(
169 pref1, i, pref2, j),
170 error_list)
172 for i in range(len(instance.preferences)):
173 preference = instance.preferences[i]
174 alternatives_appearing = [alt for category in preference for alt in category]
175 num_alt_appearing = len(alternatives_appearing)
176 num_unique_alt_appearing = len(set(alternatives_appearing))
178 my_assert(num_alt_appearing <= instance.num_alternatives,
179 "Preference {} at position {} has too many alternatives".format(preference, i),
180 error_list)
182 my_assert(num_alt_appearing <= num_unique_alt_appearing,
183 "Some alternatives appear several times in preference {} at position {}".format(preference, i),
184 error_list)
186 my_assert(len(preference) == instance.num_categories,
187 "Preference {} at position {} has {} categories instead of the {} expected.".format(
188 preference, i, len(preference), instance.num_categories),
189 error_list)
191 return error_list
194def matching(instance):
195 """ Checks that the matching preferences are consistent.
197 :param instance: The instance to draw.
198 :type instance: :class:`preflibtools.instances.preflibinstance.MatchingInstance`
199 """
200 pass