psyke 0.8.3.dev2__py3-none-any.whl → 0.8.5__py3-none-any.whl

psyke/__init__.py

@@ -61,7 +61,7 @@ class EvaluableModel(object):
         raise NotImplementedError('predict')
 
     def __convert(self, ys: Iterable) -> Iterable:
-        if self.normalization is not None:
+        if self.normalization is not None and not isinstance([p for p in ys if p is not None][0], str):
             m, s = self.normalization[list(self.normalization.keys())[-1]]
             ys = [prediction if prediction is None else prediction * s + m for prediction in ys]
         return ys
@@ -73,7 +73,7 @@ class EvaluableModel(object):
         raise NotImplementedError('brute_predict')
 
     def unscale(self, values, name):
-        if self.normalization is None or isinstance(values, LinearRegression):
+        if self.normalization is None or name not in self.normalization or isinstance(values, LinearRegression):
             return values
         if isinstance(values, Iterable):
             values = [None if value is None else
@@ -161,17 +161,20 @@ class Extractor(EvaluableModel, ABC):
         """
         raise NotImplementedError('extract')
 
-    def predict_why(self, data: dict[str, float]):
+    def predict_why(self, data: dict[str, float], verbose=True):
         """
         Provides a prediction and the corresponding explanation.
         :param data: is the instance to predict.
+        :param verbose: if the explanation has to be printed.
         """
         raise NotImplementedError('predict_why')
 
-    def predict_counter(self, data: dict[str, float]):
+    def predict_counter(self, data: dict[str, float], verbose=True, only_first=True):
         """
         Provides a prediction and counterfactual explanations.
         :param data: is the instance to predict.
+        :param verbose: if the counterfactual explanation has to be printed.
+        :param only_first: if only the closest counterfactual explanation is provided for each distinct class.
         """
         raise NotImplementedError('predict_counter')
 

psyke/extraction/hypercubic/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 from abc import ABC
 import numpy as np
 import pandas as pd
@@ -43,8 +44,8 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         return theory
 
     def pairwise_fairness(self, data: dict[str, float], neighbor: dict[str, float]):
-        cube1 = self._find_cube(data.copy())
-        cube2 = self._find_cube(neighbor.copy())
+        cube1 = self._find_cube(data)
+        cube2 = self._find_cube(neighbor)
         different_prediction_reasons = []
 
         if cube1.output == cube2.output:
@@ -62,100 +63,83 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
                     different_prediction_reasons.append(d)
         return different_prediction_reasons
 
-    def predict_counter(self, data: dict[str, float], verbose=True):
+    def predict_counter(self, data: dict[str, float], verbose=True, only_first=True):
         output = ""
         prediction = None
-        cube = self._find_cube(data.copy())
+        cube = self._find_cube(data)
         if cube is None:
             output += "The extracted knowledge is not exhaustive; impossible to predict this instance"
         else:
             prediction = self._predict_from_cubes(data)
-            output += f"The output is {prediction}"
+            output += f"The output is {prediction}\n"
 
         point = Point(list(data.keys()), list(data.values()))
         cubes = self._hypercubes if cube is None else [c for c in self._hypercubes if cube.output != c.output]
         cubes = sorted([(cube.surface_distance(point), cube.volume(), i, cube) for i, cube in enumerate(cubes)])
-        outputs = []
-        different_prediction_reasons = []
+
+        counter_conditions = []
+
         for _, _, _, c in cubes:
-            if c.output not in outputs:
-                outputs.append(c.output)
-                output += f"\nThe output may be {c.output} if"
-
-                for d in point.dimensions.keys():
-                    lower, upper = c[d]
-                    p = point[d]
-                    if p < lower:
-                        output += f"\n     {d} increases above {round(lower, 1)}"
-                        different_prediction_reasons.append((d, '>=', lower))
-                    elif p > upper:
-                        output += f"\n     {d} decreses below {round(upper, 1)}"
-                        different_prediction_reasons.append((d, '<=', upper))
+            if not only_first or c.output not in [o for o, _ in counter_conditions]:
+                counter_conditions.append((c.output, {c: [val for val in v if val is not None and not val.is_in(
+                    self.unscale(data[c], c))] for c, v in self.__get_conditions(data, c).items()}))
+
         if verbose:
+            for o, conditions in counter_conditions:
+                output += f"The output may be {o} if\n" + HyperCubeExtractor.__conditions_to_string(conditions)
             print(output)
-        return prediction, different_prediction_reasons
-
-    def __get_local_conditions(self, data: dict[str, float], cube: GenericCube) -> dict[list[Value]]:
-        conditions = {d: [Between(*cube.dimensions[d])] for d in cube.dimensions}
-        subcubes = cube.subcubes(self._hypercubes)
-        for c in [c for c in subcubes if sum(c in sc and c != sc for sc in subcubes) == 0]:
-            for d in [d for d in c.dimensions if d in data]:
-                if c.dimensions[d][0] > data[d] or c.dimensions[d][1] < data[d]:
-                    conditions[d].append(Outside(*c.dimensions[d]))
+
+        return prediction, counter_conditions
+
+    @staticmethod
+    def __conditions_to_string(conditions: dict[str, list[Value]]) -> str:
+        output = ""
+        for d in conditions:
+            for i, condition in enumerate(conditions[d]):
+                if i == 0:
+                    output += f'     {d} is '
+                else:
+                    output += ' and '
+                output += condition.print()
+                if i + 1 == len(conditions[d]):
+                    output += '\n'
+        return output
+
+    def __get_conditions(self, data: dict[str, float], cube: GenericCube) -> dict[str, list[Value]]:
+        conditions = {d: [cube.interval_to_value(d, self.unscale)] for d in data.keys()
+                      if d not in self._dimensions_to_ignore}
+        for c in cube.subcubes(self._hypercubes):
+            for d in conditions:
+                condition = c.interval_to_value(d, self.unscale)
+                if condition is None:
+                    continue
+                elif conditions[d][-1] is None:
+                    conditions[d][-1] = -condition
+                else:
+                    try:
+                        conditions[d][-1] *= -condition
+                    except Exception:
+                        conditions[d].append(-condition)
         return conditions
 
-    def predict_why(self, data: dict[str, float]):
-        cube = self._find_cube(data.copy())
+    def predict_why(self, data: dict[str, float], verbose=True):
+        cube = self._find_cube(data)
+        output = ""
         if cube is None:
-            print("The extracted knowledge is not exhaustive; impossible to predict this instance")
-        else:
-            output = self._predict_from_cubes(data)
-            print(f"The output is {output} because")
-            conditions = self.__get_local_conditions(data, cube)
-            for d in data.keys():
-                simplified = HyperCubeExtractor.__simplify(conditions[d])
-                for i, condition in enumerate(simplified):
-                    if i == 0:
-                        print('    ', d, 'is', end=' ')
-                    else:
-                        print('and', end=' ')
-                    if isinstance(condition, Outside):
-                        print('not', end=' ')
-                    print('between', round(condition.lower, 1), 'and', round(condition.upper, 1), end=' ')
-                    if i + 1 == len(simplified):
-                        print()
+            output += "The extracted knowledge is not exhaustive; impossible to predict this instance\n"
+            if verbose:
+                print(output)
+            return None, {}
+        prediction = self._predict_from_cubes(data)
+        output += f"The output is {prediction} because\n"
+        conditions = {c: [val for val in v if val is not None and val.is_in(self.unscale(data[c], c))]
+                      for c, v in self.__get_conditions(data, cube).items()}
 
-    @staticmethod
-    def __simplify(conditions):
-        simplified = []
-        for condition in conditions:
-            to_add = True
-            for i, simple in enumerate(simplified):
-                if isinstance(condition, Outside) and isinstance(simple, Outside):
-                    if simple.lower <= condition.lower <= simple.upper or \
-                            simple.lower <= condition.upper <= simple.upper or \
-                            condition.lower <= simple.lower <= simple.upper <= condition.upper:
-                        simplified[i].upper = max(condition.upper, simple.upper)
-                        simplified[i].lower = min(condition.lower, simple.lower)
-                        to_add = False
-                        break
-                elif isinstance(condition, Outside) and isinstance(simple, Between):
-                    if simple.lower >= condition.upper or simple.upper <= condition.lower:
-                        to_add = False
-                        break
-                    elif condition.lower <= simple.lower <= condition.upper <= simple.upper:
-                        simplified[i].lower = condition.upper
-                        to_add = False
-                        break
-                    elif simple.lower <= condition.lower <= simple.upper <= condition.upper:
-                        simplified[i].upper = condition.lower
-                        to_add = False
-                        break
-                    elif condition.lower <= simple.lower <= simple.upper <= condition.upper:
-                        raise ValueError
-            if to_add:
-                simplified.append(condition)
-        return simplified
+        if verbose:
+            output += HyperCubeExtractor.__conditions_to_string(conditions)
+            print(output)
+
+        return prediction, conditions
 
     @staticmethod
     def _create_head(dataframe: pd.DataFrame, variables: list[Var], output: float | LinearRegression) -> Struct:

psyke/extraction/hypercubic/creepy/__init__.py

@@ -25,7 +25,7 @@ class CReEPy(HyperCubeExtractor):
         self.clustering = clustering(depth, error_threshold, self._output, gauss_components, discretization,
                                      normalization, seed)
         self._default_surrounding_cube = True
-        self._dimensions_to_ignore = [dimension for dimension, relevance in ranks if relevance < ignore_threshold]
+        self._dimensions_to_ignore = set([dimension for dimension, relevance in ranks if relevance < ignore_threshold])
 
     def _extract(self, dataframe: pd.DataFrame) -> Theory:
         if not isinstance(self.clustering, HyperCubeClustering):

psyke/extraction/hypercubic/hypercube.py

@@ -13,7 +13,6 @@ from psyke.utils import get_default_precision, get_int_precision, Target, get_de
 from psyke.utils.logic import create_term, to_rounded_real, linear_function_creator
 from sklearn.linear_model import LinearRegression
 from tuprolog.core import Var, Struct
-from random import Random
 import numpy as np
 
 
@@ -149,6 +148,9 @@ class HyperCube:
         else:
             self._infinite_dimensions[dimension] = [direction]
 
+    def copy_infinite_dimensions(self, dimensions: dict[str, str]):
+        self._infinite_dimensions = dimensions.copy()
+
     @property
     def dimensions(self) -> Dimensions:
         return self._dimensions
@@ -173,8 +175,12 @@ class HyperCube:
     def barycenter(self) -> Point:
         return self._barycenter
 
-    def subcubes(self, cubes: Iterable[GenericCube]) -> Iterable[GenericCube]:
-        return [c for c in cubes if c in self and c != self]
+    def subcubes(self, cubes: Iterable[GenericCube], only_largest: bool = True) -> Iterable[GenericCube]:
+        subcubes = [c for c in cubes if c in self and c.output != self.output]
+        if only_largest:
+            subsubcubes = [c for cube_list in [c.subcubes(cubes) for c in subcubes] for c in cube_list]
+            subcubes = [c for c in subcubes if c not in subsubcubes]
+        return subcubes
 
     def _fit_dimension(self, dimension: dict[str, tuple[float, float]]) -> dict[str, tuple[float, float]]:
         new_dimension: dict[str, tuple[float, float]] = {}
@@ -231,12 +237,14 @@ class HyperCube:
         return False
 
     def copy(self) -> HyperCube:
-        return HyperCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube = HyperCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
     def count(self, dataset: pd.DataFrame) -> int:
         return self.filter_dataframe(dataset.iloc[:, :-1]).shape[0]
 
-    def _interval_to_value(self, dimension, unscale):
+    def interval_to_value(self, dimension, unscale=None):
         if dimension not in self._infinite_dimensions:
             return Between(unscale(self[dimension][0], dimension), unscale(self[dimension][1], dimension))
         if len(self._infinite_dimensions[dimension]) == 2:
@@ -247,7 +255,7 @@ class HyperCube:
             return LessThan(unscale(self[dimension][1], dimension))
 
     def body(self, variables: dict[str, Var], ignore: list[str], unscale=None, normalization=None) -> Iterable[Struct]:
-        values = [(dim, self._interval_to_value(dim, unscale)) for dim in self.dimensions if dim not in ignore]
+        values = [(dim, self.interval_to_value(dim, unscale)) for dim in self.dimensions if dim not in ignore]
         return [create_term(variables[name], value) for name, value in values
                 if not self.is_default and value is not None]
 
@@ -439,8 +447,8 @@ class HyperCube:
 
 
 class RegressionCube(HyperCube):
-    def __init__(self, dimension: dict[str, tuple] = None, output=None):
-        super().__init__(dimension=dimension, output=LinearRegression() if output is None else output)
+    def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None, output=None):
+        super().__init__(dimension=dimension, limits=limits, output=LinearRegression() if output is None else output)
 
     def update(self, dataset: pd.DataFrame, predictor) -> None:
         filtered = self.filter_dataframe(dataset.iloc[:, :-1])
@@ -458,7 +466,9 @@ class RegressionCube(HyperCube):
             output.intercept_ = self.output.intercept_
         except AttributeError:
             pass
-        return RegressionCube(self.dimensions.copy(), output=output)
+        new_cube = RegressionCube(self.dimensions.copy(), self._limits.copy(), output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
     def body(self, variables: dict[str, Var], ignore: list[str], unscale=None, normalization=None) -> Iterable[Struct]:
         intercept = self.output.intercept_ if normalization is None else unscale(sum(
@@ -487,12 +497,15 @@ class ClassificationCube(HyperCube):
             self._barycenter = Point(means.index.values, means.values)
 
     def copy(self) -> ClassificationCube:
-        return ClassificationCube(self.dimensions.copy(), self._limits.copy(), self._output)
+        new_cube = ClassificationCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
 
 class ClosedCube(HyperCube):
-    def __init__(self, dimension: dict[str, tuple] = None, output: str | LinearRegression | float = 0.0):
-        super().__init__(dimension=dimension, output=output)
+    def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None,
+                 output: str | LinearRegression | float = 0.0):
+        super().__init__(dimension=dimension, limits=limits, output=output)
 
     def __contains__(self, obj: dict[str, float] | ClosedCube) -> bool:
         """
@@ -533,12 +546,14 @@ class ClosedCube(HyperCube):
         return np.all((v[:, 0] <= ds) & (ds <= v[:, 1]), axis=1)
 
     def copy(self) -> ClosedCube:
-        return ClosedCube(self.dimensions.copy(), output=self._output)
+        new_cube = ClosedCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
 
 class ClosedRegressionCube(ClosedCube, RegressionCube):
-    def __init__(self, dimension: dict[str, tuple] = None, output=None):
-        super().__init__(dimension=dimension, output=LinearRegression() if output is None else output)
+    def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None, output=None):
+        super().__init__(dimension=dimension, limits=limits, output=LinearRegression() if output is None else output)
 
     def copy(self) -> ClosedRegressionCube:
         output = LinearRegression()
