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

1import os.path 

2 

3 

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) 

10 

11 

12def metadata(instance): 

13 """ Checks that the basic metadata are in line with the content of the instance. 

14 

15 :param instance: The instance to test. 

16 :type instance: :class:`preflibtools.instances.preflibinstance.PrefLibInstance` 

17 """ 

18 

19 error_list = [] 

20 

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) 

25 

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) 

30 

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) 

35 

36 

37def orders(instance): 

38 """ Checks that the orders are consistent. 

39 

40 :param instance: The instance to draw. 

41 :type instance: :class:`preflibtools.instances.preflibinstance.OrdinalInstance` 

42 """ 

43 

44 error_list = [] 

45 

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) 

50 

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) 

55 

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) 

60 

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) 

66 

67 my_assert(0 not in alternatives, 

68 "0 appears as an alternative", 

69 error_list) 

70 

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) 

74 

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) 

78 

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) 

89 

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)) 

95 

96 my_assert(num_alt_appearing <= instance.num_alternatives, 

97 "Order {} at position {} has too many alternatives".format(order, i), 

98 error_list) 

99 

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) 

103 

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) 

108 

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) 

113 

114 return error_list 

115 

116 

117def categories(instance): 

118 """ Checks that the preferences and categories are consistent. 

119 

120 :param instance: The instance to draw. 

121 :type instance: :class:`preflibtools.instances.preflibinstance.CategoricalInstance` 

122 """ 

123 

124 error_list = [] 

125 

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) 

130 

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) 

135 

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) 

140 

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) 

145 

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) 

151 

152 my_assert(0 not in alternatives, 

153 "0 appears as an alternative", 

154 error_list) 

155 

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) 

160 

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) 

171 

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)) 

177 

178 my_assert(num_alt_appearing <= instance.num_alternatives, 

179 "Preference {} at position {} has too many alternatives".format(preference, i), 

180 error_list) 

181 

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) 

185 

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) 

190 

191 return error_list 

192 

193 

194def matching(instance): 

195 """ Checks that the matching preferences are consistent. 

196 

197 :param instance: The instance to draw. 

198 :type instance: :class:`preflibtools.instances.preflibinstance.MatchingInstance` 

199 """ 

200 pass