psyke 0.4.9.dev6__py3-none-any.whl → 1.0.4.dev10__py3-none-any.whl

psyke/genetic/gin/__init__.py

@@ -0,0 +1,144 @@
+from statistics import mode
+
+import numpy as np
+from deap import base, creator, tools, algorithms
+import random
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_absolute_error, r2_score, mean_squared_error, f1_score, accuracy_score
+from sklearn.preprocessing import PolynomialFeatures
+
+from psyke import Target
+
+
+class GIn:
+
+    def __init__(self, train, valid, features, sigmas, slices, min_rules=1, poly=1, alpha=0.5, indpb=0.5, tournsize=3,
+                 metric='R2', output=Target.REGRESSION, warm=False):
+        self.X, self.y = train
+        self.valid = valid
+        self.output = output
+
+        self.features = features
+        self.sigmas = sigmas
+        self.slices = slices
+        self.min_rules = min_rules
+        self.poly = PolynomialFeatures(degree=poly, include_bias=False)
+
+        self.alpha = alpha
+        self.indpb = indpb
+        self.tournsize = tournsize
+        self.metric = metric
+
+        self.toolbox = None
+        self.stats = None
+        self.hof = None
+        self.best = None
+
+        self.__setup(warm)
+
+    def _region(self, x, cuts):
+        indices = [np.searchsorted(np.array(cut), x[f].to_numpy(), side='right')
+                   for cut, f in zip(cuts, self.features)]
+
+        regions = np.zeros(len(x), dtype=int)
+        multiplier = 1
+        for idx, n in zip(reversed(indices), reversed([len(cut) + 1 for cut in cuts])):
+            regions += idx * multiplier
+            multiplier *= n
+
+        return regions
+
+    def _output_estimation(self, mask, to_pred):
+        if self.output == Target.REGRESSION:
+            return LinearRegression().fit(self.poly.fit_transform(self.X)[mask], self.y[mask]).predict(
+                self.poly.fit_transform(to_pred))
+        if self.output == Target.CONSTANT:
+            return np.mean(self.y[mask])
+        if self.output == Target.CLASSIFICATION:
+            return mode(self.y[mask])
+        raise ValueError('Supported outputs are Target.{REGRESSION, CONSTANT, CLASSIFICATION}')
+
+    def _score(self, true, pred):
+        if self.metric == 'R2':
+            return r2_score(true, pred)
+        if self.metric == 'MAE':
+            return -mean_absolute_error(true, pred)
+        if self.metric == 'MSE':
+            return -mean_squared_error(true, pred)
+        if self.metric == 'F1':
+            return f1_score(true, pred, average='weighted')
+        if self.metric == 'ACC':
+            return accuracy_score(true, pred)
+        raise ValueError('Supported metrics are R2, MAE, MSE, F1, ACC')
+
+    def predict(self, to_pred):
+        return self.__predict(to_pred=to_pred)[0]
+
+    def _get_cuts(self, individual):
+        boundaries = np.cumsum([0] + list(self.slices))
+        return [sorted(individual[boundaries[i]:boundaries[i + 1]]) for i in range(len(self.slices))]
+
+    def __predict(self, individual=None, to_pred=None):
+        cuts = self._get_cuts(individual or self.best)
+
+        regions = self._region(to_pred, cuts)
+        regionsT = self._region(self.X, cuts)
+
+        pred = np.empty(len(to_pred), dtype=f'U{self.y.str.len().max()}') if self.output == Target.CLASSIFICATION \
+            else np.zeros(len(to_pred))
+        valid_regions = 0
+
+        for r in range(np.prod([s + 1 for s in self.slices])):
+            mask = regions == r
+            maskT = regionsT == r
+            if min(mask.sum(), maskT.sum()) < 3:
+                if self.output != Target.CLASSIFICATION:
+                    pred[mask] = np.mean(self.y)
+                continue
+            pred[mask] = self._output_estimation(maskT, to_pred[mask])
+            valid_regions += 1
+
+        return pred, valid_regions
+
+    def _evaluate(self, individual=None):
+        y_pred, valid_regions = self.__predict(individual or self.best, self.X if self.valid is None else self.valid[0])
+        if valid_regions < self.min_rules:
+            return -9999,
+        return self._score(self.y if self.valid is None else self.valid[1], y_pred),
+
+    def __setup(self, warm=False):
+        if not warm:
+            creator.create("FitnessMax", base.Fitness, weights=(1.0,))
+            creator.create("Individual", list, fitness=creator.FitnessMax)
+
+        self.toolbox = base.Toolbox()
+        for f in self.features:
+            self.toolbox.register(f, random.uniform, self.X[f].min(), self.X[f].max())
+
+        self.toolbox.register("individual", tools.initCycle, creator.Individual,
+                              (sum([[getattr(self.toolbox, f) for i in range(s)]
+                                    for f, s in zip(self.features, self.slices)], [])), n=1)
+
+        self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual)
+
+        self.toolbox.register("mate", tools.cxBlend, alpha=self.alpha)
+        self.toolbox.register("mutate", tools.mutGaussian, indpb=self.indpb, mu=0,
+                              sigma=sum([[sig] * s for sig, s in zip(self.sigmas, self.slices)], []))
+        self.toolbox.register("select", tools.selTournament, tournsize=self.tournsize)
+        self.toolbox.register("evaluate", self._evaluate)
+
+        self.stats = tools.Statistics(lambda ind: ind.fitness.values[0])
+        self.stats.register("avg", np.mean)
+        # self.stats.register("min", np.min)
+        self.stats.register("max", np.max)
+        # self.stats.register("std", np.std)
+
+        self.hof = tools.HallOfFame(1)
+
+    def run(self, n_pop=30, cxpb=0.8, mutpb=0.5, n_gen=50, seed=123):
+        random.seed(seed)
+        pop = self.toolbox.population(n=n_pop)
+        result, log = algorithms.eaSimple(pop, self.toolbox, cxpb=cxpb, mutpb=mutpb, ngen=n_gen,
+                                          stats=self.stats, halloffame=self.hof, verbose=False)
+        self.best = tools.selBest(pop, 1)[0]
+        return self.best, self._evaluate()[0], result, log

