fuzzy-dl-owl2 1.0.0__py3-none-any.whl

fuzzy_dl_owl2/fuzzyowl2/owl_types/choquet_concept.py

@@ -0,0 +1,19 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class ChoquetConcept(ConceptDefinition):
+
+    def __init__(self, weights: list[float], concepts: list[str]) -> None:
+        super().__init__(ConceptType.CHOQUET)
+        self._weights: list[float] = weights
+        self._concepts: list[str] = concepts
+
+    def get_weights(self) -> list[float]:
+        return self._weights
+
+    def get_concepts(self) -> list[str]:
+        return self._concepts
+
+    def __str__(self) -> str:
+        return f"(choquet ({' '.join(map(str, self._weights))}) ({' '.join(self._concepts)}))"

fuzzy_dl_owl2/fuzzyowl2/owl_types/concept_definition.py

@@ -0,0 +1,14 @@
+import abc
+
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class ConceptDefinition(abc.ABC):
+    def __init__(self, type: ConceptType) -> None:
+        self._type: ConceptType = type
+
+    def get_type(self) -> ConceptType:
+        return self._type
+
+    def __repr__(self) -> str:
+        return str(self)

fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_datatype.py

@@ -0,0 +1,22 @@
+import abc
+
+class FuzzyDatatype(abc.ABC):
+
+    def __init__(self) -> None:
+        self._k1: float = 0.0
+        self._k2: float = 0.0
+
+    def get_min_value(self) -> float:
+        return self._k1
+
+    def get_max_value(self) -> float:
+        return self._k2
+
+    def set_min_value(self, min: float) -> None:
+        self._k1 = min
+
+    def set_max_value(self, max: float) -> None:
+        self._k2 = max
+
+    def __repr__(self) -> str:
+        return str(self)

fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_modifier.py

@@ -0,0 +1,4 @@
+import abc
+
+class FuzzyModifier(abc.ABC):
+    pass

fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_nominal_concept.py

@@ -0,0 +1,19 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class FuzzyNominalConcept(ConceptDefinition):
+
+    def __init__(self, n: float, i: str) -> None:
+        super().__init__(ConceptType.FUZZY_NOMINAL)
+        self._n: float = n
+        self._i: str = i
+
+    def get_degree(self) -> float:
+        return self._n
+
+    def get_individual(self) -> str:
+        return self._i
+
+    def __str__(self) -> str:
+        return f"({self.get_degree()}, {self.get_individual()})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_property.py

@@ -0,0 +1,5 @@
+import abc
+
+
+class FuzzyProperty(abc.ABC):
+    pass

fuzzy_dl_owl2/fuzzyowl2/owl_types/left_shoulder_function.py

@@ -0,0 +1,17 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+
+
+class LeftShoulderFunction(FuzzyDatatype):
+    def __init__(self, a: float, b: float) -> None:
+        super().__init__()
+        self._a: float = a
+        self._b: float = b
+
+    def get_a(self) -> float:
+        return self._a
+
+    def get_b(self) -> float:
+        return self._b
+
+    def __str__(self) -> str:
+        return f"left-shoulder({self._k1}, {self._k2}, {self._a}, {self._b})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/linear_function.py

@@ -0,0 +1,17 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+
+
+class LinearFunction(FuzzyDatatype):
+    def __init__(self, a: float, b: float) -> None:
+        super().__init__()
+        self._a: float = a
+        self._b: float = b
+
+    def get_a(self) -> float:
+        return self._a
+
+    def get_b(self) -> float:
+        return self._b
+
+    def __str__(self) -> str:
+        return f"linear({self._k1}, {self._k2}, {self._a}, {self._b})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/linear_modifier.py

@@ -0,0 +1,13 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_modifier import FuzzyModifier
+
+
+class LinearModifier(FuzzyModifier):
+    def __init__(self, c: float) -> None:
+        super().__init__()
+        self._c: float = c
+
+    def get_c(self) -> float:
+        return self._c
+
+    def __str__(self) -> str:
+        return f"linear-modifier({self._c})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_concept.py

@@ -0,0 +1,19 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class ModifiedConcept(ConceptDefinition):
+
+    def __init__(self, mod: str, c: str) -> None:
+        super().__init__(ConceptType.MODIFIED_CONCEPT)
+        self._mod: str = mod
+        self._c: str = c
+
+    def get_fuzzy_modifier(self) -> str:
+        return self._mod
+
+    def get_fuzzy_concept(self) -> str:
+        return self._c
+
+    def __str__(self) -> str:
+        return f"({self._mod}, {self._c})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_function.py

