eqclass_handler

EquivalenceClassesHandler(test_tree, minmax_values_specs, n_features)

A class used to extract equivalence classes from a decision tree.

Attributes:

test_tree: TestTree The decision tree structure.

dict

Dictionary storing min/max values for each feature from specifications.

int

Number of samples used to train the tree.

int

Number of features in the dataset.

Methods:

get_equivalence_classes() Extracts and formats equivalence classes from the decision tree.

to_str(eqclass) Converts a single equivalence class to a string.

to_strs(eqclasses, feature_names) Converts a list of equivalence classes to a readable string format.

Initializes the EquivalenceClassesHandler.

Parameters:

Name	Type	Description	Default
test_tree	Any	The decision tree used for extracting equivalence classes.	required
minmax_values_specs	dict	Dictionary containing min/max values for each feature.	required
n_features	int	Number of features in the dataset.	required

Source code in src/flowcean/testing/generator/ddtig/domain/model_analyser/surrogate/eqclass_handler.py

def __init__(
    self,
    test_tree: Any,
    minmax_values_specs: dict,
    n_features: int,
) -> None:
    """Initializes the EquivalenceClassesHandler.

    Args:
        test_tree: The decision tree used for extracting
            equivalence classes.
        minmax_values_specs: Dictionary containing min/max
            values for each feature.
        n_features: Number of features in the dataset.
    """
    self.test_tree = test_tree.test_tree
    self.n_samples = test_tree.get_n_samples()
    self.minmax_values_specs = minmax_values_specs
    self.n_features = n_features
    self.eqclass_prio = []

get_equivalence_classes()

Extracts and formats equivalence classes from the decision tree.

Returns:

Type	Description
list	List of formatted equivalence classes.

Source code in src/flowcean/testing/generator/ddtig/domain/model_analyser/surrogate/eqclass_handler.py

def get_equivalence_classes(self) -> list:
    """Extracts and formats equivalence classes from the decision tree.

    Returns:
        List of formatted equivalence classes.
    """
    self.eqclass_prio = []
    paths = self._collect_all_paths(self.ROOT_INDEX)
    equivalence_classes = self._extract_equivalence_classes(paths)
    equivalence_classes_formatted = self._format_equivalence_classes(
        equivalence_classes,
    )
    logger.info("Extracted equivalence classes successfully.")
    return equivalence_classes_formatted

to_str(eqclass) staticmethod

Converts a single equivalence class to a string.

Parameters:

Name	Type	Description	Default
eqclass	tuple	A tuple of Interval objects.	required

Returns:

Type	Description
str	String representation of the equivalence class.

Source code in src/flowcean/testing/generator/ddtig/domain/model_analyser/surrogate/eqclass_handler.py

@staticmethod
def to_str(eqclass: tuple) -> str:
    """Converts a single equivalence class to a string.

    Args:
        eqclass: A tuple of Interval objects.

    Returns:
        String representation of the equivalence class.
    """
    eqclass_str = "("
    eqclass_str += eqclass[0].__str__()
    for interval in eqclass[1:]:
        eqclass_str += ", "
        eqclass_str += interval.__str__()
    eqclass_str += ")"
    return eqclass_str

to_strs(eqclasses, feature_names) staticmethod

Converts a list of equivalence classes to a readable string format.

Parameters:

Name	Type	Description	Default
eqclasses	list	List of equivalence classes.	required
feature_names	list	List of feature names.	required

Returns:

Type	Description
str	Formatted string of all equivalence classes.

Source code in src/flowcean/testing/generator/ddtig/domain/model_analyser/surrogate/eqclass_handler.py

@staticmethod
def to_strs(eqclasses: list, feature_names: list) -> str:
    """Converts a list of equivalence classes to a readable string format.

    Args:
        eqclasses: List of equivalence classes.
        feature_names: List of feature names.

    Returns:
        Formatted string of all equivalence classes.
    """
    eqclasses_str = ""
    for i in range(len(eqclasses)):
        feature_idx = 0
        eqclasses_str += f"Equivalence class {i}:\n"
        eqclasses_str += "{"
        eqclasses_str += f"{feature_names[feature_idx]}: "
        eqclasses_str += eqclasses[i][feature_idx].__str__()
        for interval in eqclasses[i][1:]:
            feature_idx += 1
            eqclasses_str += ", "
            eqclasses_str += f"{feature_names[feature_idx]}: "
            eqclasses_str += interval.__str__()
        eqclasses_str += "}\n"
    return eqclasses_str

is_subset(eqclass1, eqclass2) staticmethod

Compares interval ranges of features between classes.

Compares the interval ranges of all features between two equivalence classes and determines which one is a subset of the other.

An equivalence class is considered a subset only if all its intervals are strictly contained within the corresponding intervals of the other class. The method returns the superset equivalence class if such a relationship exists.

Parameters:

Name	Type	Description	Default
eqclass1	tuple	First equivalence class (tuple of Interval objects).	required
eqclass2	tuple	Second equivalence class (tuple of Interval objects).	required

Returns:

Type	Description
tuple | None	The equivalence class that is the superset,
tuple | None	or None if neither is a subset of the other.

Source code in src/flowcean/testing/generator/ddtig/domain/model_analyser/surrogate/eqclass_handler.py

@staticmethod
def is_subset(eqclass1: tuple, eqclass2: tuple) -> tuple | None:
    """Compares interval ranges of features between classes.

    Compares the interval ranges of all features between two equivalence
    classes and determines which one is a subset of the other.

    An equivalence class is considered a subset only if all its
    intervals are strictly contained within the corresponding
    intervals of the other class. The method returns the
    superset equivalence class if such a relationship exists.

    Args:
        eqclass1: First equivalence class (tuple of Interval objects).
        eqclass2: Second equivalence class (tuple of Interval objects).

    Returns:
        The equivalence class that is the superset,
        or None if neither is a subset of the other.
    """
    from flowcean.testing.generator.ddtig.domain import Interval

    # Compare the first interval to determine initial superset
    interval_a = eqclass1[0]
    interval_b = eqclass2[0]
    interval_res = Interval.is_subset(interval_a, interval_b)

    if interval_res is None:
        return None

    # Identify which equivalence class contains the superset interval
    eqclass_large = eqclass1 if interval_res == interval_a else eqclass2

    # Check consistency across all remaining intervals
    for idx in range(1, len(eqclass1)):
        interval_a = eqclass1[idx]
        interval_b = eqclass2[idx]
        interval_res = Interval.is_subset(interval_a, interval_b)

        if interval_res is None or (
            ((interval_res == interval_a) and (eqclass_large != eqclass1))
            or (
                (interval_res == interval_b)
                and (eqclass_large != eqclass2)
            )
        ):
            return None

    return eqclass_large