psyke/hypercubepredictor.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+import numpy as np
+import pandas as pd
+from sklearn.neighbors import BallTree
+
+from psyke import EvaluableModel, Target, get_int_precision
+from psyke.extraction.hypercubic import RegressionCube, GenericCube, Point
+
+
+class HyperCubePredictor(EvaluableModel):
+    def __init__(self, output=Target.CONSTANT, discretization=None, normalization=None):
+        super().__init__(discretization, normalization)
+        self._hypercubes = []
+        self._dimensions_to_ignore = set()
+        self._output = output
+        self._surrounding = None
+
+    def _predict(self, dataframe: pd.DataFrame) -> Iterable:
+        return np.array([self._predict_from_cubes(row.to_dict()) for _, row in dataframe.iterrows()])
+
+    def _brute_predict(self, dataframe: pd.DataFrame, criterion: str = 'corner', n: int = 2) -> Iterable:
+        predictions = np.array(self._predict(dataframe))
+        idx = [prediction is None for prediction in predictions]
+        if sum(idx) > 0:
+            if criterion == 'default':
+                predictions[idx] = np.array([HyperCubePredictor._get_cube_output(
+                    self._surrounding, row
+                ) for _, row in dataframe[idx].iterrows()])
+            elif criterion == 'surface':
+                predictions[idx] = np.array([HyperCubePredictor._get_cube_output(self._brute_predict_surface(row), row)
+                                             for _, row in dataframe[idx].iterrows()])
+            else:
+                tree, cubes = self._create_brute_tree(criterion, n)
+                predictions[idx] = np.array([HyperCubePredictor._brute_predict_from_cubes(
+                    row.to_dict(), tree, cubes
+                ) for _, row in dataframe[idx].iterrows()])
+        return np.array(predictions)
+
+    @staticmethod
+    def _brute_predict_from_cubes(row: dict[str, float], tree: BallTree,
+                                  cubes: list[GenericCube]) -> float | str:
+        idx = tree.query([list(row.values())], k=1)[1][0][0]
+        return HyperCubePredictor._get_cube_output(cubes[idx], row)
+
+    def _brute_predict_surface(self, row: pd.Series) -> GenericCube:
+        return min([(
+            cube.surface_distance(Point(list(row.keys()), list(row.values))), cube.volume(), cube
+        ) for cube in self._hypercubes])[-1]
+
+    def _create_brute_tree(self, criterion: str = 'center', n: int = 2) -> (BallTree, list[GenericCube]):
+        admissible_criteria = ['surface', 'center', 'corner', 'perimeter', 'density', 'default']
+        if criterion not in admissible_criteria:
+            raise NotImplementedError(
+                "'criterion' should be chosen in " + str(admissible_criteria)
+            )
+
+        points = [(cube.center, cube) for cube in self._hypercubes] if criterion == 'center' else \
+            [(cube.barycenter, cube) for cube in self._hypercubes] if criterion == 'density' else \
+            [(corner, cube) for cube in self._hypercubes for corner in cube.corners()] if criterion == 'corner' else \
+            [(point, cube) for cube in self._hypercubes for point in cube.perimeter_samples(n)] \
+            if criterion == 'perimeter' else None
+
+        return BallTree(pd.concat([point[0].to_dataframe() for point in points], ignore_index=True)), \
+            [point[1] for point in points]
+
+    def _predict_from_cubes(self, data: dict[str, float]) -> float | str | None:
+        cube = self._find_cube(data)
+        if cube is None:
+            return None
+        elif self._output == Target.CLASSIFICATION:
+            return HyperCubePredictor._get_cube_output(cube, data)
+        else:
+            return round(HyperCubePredictor._get_cube_output(cube, data), get_int_precision())
+
+    def _find_cube(self, data: dict[str, float]) -> GenericCube | None:
+        if not self._hypercubes:
+            return None
+        data = data.copy()
+        for dimension in self._dimensions_to_ignore:
+            if dimension in data:
+                del data[dimension]
+        for cube in self._hypercubes:
+            if data in cube:
+                return cube.copy()
+        if self._hypercubes[-1].is_default:
+            return self._hypercubes[-1].copy()
+
+    @property
+    def n_rules(self):
+        return len(list(self._hypercubes))
+
+    @property
+    def volume(self):
+        return sum([cube.volume() for cube in self._hypercubes])
+
+    @staticmethod
+    def _get_cube_output(cube, data: dict[str, float]) -> float:
+        return cube.output.predict(pd.DataFrame([data])).flatten()[0] if \
+            isinstance(cube, RegressionCube) else cube.output

