def binary_relation_composite(first: Fuzzy, second: Fuzzy) -> MutableFuzzySet: if not (Relations.is_UxU_relation(first) and Relations.is_UxU_relation(second)): raise ValueError( defaults.RELATIONS_ARE_NOT_BINARY.format(first, second)) first_components, second_components = [ x.domain.decompose() for x in (first, second) ] if first_components[-1] != second_components[0]: raise ValueError(defaults.RELATIONS_ARE_NOT_CHAINED) U = Domain(first_components[0]) V = Domain(first_components[-1]) W = Domain(second_components[-1]) to_return = MutableFuzzySet(Domain.from_domains((U, W))) for element_i in U: for element_k in W: max_value = 0 for element_j in V: max_value = max( max_value, min(first.get_membership((element_i, element_j)), second.get_membership((element_j, element_k)))) to_return.set(to_return.domain.index((element_i, element_k)), max_value) return to_return
def and_zadeh(fuzzy_set_1: Fuzzy, fuzzy_set_2: Fuzzy) -> MutableFuzzySet: if fuzzy_set_1 is None or fuzzy_set_2 is None: raise ValueError(DZ1.defaults.OPERATION_SET_NONE) to_return = MutableFuzzySet(Domain.from_domains_merge((fuzzy_set_1.domain, fuzzy_set_2.domain))) for i, element in enumerate(to_return.domain): to_return.set(i, min(fuzzy_set_1.get_membership(element), fuzzy_set_2.get_membership(element))) return to_return
def is_symmetric(relation: Fuzzy) -> bool: if Relations.is_UxU_relation(relation): for element in relation.domain: if relation.get_membership(element) != relation.get_membership( element[::-1]): return False return True return False
def is_max_min_transitive(relation: Fuzzy) -> bool: if Relations.is_UxU_relation(relation): for i, element_i in enumerate(relation.domain): for element_j in relation.domain[i + 1:]: if element_i[1] == element_j[0]: new_element = (element_i[0], element_j[1]) if relation.get_membership(new_element) < min([ relation.get_membership(element_i), relation.get_membership(element_j) ]): return False return True return False
def is_reflexive(relation: Fuzzy) -> bool: if Relations.is_UxU_relation(relation): for element in relation.domain: if element[0] == element[1] and relation.get_membership( element) != 1.: return False return True return False
def t_norm_hamacher(fuzzy_set_1: Fuzzy, fuzzy_set_2: Fuzzy, p: float = 1.) -> MutableFuzzySet: if fuzzy_set_1 is None or fuzzy_set_2 is None: raise ValueError(DZ1.defaults.OPERATION_SET_NONE) if p is None or not isinstance(p, float): raise TypeError(DZ1.defaults.OPERATION_HAMACHER_T_NORM_WRONG_TYPE) if p < 0.: raise ValueError(DZ1.defaults.OPERATION_HAMACHER_NORM_NEGATIVE_PARAMETER) to_return = MutableFuzzySet(Domain.from_domains_merge((fuzzy_set_1.domain, fuzzy_set_2.domain))) for i, element in enumerate(to_return.domain): a, b = (fuzzy_set_1.get_membership(element), fuzzy_set_2.get_membership(element)) if a == b and a == 0.: to_return.set(i, 0.) else: to_return.set(i, (a * b) / (p + (1 - p) * (a + b + a * b))) return to_return
def defuzzify(self, fuzzy_set: Fuzzy) -> int: numerator = 0. denominator = 0. for domain_element in fuzzy_set.domain: t = fuzzy_set.get_membership(domain_element) numerator += t * domain_element denominator += t if abs(numerator) < 10e-6 or abs(denominator) < 10e-6: return 0 return int(numerator / denominator + 0.5)
def product_machine(current_value, current_premise: Fuzzy, element): return current_value * current_premise.get_membership(element)
def minimum_machine(current_value, current_premise: Fuzzy, element): return min(current_value, current_premise.get_membership(element))
speed_up_bounds = (max_acceleration + speed_up_bounds[0], max_acceleration + speed_up_bounds[1]) turn_left_sharply_bounds = (angle_thresholds[2], angle_thresholds[3]) turn_right_sharply_bounds = (-angle_thresholds[3], -angle_thresholds[2]) turn_around_bounds = (-angle_range[0] + 89, -angle_range[0] + 90) turn_left_sharply_bounds = (-angle_range[0] + turn_left_sharply_bounds[0], -angle_range[0] + turn_left_sharply_bounds[1]) turn_right_sharply_bounds = (-angle_range[0] + turn_right_sharply_bounds[0], -angle_range[0] + turn_right_sharply_bounds[1]) # endregion # region Rules # region Premise Database wrong_way = CalculatedFuzzySet(orientation_domain, Fuzzy.fuzzy_l(*wrong_way_bounds)) close_to_wall = CalculatedFuzzySet(distance_domain, Fuzzy.fuzzy_l(*close_to_wall_bounds)) really_close_to_wall = CalculatedFuzzySet( distance_domain, Fuzzy.fuzzy_l(*really_close_to_wall_bounds)) going_too_slowly = CalculatedFuzzySet(velocity_domain, Fuzzy.fuzzy_l(*going_too_slowly_bounds)) going_too_quickly = CalculatedFuzzySet( velocity_domain, Fuzzy.fuzzy_gamma(*going_too_quickly_bounds)) # endregion # region Conclusion Database slow_down = CalculatedFuzzySet(acceleration_domain, Fuzzy.fuzzy_l(*slow_down_bounds))