@@ -0,0 +1,17 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+
+
+class ModifiedFunction(FuzzyDatatype):
+    def __init__(self, mod: str, d: str) -> None:
+        super().__init__()
+        self._mod: str = mod
+        self._d: str = d
+
+    def get_mod(self) -> str:
+        return self._mod
+
+    def get_d(self) -> str:
+        return self._d
+
+    def __str__(self) -> str:
+        return f"({self._mod}, {self._d})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_property.py

@@ -0,0 +1,15 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_property import FuzzyProperty
+
+
+class ModifiedProperty(FuzzyProperty):
+
+    def __init__(self, mod: str, prop: str) -> None:
+        super.__init__()
+        self._mod: str = mod
+        self._prop: str = prop
+
+    def get_fuzzy_modifier(self) -> str:
+        return self._mod
+
+    def get_property(self) -> str:
+        return self._prop

fuzzy_dl_owl2/fuzzyowl2/owl_types/owa_concept.py

@@ -0,0 +1,19 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class OwaConcept(ConceptDefinition):
+
+    def __init__(self, weights: list[float], concepts: list[str]) -> None:
+        super().__init__(ConceptType.OWA)
+        self._weights: list[float] = weights
+        self._concepts: list[str] = concepts
+
+    def get_weights(self) -> list[float]:
+        return self._weights
+
+    def get_concepts(self) -> list[str]:
+        return self._concepts
+
+    def __str__(self) -> str:
+        return f"(owa ({' '.join(map(str, self._weights))}) ({' '.join(self._concepts)}))"

fuzzy_dl_owl2/fuzzyowl2/owl_types/property_definition.py

@@ -0,0 +1,10 @@
+class PropertyDefinition:
+    def __init__(self, mod: str, prop: str) -> None:
+        self._mod: str = mod
+        self._prop: str = prop
+
+    def get_fuzzy_modifier(self) -> str:
+        return self._mod
+
+    def get_property(self) -> str:
+        return self._prop

fuzzy_dl_owl2/fuzzyowl2/owl_types/qowa_concept.py

@@ -0,0 +1,19 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class QowaConcept(ConceptDefinition):
+
+    def __init__(self, q: str, concepts: list[str]) -> None:
+        super().__init__(ConceptType.QUANTIFIED_OWA)
+        self._q: str = q
+        self._concepts: list[str] = concepts
+
+    def get_quantifier(self) -> str:
+        return self._q
+
+    def get_concepts(self) -> list[str]:
+        return self._concepts
+
+    def __str__(self) -> str:
+        return f"(q-owa {self._q} {' '.join(self._concepts)})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/quasi_sugeno_concept.py

@@ -0,0 +1,21 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class QsugenoConcept(ConceptDefinition):
+
+    def __init__(self, weights: list[float], concepts: list[str]) -> None:
+        super().__init__(ConceptType.QUASI_SUGENO)
+        self._weights: list[float] = weights
+        self._concepts: list[str] = concepts
+
+    def get_weights(self) -> list[float]:
+        return self._weights
+
+    def get_concepts(self) -> list[str]:
+        return self._concepts
+
+    def __str__(self) -> str:
+        return (
+            f"(q-sugeno ({' '.join(map(str, self._weights))}) ({' '.join(self._concepts)}))"
+        )

fuzzy_dl_owl2/fuzzyowl2/owl_types/right_shoulder_function.py

@@ -0,0 +1,17 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+
+
+class RightShoulderFunction(FuzzyDatatype):
+    def __init__(self, a: float, b: float) -> None:
+        super().__init__()
+        self._a: float = a
+        self._b: float = b
+
+    def get_a(self) -> float:
+        return self._a
+
+    def get_b(self) -> float:
+        return self._b
+
+    def __str__(self) -> str:
+        return f"right-shoulder({self._k1}, {self._k2}, {self._a}, {self._b})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/sugeno_concept.py

@@ -0,0 +1,21 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class SugenoConcept(ConceptDefinition):
+
+    def __init__(self, weights: list[float], concepts: list[str]) -> None:
+        super().__init__(ConceptType.SUGENO)
+        self._weights: list[float] = weights
+        self._concepts: list[str] = concepts
+
+    def get_weights(self) -> list[float]:
+        return self._weights
+
+    def get_concepts(self) -> list[str]:
+        return self._concepts
+
+    def __str__(self) -> str:
+        return (
+            f"(sugeno ({' '.join(map(str, self._weights))}) ({' '.join(self._concepts)}))"
+        )

fuzzy_dl_owl2/fuzzyowl2/owl_types/trapezoidal_function.py