psyke/schema/__init__.py

@@ -3,14 +3,27 @@ import math
 from typing import Callable
 from psyke.utils import get_int_precision
 
+
+class SchemaException(Exception):
+
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
 _EMPTY_INTERSECTION_EXCEPTION: Callable = lambda x, y: \
-    Exception("Empty intersection between two Value: " + str(x) + ' and ' + str(y))
+    SchemaException(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))
+    SchemaException(f"Not implemented intersection between: {str(x)} and {str(y)}")
 
-_INTERSECTION_WITH_WRONG_TYPE: Callable = lambda x, y: \
-    Exception("Calling method with wrong type argument: " + str(x) + ' and ' + str(y))
+_OPERATION_WITH_WRONG_TYPE: Callable = lambda x, y: \
+    SchemaException("Calling method with wrong type argument: " + str(x) + ' and ' + str(y))
+
+_EMPTY_UNION_EXCEPTION: Callable = lambda x, y: \
+    SchemaException(f"Empty union between two Value: {str(x)} and {str(y)}")
+
+_NOT_IMPLEMENTED_UNION: Callable = lambda x, y: \
+    SchemaException("Not implemented union between: " + str(x) + ' and ' + str(y))
 
 PRECISION = get_int_precision()
 STRING_PRECISION = str(PRECISION)
@@ -85,61 +98,78 @@ 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)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_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)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_between(first_value: Between, second_value: Value) -> Value:
             if isinstance(first_value, Between):
@@ -173,13 +203,13 @@ 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:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_less_than(first_value: LessThan, second_value: Value) -> Value:
             if isinstance(first_value, LessThan):
