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