@@ -0,0 +1,25 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+
+
+class TrapezoidalFunction(FuzzyDatatype):
+    def __init__(self, a: float, b: float, c: float, d: float) -> None:
+        super().__init__()
+        self._a: float = a
+        self._b: float = b
+        self._c: float = c
+        self._d: float = d
+
+    def get_a(self) -> float:
+        return self._a
+
+    def get_b(self) -> float:
+        return self._b
+
+    def get_c(self) -> float:
+        return self._c
+
+    def get_d(self) -> float:
+        return self._d
+
+    def __str__(self) -> str:
+        return f"trapezoidal({self._k1}, {self._k2}, {self._a}, {self._b}, {self._c}, {self._d})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/triangular_function.py

@@ -0,0 +1,21 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+
+
+class TriangularFunction(FuzzyDatatype):
+    def __init__(self, a: float, b: float, c: float) -> None:
+        super().__init__()
+        self._a: float = a
+        self._b: float = b
+        self._c: float = c
+
+    def get_a(self) -> float:
+        return self._a
+
+    def get_b(self) -> float:
+        return self._b
+
+    def get_c(self) -> float:
+        return self._c
+
+    def __str__(self) -> str:
+        return f"triangular({self._k1}, {self._k2}, {self._a}, {self._b}, {self._c})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/triangular_modifer.py

@@ -0,0 +1,21 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_modifier import FuzzyModifier
+
+
+class TriangularModifier(FuzzyModifier):
+    def __init__(self, a: float, b: float, c: float) -> None:
+        super().__init__()
+        self._a: float = a
+        self._b: float = b
+        self._c: float = c
+
+    def get_a(self) -> float:
+        return self._a
+
+    def get_b(self) -> float:
+        return self._b
+
+    def get_c(self) -> float:
+        return self._c
+
+    def __str__(self) -> str:
+        return f"triangular-modifier({self._a}, {self._b}, {self._c})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_concept.py

@@ -0,0 +1,19 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class WeightedConcept(ConceptDefinition):
+
+    def __init__(self, n: float, c: str) -> None:
+        super().__init__(ConceptType.WEIGHTED_CONCEPT)
+        self._n: float = n
+        self._c: str = c
+
+    def get_number(self) -> float:
+        return self._n
+
+    def get_fuzzy_concept(self) -> str:
+        return self._c
+
+    def __str__(self) -> str:
+        return f"({self._n} {self._c})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_max_concept.py

@@ -0,0 +1,15 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class WeightedMaxConcept(ConceptDefinition):
+
+    def __init__(self, wc: list[ConceptDefinition]) -> None:
+        super().__init__(ConceptType.WEIGHTED_MAX)
+        self._wc: list[ConceptDefinition] = wc
+
+    def get_weighted_concepts(self) -> list[ConceptDefinition]:
+        return self._wc
+
+    def __str__(self) -> str:
+        return f"(w-max {self._wc})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_min_concept.py

@@ -0,0 +1,15 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class WeightedMinConcept(ConceptDefinition):
+
+    def __init__(self, wc: list[ConceptDefinition]) -> None:
+        super().__init__(ConceptType.WEIGHTED_MIN)
+        self._wc: list[ConceptDefinition] = wc
+
+    def get_weighted_concepts(self) -> list[ConceptDefinition]:
+        return self._wc
+
+    def __str__(self) -> str:
+        return f"(w-min {self._wc})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_concept.py

@@ -0,0 +1,15 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class WeightedSumConcept(ConceptDefinition):
+
+    def __init__(self, wc: list[ConceptDefinition]) -> None:
+        super().__init__(ConceptType.WEIGHTED_SUM)
+        self._wc: list[ConceptDefinition] = wc
+
+    def get_weighted_concepts(self) -> list[ConceptDefinition]:
+        return self._wc
+
+    def __str__(self) -> str:
+        return f"(w-sum {self._wc})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_zero_concept.py

@@ -0,0 +1,15 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import ConceptType
+
+
+class WeightedSumZeroConcept(ConceptDefinition):
+
+    def __init__(self, wc: list[ConceptDefinition]) -> None:
+        super().__init__(ConceptType.WEIGHTED_SUM_ZERO)
+        self._wc: list[ConceptDefinition] = wc
+
+    def get_weighted_concepts(self) -> list[ConceptDefinition]:
+        return self._wc
+
+    def __str__(self) -> str:
+        return f"(w-sum-zero {self._wc})"

fuzzy_dl_owl2/fuzzyowl2/parser/__init__.py

@@ -0,0 +1 @@
+from .owl2_parser import *