@@ -547,15 +562,19 @@ class ClosedRegressionCube(ClosedCube, RegressionCube):
             output.intercept_ = self.output.intercept_
         except AttributeError:
             pass
-        return ClosedRegressionCube(self.dimensions.copy(), output=output)
+        new_cube = ClosedRegressionCube(self.dimensions.copy(), self._limits.copy(), output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
 
 class ClosedClassificationCube(ClosedCube, ClassificationCube):
-    def __init__(self, dimension: dict[str, tuple] = None, output: str = None):
-        super().__init__(dimension=dimension, output=output)
+    def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None, output: str = None):
+        super().__init__(dimension=dimension, limits=limits, output=output)
 
     def copy(self) -> ClosedClassificationCube:
-        return ClosedClassificationCube(self.dimensions.copy(), output=self._output)
+        new_cube = ClosedClassificationCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
 
 GenericCube = Union[HyperCube, ClassificationCube, RegressionCube,

psyke/hypercubepredictor.py

@@ -76,8 +76,10 @@ class HyperCubePredictor(EvaluableModel):
             return round(HyperCubePredictor._get_cube_output(cube, data), get_int_precision())
 
     def _find_cube(self, data: dict[str, float]) -> GenericCube | None:
+        data = data.copy()
         for dimension in self._dimensions_to_ignore:
-            del data[dimension]
+            if dimension in data:
+                del data[dimension]
         for cube in self._hypercubes:
             if data in cube:
                 return cube.copy()

psyke/schema/__init__.py

@@ -4,7 +4,7 @@ from typing import Callable
 from psyke.utils import get_int_precision
 
 _EMPTY_INTERSECTION_EXCEPTION: Callable = lambda x, y: \
-    Exception("Empty intersection between two Value: " + str(x) + ' and ' + str(y))
+    Exception(f"Empty intersection between two Value: {str(x)} and {str(y)}")
 
 _NOT_IMPLEMENTED_INTERSECTION: Callable = lambda x, y: \
     Exception("Not implemented intersection between: " + str(x) + ' and ' + str(y))
@@ -85,12 +85,26 @@ class Value:
         else:
             return False
 
+    def __neg__(self) -> Value:
+        if isinstance(self, Constant):
+            return self
+        elif isinstance(self, GreaterThan):
+            return LessThan(self.value, self.standard)
+        elif isinstance(self, LessThan):
+            return GreaterThan(self.value, self.standard)
+        elif isinstance(self, Between):
+            return Outside(self.lower, self.upper, self.standard)
+        elif isinstance(self, Outside):
+            return Between(self.lower, self.upper, self.standard)
+        else:
+            raise TypeError
+
     # TODO: handle convention (low priority).
     def __mul__(self, other) -> Value:
 
         def intersection_with_constant(first_value: Constant, second_value: Value) -> Value:
             if isinstance(first_value, Constant):
-                if second_value.is_in(first_value.value):
+                if first_value in second_value:
                     return first_value
                 else:
                     raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
@@ -100,42 +114,45 @@ class Value:
         def intersection_with_outside(first_value: Outside, second_value: Value) -> Value:
             if isinstance(first_value, Outside):
                 if isinstance(second_value, LessThan):
-                    if second_value.value <= first_value.lower:
-                        return second_value
-                    elif first_value.is_in(second_value.value):
+                    if second_value.value > first_value.upper:
+                        # LessThan(first_value.lower) + Between(first_value.lower, second_value.value)
+                        raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
+                    elif second_value.value > first_value.lower:
                         return LessThan(first_value.lower)
                     else:
-                        raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
+                        return second_value
                 elif isinstance(second_value, GreaterThan):
-                    if second_value.value >= first_value.lower:
+                    if second_value.value < first_value.lower:
+                        # Between(second_value.value, first_value.lower) + GreaterThan(first_value.upper)
+                        raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
+                    elif second_value.value < first_value.upper:
                         return GreaterThan(first_value.upper)
-                    elif first_value.is_in(second_value.value):
-                        return second_value
                     else:
-                        raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
-                elif isinstance(second_value, Constant):
-                    if not first_value.is_in(second_value.value):
                         return second_value
-                    else:
-                        raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
                 elif isinstance(second_value, Between):
-                    if second_value in first_value:
+                    if second_value.upper <= first_value.lower or second_value.lower >= first_value.upper:
                         return second_value
                     elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
                         return Between(second_value.lower, first_value.lower)
                     elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
                         return Between(first_value.upper, second_value.upper)
-                    else:
+                    elif second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
                         raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
+                    else:
+                        raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
                 elif isinstance(second_value, Outside):
-                    if second_value.lower <= first_value.lower and second_value.upper >= first_value.upper:
+                    if second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
                         return second_value
-                    elif first_value.lower <= second_value.lower and first_value.upper >= second_value.upper:
+                    elif first_value.lower <= second_value.lower <= second_value.upper <= first_value.upper:
                         return first_value
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Outside(second_value.lower, first_value.upper)
+                    elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
+                        return Outside(first_value.lower, second_value.upper)
                     else:
                         raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
                 elif isinstance(second_value, Constant):
-                    intersection_with_constant(second_value, first_value)
+                    return intersection_with_constant(second_value, first_value)
                 else:
                     raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
             else:
@@ -173,7 +190,7 @@ class Value:
                     else:
                         raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
                 elif isinstance(second_value, Constant):
-                    intersection_with_constant(second_value, first_value)
+                    return intersection_with_constant(second_value, first_value)
                 elif isinstance(second_value, Outside):
                     return intersection_with_outside(second_value, first_value)
                 else:
@@ -233,6 +250,9 @@ class Value:
         else:
             raise _INTERSECTION_WITH_WRONG_TYPE(self, other)
 
+    def print(self) -> str:
+        pass
+
 
 class Interval(Value):
 
@@ -248,7 +268,7 @@ class Interval(Value):
     def __repr__(self):
         return f"Interval({self.lower:.2f}, {self.upper:.2f})"
 
-    def __eq__(self, other: Between) -> bool:
+    def __eq__(self, other: Interval) -> bool:
         return (self.upper == other.upper) and (self.lower == other.lower) and (self.standard == other.standard)
 
 
@@ -264,6 +284,9 @@ class LessThan(Interval):
     def value(self) -> float:
         return self.upper
 
+    def print(self) -> str:
+        return f"below {round(self.upper, 1)}"
+
     def __str__(self):
         return f"]-∞, {self.upper:.2f}" + ("]" if self.standard else "[")
 
@@ -271,7 +294,8 @@ class LessThan(Interval):
         return f"LessThan({self.upper:.2f})"
 
     def __eq__(self, other: LessThan) -> bool:
-        return (self.upper == other.upper) and (self.value == other.value) and (self.standard == other.standard)
+        return isinstance(other, LessThan) and (self.upper == other.upper) and \
+               (self.value == other.value) and (self.standard == other.standard)
 
 
 class GreaterThan(Interval):
@@ -286,6 +310,9 @@ class GreaterThan(Interval):
     def value(self) -> float:
         return self.lower
 
+    def print(self) -> str:
+        return f"above {round(self.lower, 1)}"
+
     def __str__(self):
         return ("]" if self.standard else "[") + f"{self.lower:.2f}, ∞["
 
@@ -293,7 +320,8 @@ class GreaterThan(Interval):
         return f"GreaterThan({self.lower:.2f})"
 
     def __eq__(self, other: GreaterThan) -> bool:
-        return (self.lower == other.lower) and (self.value == other.value) and (self.standard == other.standard)
+        return isinstance(other, GreaterThan) and (self.lower == other.lower) and \
+               (self.value == other.value) and (self.standard == other.standard)
 
 
 class Between(Interval):
@@ -304,6 +332,9 @@ class Between(Interval):
     def is_in(self, other: float) -> bool:
         return self.lower <= other < self.upper if self.standard else self.lower < other <= self.upper
 
+    def print(self) -> str:
+        return f"between {round(self.lower, 1)} and {round(self.upper, 1)}"
+
     def __str__(self):
         return ("[" if self.standard else "]") + f"{self.lower:.2f}, {self.upper:.2f}" + ("[" if self.standard else "]")
 
@@ -319,6 +350,9 @@ class Outside(Interval):
     def is_in(self, other: float) -> bool:
         return other < self.lower or self.upper <= other if self.standard else other <= self.lower or self.upper < other
 
+    def print(self) -> str:
+        return f"not between {round(self.lower, 1)} and {round(self.upper, 1)}"
+
     def __str__(self):
         return f"]-∞, {self.lower:.2f}" + ("[" if self.standard else "]") + ' U '\
                + ("[" if self.standard else "]") + f"{self.upper:.2f}, ∞["
@@ -336,6 +370,9 @@ class Constant(Value):
     def is_in(self, other: float) -> bool:
         return math.isclose(other, self.value)
 
+    def print(self) -> str:
+        return f"equal {round(self.value, 1)}"
+
     def __str__(self):
         return "{" + str(self.value) + "}"
 

{psyke-0.8.3.dev2.dist-info → psyke-0.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.8.3.dev2
+Version: 0.8.5
 Summary: Python-based implementation of PSyKE, i.e. a Platform for Symbolic Knowledge Extraction
 Home-page: https://github.com/psykei/psyke-python
 Author: Matteo Magnini

{psyke-0.8.3.dev2.dist-info → psyke-0.8.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
-psyke/__init__.py,sha256=weEnLws23jzCu_wqZVfq-jVlikiGle14coSMrjUnt7w,18155
-psyke/hypercubepredictor.py,sha256=XceZtTy70QI0PaoCuowvnJWZWcF3NoWF4Khd3qXHCgk,4507
+psyke/__init__.py,sha256=MSMiwvVth4kqmGvQt6HiYNR3J4EdINe8PBmK8-DQVSo,18545
+psyke/hypercubepredictor.py,sha256=MlSRLky6J1I07qKcH98c9WvEjFHGyBiz_LU9W_oDnqs,4572
 psyke/clustering/__init__.py,sha256=36MokTVwwWR_-o0mesvXHaYEYVTK2pn2m0ZY4G3Y3qU,581
 psyke/clustering/utils.py,sha256=S0YwCKyHVYp9qUAQVzCMrTwcQFPJ5TD14Jwn10DE-Z4,1616
 psyke/clustering/cream/__init__.py,sha256=W6k7vdjuUdA_azYA4vb5JtpWrofhDJ0DbM2jsnRKzfw,2994
@@ -7,12 +7,12 @@ psyke/clustering/exact/__init__.py,sha256=s4MPvGZ6gle3X9WH3YFHOEdinGcXIXh-7EFRcE
 psyke/extraction/__init__.py,sha256=ziZ8T9eAOZjKipepE5_j1zfZgyFPONjW8MGERSk83nI,743
 psyke/extraction/cart/__init__.py,sha256=s8tr7jPhONgF0pfetHieFax2MD8cy6ddOS7dRWzZLjc,3579
 psyke/extraction/cart/predictor.py,sha256=2-2mv5fI0lTwwfTaEonxKh0ZUdhxuIEE6OP_rJxgmqc,3019
-psyke/extraction/hypercubic/__init__.py,sha256=34ZB7zwLs3NKaJBKlpxytnyfGtOl9LVdZX3ppxZrN8k,12042
-psyke/extraction/hypercubic/hypercube.py,sha256=Ws0tky0CMvCVuIwBJNxmY97xsG7VapwLQ2uSwpWlb1g,24510
+psyke/extraction/hypercubic/__init__.py,sha256=w_NmfSjh8fCWLDXVXpRLiAApq697cvUSPTgju-jtZCA,10620
+psyke/extraction/hypercubic/hypercube.py,sha256=GKjplRl34BegrA3JclvlkrL7hXftdUUMXndmRFFoJic,25697
 psyke/extraction/hypercubic/strategy.py,sha256=X-roIsfcpJyMdo2px5JtbhP7-XE-zUNkaEK7XGXoWA8,1636
 psyke/extraction/hypercubic/utils.py,sha256=D2FN5CCm_T3h23DmLFoTnIcFo7LvIq__ktl4hjUqkcA,1525
 psyke/extraction/hypercubic/cosmik/__init__.py,sha256=XQUvOtMFpR0vMHYtwIVl3G626HMqN8Clt6BqNm4nvFs,1880
-psyke/extraction/hypercubic/creepy/__init__.py,sha256=8bT0zVsJs9odlVuMIzQUzMwUpfcFwbULzm7dlbhyJkg,1730
+psyke/extraction/hypercubic/creepy/__init__.py,sha256=js91nWXOSJtRFFjnNzv4eDKnRYthe1GA1a-CGAaHzDM,1735
 psyke/extraction/hypercubic/divine/__init__.py,sha256=ClO8CITKKXoo7nhlBJagR1yAachsxLHYQlqggl-9eGE,3665
 psyke/extraction/hypercubic/gridex/__init__.py,sha256=o7tNU3JH8AqA2PRj839-rPb6zhwAdpaCVGC__0DH-b0,5543
 psyke/extraction/hypercubic/gridrex/__init__.py,sha256=h9usK5tFqd6ngBmRydsgkfQ1jlcQKj2uG72Tr1puFHk,595
@@ -22,7 +22,7 @@ psyke/extraction/real/__init__.py,sha256=fFqiwgWTpu5Jx9lz5CdSfs1QyqWYFLQDG7tc5M6
 psyke/extraction/real/utils.py,sha256=eHGU-Y0inn_8jrk9lMcuRUKXpsTkI-s_myXSWz4bALQ,2190
 psyke/extraction/trepan/__init__.py,sha256=KpZpk0btCWV4bS-DOmpgpYscSQ5FEMyP54ekm7ZedME,6583
 psyke/extraction/trepan/utils.py,sha256=iSUJ1ooNQT_VO1KfBZuIUeUsyUbGdQf_pSEE87vMeQg,2320
-psyke/schema/__init__.py,sha256=gOUWx3gYSkRehlJ5opK0Q16-Tv5fwSTl19k7kzIHALU,15760
+psyke/schema/__init__.py,sha256=66Jm4hk9s2ZBdXUF7tg43_zG0X6XicMYOPsBkXyY0wE,17444
 psyke/tuning/__init__.py,sha256=I-07lLZb02DoIm9AGXPPPOkB55ANu8RU4TMy2j30Pxg,3574
 psyke/tuning/crash/__init__.py,sha256=zIHEF75EFy_mRIieqzP04qKLG3GLsSc_mYZHpPfkzxU,2623
 psyke/tuning/orchid/__init__.py,sha256=s64iABbteik27CrRPHSVHNZX25JKlDu7YYjhseOizxw,3618
@@ -33,8 +33,8 @@ psyke/utils/logic.py,sha256=7bbW6qcKof5PlqoQ0n5Kt3Obcot-KqGAvpE8rMXvEPE,12419
 psyke/utils/metrics.py,sha256=Oo5BOonOSfo0qYsXWT5dmypZ7jiStByFC2MKEU0uMHg,2250
 psyke/utils/plot.py,sha256=dE8JJ6tQ0Ezosid-r2jqAisREjFe5LqExRzsVi5Ns-c,7785
 psyke/utils/sorted.py,sha256=C3CPW2JisND30BRk5c1sAAHs3Lb_wsRB2qZrYFuRnfM,678
-psyke-0.8.3.dev2.dist-info/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
-psyke-0.8.3.dev2.dist-info/METADATA,sha256=yEgkd3-2d4UZVtOi0DLoEmiN8wytmsmxEH62tL0i-ZI,8107
-psyke-0.8.3.dev2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-psyke-0.8.3.dev2.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
-psyke-0.8.3.dev2.dist-info/RECORD,,
+psyke-0.8.5.dist-info/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
+psyke-0.8.5.dist-info/METADATA,sha256=5BPTGj6knIWcdwIdQZaXQTPAsl4CLMADsXHZNU9J10w,8102
+psyke-0.8.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+psyke-0.8.5.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
+psyke-0.8.5.dist-info/RECORD,,