@@ -197,9 +227,9 @@ class Value:
                 elif isinstance(second_value, Between):
                     return intersection_with_between(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_greater_than(first_value: GreaterThan, second_value: Value) -> Value:
             if isinstance(first_value, GreaterThan):
@@ -214,9 +244,9 @@ class Value:
                 elif isinstance(second_value, LessThan):
                     return intersection_with_less_than(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         if other is None:
             return self
@@ -231,7 +261,154 @@ class Value:
         elif isinstance(self, GreaterThan):
             return intersection_with_greater_than(self, other)
         else:
-            raise _INTERSECTION_WITH_WRONG_TYPE(self, other)
+            raise _OPERATION_WITH_WRONG_TYPE(self, other)
+
+    def __add__(self, other) -> Value:
+
+        def union_with_constant(first_value: Constant, second_value: Value) -> Value:
+            if isinstance(first_value, Constant):
+                if first_value in second_value:
+                    return second_value
+                else:
+                    raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_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.upper:
+                        return Between(-math.inf, math.inf)
+                    elif second_value.value > first_value.lower:
+                        return Outside(second_value.value, first_value.upper)
+                    else:
+                        return first_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value < first_value.lower:
+                        return Between(-math.inf, math.inf)
+                    elif second_value.value < first_value.upper:
+                        return Outside(first_value.lower, second_value.value)
+                    else:
+                        return first_value
+                elif isinstance(second_value, Between):
+                    if second_value.upper <= first_value.lower or second_value.lower >= first_value.upper:
+                        return first_value
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Outside(second_value.upper, first_value.lower)
+                    elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
+                        return Outside(first_value.upper, second_value.lower)
+                    elif second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
+                        return Between(-math.inf, math.inf)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Outside):
+                    if second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
+                        return first_value
+                    elif first_value.lower <= second_value.lower <= second_value.upper <= first_value.upper:
+                        return second_value
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Outside(first_value.lower, second_value.upper)
+                    elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
+                        return Outside(second_value.lower, first_value.upper)
+                    else:
+                        return Between(-math.inf, math.inf)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_between(first_value: Between, second_value: Value) -> Value:
+            if isinstance(first_value, Between):
+                if isinstance(second_value, LessThan):
+                    if second_value.value <= first_value.lower:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                    elif first_value.lower <= second_value.value <= first_value.upper:
+                        return LessThan(first_value.upper)
+                    else:
+                        return second_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value <= first_value.lower:
+                        return second_value
+                    elif first_value.lower <= second_value.value <= first_value.upper:
+                        return GreaterThan(first_value.lower)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Between):
+                    if second_value in first_value:
+                        return first_value
+                    elif first_value in second_value:
+                        return second_value
+                    elif first_value.lower <= second_value.lower <= first_value.upper:
+                        return Between(first_value.lower, second_value.upper)
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Between(second_value.lower, first_value.upper)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_less_than(first_value: LessThan, second_value: Value) -> Value:
+            if isinstance(first_value, LessThan):
+                if isinstance(second_value, LessThan):
+                    return second_value if first_value in second_value else first_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value <= first_value.value:
+                        return Between(-math.inf, math.inf)
+                    else:
+                        return Outside(first_value.value, second_value.value)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                elif isinstance(second_value, Between):
+                    return union_with_between(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_greater_than(first_value: GreaterThan, second_value: Value) -> Value:
+            if isinstance(first_value, GreaterThan):
+                if isinstance(second_value, GreaterThan):
+                    return second_value if first_value in second_value else first_value
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                elif isinstance(second_value, Between):
+                    return union_with_between(second_value, first_value)
+                elif isinstance(second_value, LessThan):
+                    return union_with_less_than(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        if other is None:
+            return self
+        elif isinstance(self, Constant):
+            return union_with_constant(self, other)
+        elif isinstance(self, Outside):
+            return union_with_outside(self, other)
+        elif isinstance(self, Between):
+            return union_with_between(self, other)
+        elif isinstance(self, LessThan):
+            return union_with_less_than(self, other)
+        elif isinstance(self, GreaterThan):
+            return union_with_greater_than(self, other)
+        else:
+            raise _OPERATION_WITH_WRONG_TYPE(self, other)
+
+    def print(self) -> str:
+        pass
 
 
 class Interval(Value):
@@ -248,7 +425,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 +441,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 +451,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 +467,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 +477,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 +489,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 +507,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 +527,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) + "}"