flamapy-bdd 2.0.0.dev1__tar.gz → 2.0.0.dev7__tar.gz

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flamapy-bdd
-Version: 2.0.0.dev1
+Version: 2.0.0.dev7
 Summary: bdd-plugin for the automated analysis of feature models
 Home-page: https://github.com/flamapy/bdd_metamodel
 Author: Flamapy

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/models/bdd_model.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Optional, Any
+from typing import Optional, Any, Union
 
 # Low-level interface to pure Python implementation (wrapped by dd.autoref.BDD).
 import dd.bdd as _dd_bdd
@@ -33,57 +33,76 @@ class BDDModel(VariabilityModel):
 
     def __init__(self) -> None:
         self._bdd: _bdd.BDD = _bdd.BDD()  # BDD manager
-        self._root: Optional[_bdd.Function | int] = None
-        self._variables: list[Any] = []
+        self._root: Optional[Union[_bdd.Function, int]] = None
+        self.features_variables: dict[Any, Any] = {}
+        self.variables_features: dict[Any, Any] = {}
         self._levels_variables: dict[int, Any] = {}
+        self._formula: Any = None
+
+    def build_bdd(self, expression: str) -> None:
+        """Built a BDD from an expression representing a logical formula.
+
+        It assumes that all variables have been added to 
+        features_variables and variables_features.
+        """
+        self._formula = expression
+        self._bdd.declare(*self.variables_features.keys())
+        self._root = self._bdd.add_expr(expression)
+        self._levels_variables = {l: v for v, l in self._bdd.var_levels.items()}
+
+    @property
+    def formula(self) -> str:
+        return self._formula
 
     @property
-    def bdd(self) -> _bdd.BDD | _dd_bdd.BDD:
+    def bdd(self) -> Union[_bdd.BDD, _dd_bdd.BDD]:
         return self._bdd
 
     @bdd.setter
-    def bdd(self, new_bdd: _bdd.BDD | _dd_bdd.BDD) -> None:
+    def bdd(self, new_bdd: Union[_bdd.BDD, _dd_bdd.BDD]) -> None:
         self._bdd = new_bdd
-        self._variables = list(self._bdd.vars)
+        self.features_variables = {var: var for var in self._bdd.vars}
+        self.variables_features = dict(self.features_variables)
         self._root = next(iter(self._bdd.roots), None)
         self._levels_variables = {l: v for v, l in self._bdd.var_levels.items()}
 
     @property
-    def root(self) -> _bdd.Function | int:
+    def root(self) -> Union[_bdd.Function, int]:
         return self._root
 
     @root.setter
-    def root(self, new_root: _bdd.Function | int) -> None:
+    def root(self, new_root: Union[_bdd.Function, int]) -> None:
         self._root = new_root
-        self._variables = list(self._bdd.vars)
+        self.features_variables = {var: var for var in self._bdd.vars}
+        self.variables_features = dict(self.features_variables)
         self._levels_variables = {l: v for v, l in self._bdd.var_levels.items()}
 
-    @property
-    def variables(self) -> list[Any]:
-        return self._variables
-
-    @classmethod
-    def from_logic_formula(cls, formula: str, variables: list[Any]) -> 'BDDModel':
-        """Build the BDD from a logic formula, and the list of variables.
-
-        The logic formula can be a CNF formula or a propositional logic formula.
-        """
-        bdd_model = cls()
-        # Store variables
-        bdd_model._variables = variables
-        # Declare variables
-        bdd_model._bdd.declare(*variables)
-        # Build the BDD
-        bdd_model._root = bdd_model._bdd.add_expr(formula)
-
-        # Reorder for optimization
-        # Warning! Reordering may make the root starting to level > 0, and thus,
-        # operations won't work correctly.
-        # bdd_model._bdd.reorder()  
-
-        # Levels and variables (dict for optimization)
-        bdd_model._levels_variables = {l: v for v, l in bdd_model._bdd.var_levels.items()}
-        return bdd_model
+    # @classmethod
+    # def from_logic_formula(cls, 
+    #                        formula: str, 
+    #                        variables: list[Any]) -> 'BDDModel':
+    #     """Build the BDD from a logic formula, and the list of variables.
+
+    #     The logic formula can be a CNF formula or a propositional logic formula.
+    #     An optional features_variables and variables_features mapping can be provided 
+    #     to track safe features' and variables' names.
+    #     """
+    #     bdd_model = cls()
+    #     # Store variables
+    #     bdd_model._variables = variables
+    #     # Declare variables
+    #     bdd_model._bdd.declare(*variables)
+    #     # Build the BDD
+    #     bdd_model._root = bdd_model._bdd.add_expr(formula)
+
+    #     # Reorder for optimization
+    #     # Warning! Reordering may make the root starting to level > 0, and thus,
+    #     # operations won't work correctly.
+    #     #bdd_model._bdd.reorder()  
+
+    #     # Levels and variables (dict for optimization)
+    #     bdd_model._levels_variables = {l: v for v, l in bdd_model._bdd.var_levels.items()}
+    #     return bdd_model
 
     def level_of_var(self, var: Any) -> Optional[int]:
         """Return the level of a given variable."""
@@ -93,7 +112,7 @@ class BDDModel(VariabilityModel):
         """Return the variable at the given level."""
         return self._levels_variables.get(level, None)
 
-    def var(self, node: _bdd.Function | int) -> Optional[Any]:
+    def var(self, node: Union[_bdd.Function, int]) -> Optional[Any]:
         """Return the variable of the node.
 
         It returns None if the node is a terminal node.
@@ -105,7 +124,7 @@ class BDDModel(VariabilityModel):
             return self.var_at_level(level)
         return node.var
 
-    def level(self, node: _bdd.Function | int) -> Optional[int]:
+    def level(self, node: Union[_bdd.Function, int]) -> Optional[int]:
         """Return the level of the node.
 
         Non-terminal nodes start at 0.
@@ -118,11 +137,11 @@ class BDDModel(VariabilityModel):
         """Return number of nodes in the BDD."""
         return len(self._bdd)
 
-    def get_node(self, var: Any) -> _bdd.Function | int:
+    def get_node(self, var: Any) -> Union[_bdd.Function, int]:
         """Return the node of the variable."""
         return self._bdd.var(var)
 
-    def index(self, node: _bdd.Function | int) -> Optional[int]:
+    def index(self, node: Union[_bdd.Function, int]) -> Optional[int]:
         """Position (index) of the variable that labels the node `n` in the ordering.
 
         Indexes start at 1.
@@ -133,45 +152,49 @@ class BDDModel(VariabilityModel):
         thus level(n4) = 2.
         """
         if self.is_terminal_node(node):
-            return len(self.variables) + 1
+            return len(self.variables_features) + 1
         level = self.level(node)
         return level + 1 if level is not None else None
 
-    def negated(self, node: _bdd.Function | int) -> bool:
+    def negated(self, node: Union[_bdd.Function, int]) -> bool:
         """Return whether the node is negated."""
         if isinstance(node, int):
             return node < 0
         return node.negated
 
-    def get_terminal_node_n0(self) -> _bdd.Function | int:
+    def get_terminal_node_n0(self) -> Union[_bdd.Function, int]:
         return self._bdd.false
 
-    def get_terminal_node_n1(self) -> _bdd.Function | int:
+    def get_terminal_node_n1(self) -> Union[_bdd.Function, int]:
         return self._bdd.true
 
-    def is_terminal_node(self, node: _bdd.Function | int) -> bool:
+    def is_terminal_node(self, node: Union[_bdd.Function, int]) -> bool:
         """Check if the node is a terminal node."""
         return self.is_terminal_n0(node) or self.is_terminal_n1(node)
 
-    def is_terminal_n1(self, node: _bdd.Function | int) -> bool:
+    def is_terminal_n1(self, node: Union[_bdd.Function, int]) -> bool:
         """Check if the node is the terminal node 1 (n1)."""
         return node == self.get_terminal_node_n1()
 
-    def is_terminal_n0(self, node: _bdd.Function | int) -> bool:
+    def is_terminal_n0(self, node: Union[_bdd.Function, int]) -> bool:
         """Check if the node is the terminal node 0 (n0)."""
         return node == self.get_terminal_node_n0()
 
-    def get_high_node(self, node: _bdd.Function | int) -> Optional[_bdd.Function | int]:
+    def get_high_node(self, 
+                      node: Union[_bdd.Function, int]
+                      ) -> Optional[Union[_bdd.Function, int]]:
         """Return the high (right, solid) node."""
         _, _, high = self._bdd.succ(node)
         return high
 
-    def get_low_node(self, node: _bdd.Function | int) -> Optional[_bdd.Function | int]:
+    def get_low_node(self, 
+                     node: Union[_bdd.Function, int]
+                     ) -> Optional[Union[_bdd.Function, int]]:
         """Return the low (left, dashed) node."""
         _, low, _ = self._bdd.succ(node)
         return low
 
-    def get_value(self, node: _bdd.Function | int, complemented: bool = False) -> int:
+    def get_value(self, node: Union[_bdd.Function, int], complemented: bool = False) -> int:
         """Return the value (id) of the node considering complemented arcs."""
         value = int(node)
         if self.is_terminal_n0(node):
@@ -180,7 +203,7 @@ class BDDModel(VariabilityModel):
             value = 0 if complemented else 1
         return value
 
-    def pretty_node_str(self, node: _bdd.Function | int) -> str:
+    def pretty_node_str(self, node: Union[_bdd.Function, int]) -> str:
         return f'{self.var(node)} ' \
                f'(id: {self.get_value(node)}) ' \
                f'(level: {self.level(node)}) ' \
@@ -192,7 +215,7 @@ class BDDModel(VariabilityModel):
         result += f'#Nodes: {self.nof_nodes()}\n'
         result += f'Root: {self.pretty_node_str(self.root)}\n'
         levels_vars = dict(sorted(self._levels_variables.items(), key=lambda item: item[0]))
-        for level, var in levels_vars.items():
+        for _level, var in levels_vars.items():
             node = self.get_node(var)
             result += f' |-{self.pretty_node_str(node)}\n'
         result += f'Terminal node (n0): {self.pretty_node_str(self.get_terminal_node_n0())}\n'

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/operations/bdd_commonality_factor.py

@@ -31,6 +31,8 @@ class BDDCommonalityFactor(CommonalityFactor):
 def commonality_factor(bdd_model: BDDModel, config: Configuration) -> float:
     configs_number_op = BDDConfigurationsNumber()
     total_configs = configs_number_op.execute(bdd_model).get_result()
+    if total_configs == 0:
+        return 0.0
     configs_number_op.set_partial_configuration(config)
     n_configs = configs_number_op.execute(bdd_model).get_result()
     return n_configs / total_configs

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/operations/bdd_configurations.py

@@ -35,17 +35,18 @@ def configurations(bdd_model: BDDModel,
                    partial_config: Optional[Configuration] = None) -> list[Configuration]:
     if partial_config is None:
         u_func = bdd_model.root
-        care_vars = set(bdd_model.variables)
+        care_vars = set(bdd_model.variables_features)
         elements = {}
     else:
         values = dict(partial_config.elements.items())
         u_func = bdd_model.bdd.let(values, bdd_model.root)
-        care_vars = set(bdd_model.variables) - set(values.keys())
+        care_vars = set(bdd_model.variables_features) - set(values.keys())
         elements = partial_config.elements
 
     configs = []
     for assignment in bdd_model.bdd.pick_iter(u_func, care_vars=care_vars):
-        features = {f: True for f in assignment.keys() if assignment[f]}
+        features = {bdd_model.variables_features[f]: True 
+                    for f in assignment.keys() if assignment[f]}
         features = features | elements
         configs.append(Configuration(features))
     return configs

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/operations/bdd_configurations_number.py

@@ -35,9 +35,10 @@ def configurations_number(bdd_model: BDDModel,
                           partial_configuration: Optional[Configuration] = None) -> int:
     if partial_configuration is None:
         u_func = bdd_model.root
-        n_vars = len(bdd_model.variables)
+        n_vars = len(bdd_model.variables_features)
     else:
-        values = dict(partial_configuration.elements.items())
+        values = {bdd_model.features_variables[f]: selected 
+                  for f, selected in partial_configuration.elements.items()}
         u_func = bdd_model.bdd.let(values, bdd_model.root)
-        n_vars = len(bdd_model.variables) - len(values)
+        n_vars = len(bdd_model.variables_features) - len(values)
     return int(bdd_model.bdd.count(u_func, nvars=n_vars))

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/operations/bdd_feature_inclusion_probability.py

@@ -42,27 +42,28 @@ def feature_inclusion_probability(bdd_model: BDDModel,
     n_configs_op.set_partial_configuration(config)
     total_configs = n_configs_op.execute(bdd_model).get_result()
     if total_configs == 0:
-        return {feature: 0.0 for feature in bdd_model.variables}
+        return {feature: 0.0 for feature in bdd_model.features_variables}
 
     prob: dict[Any, float] = defaultdict(float)
     if config is None:
-        for feature in bdd_model.variables:
-            values = {feature: True}
+        for variable, feature in bdd_model.variables_features.items():
+            values = {variable: True}
             u_func = bdd_model.bdd.let(values, bdd_model.root)
-            n_vars = len(bdd_model.variables) - len(values)
+            n_vars = len(bdd_model.variables_features) - len(values)
             prob[feature] = bdd_model.bdd.count(u_func, nvars=n_vars) / total_configs
     else:
-        values = dict(config.elements.items())
-        for feature in bdd_model.variables:
-            feature_selected = values.get(feature, None)    
-            values = {feature: True}
+        values = {bdd_model.features_variables[f]: selected 
+                  for f, selected in config.elements.items()}
+        for variable, feature in bdd_model.variables_features.items():
+            feature_selected = values.get(variable, None)    
+            values = {variable: True}
             u_func = bdd_model.bdd.let(values, bdd_model.root)
-            n_vars = len(bdd_model.variables) - len(values)
+            n_vars = len(bdd_model.variables_features) - len(values)
             prob[feature] = bdd_model.bdd.count(u_func, nvars=n_vars) / total_configs
             if feature_selected is None:
-                values.pop(feature)
+                values.pop(variable)
             else:
-                values[feature] = feature_selected
+                values[variable] = feature_selected
     return prob
 
 
@@ -88,7 +89,8 @@ def feature_inclusion_probability(bdd_model: BDDModel,
 #     joint_prob_nodes_phi: dict[tuple[int, Any], float] = defaultdict(float)
 #     cond_prob: dict[tuple[int, Any], float] = defaultdict(float)
 #     mark: dict[int, bool] = defaultdict(bool)
-#     get_joint_pr(bdd_model, root, prob, joint_prob, joint_prob_nodes_n, joint_prob_nodes_phi, cond_prob, mark, bdd_model.negated(root))
+#     get_joint_pr(bdd_model, root, prob, joint_prob, joint_prob_nodes_n, 
+#               joint_prob_nodes_phi, cond_prob, mark, bdd_model.negated(root))
 #     print(f'COND PROBS: {len(cond_prob)}')
 #     for v, p in cond_prob.items():
 #         print(f'Value (id): {v} -> {p}')
@@ -100,8 +102,10 @@ def feature_inclusion_probability(bdd_model: BDDModel,
 #         print(f'Index: {v} -> {p}')
 #     #total_prob = prob[bdd_model.get_value(bdd_model.get_terminal_node_n1())]
 #     #total_prob = prob[bdd_model.get_value(bdd_model.get_terminal_node_n1())]
-#     #total_prob = prob[bdd_model.get_value(bdd_model.get_terminal_node_n1(), bdd_model.negated(root))]
-#     total_prob = prob[bdd_model.get_value(bdd_model.get_terminal_node_n1(), bdd_model.negated(root))]
+#     #total_prob = prob[bdd_model.get_value(bdd_model.get_terminal_node_n1(), 
+#                       bdd_model.negated(root))]
+#     total_prob = prob[bdd_model.get_value(bdd_model.get_terminal_node_n1(), 
+#                       bdd_model.negated(root))]
 #     print(f'Total Prob: {total_prob}')
 #     fip: dict[Any, float] = {}
 #     print(bdd_model.bdd.var_levels)
@@ -131,7 +135,8 @@ def feature_inclusion_probability(bdd_model: BDDModel,
 #         else:
 #             prob[id_low] = prob[id_low] + (prob[id_node] / 2)
 #         if mark[id_node] != mark[id_low]:
-#             get_node_pr(bdd_model, low, prob, mark, complemented ^ bdd_model.negated(low))
+#             get_node_pr(bdd_model, low, prob, mark, 
+#                   complemented ^ bdd_model.negated(low))
 
 #         # explore high
 #         high = bdd_model.get_high_node(node)
@@ -141,7 +146,8 @@ def feature_inclusion_probability(bdd_model: BDDModel,
 #         else:
 #             prob[id_high] = prob[id_high] + (prob[id_node] / 2)
 #         if mark[id_node] != mark[id_high]:
-#             get_node_pr(bdd_model, high, prob, mark, complemented ^ bdd_model.negated(high))
+#             get_node_pr(bdd_model, high, prob, mark,
+#                    complemented ^ bdd_model.negated(high))
 
 
 # def get_joint_pr(bdd_model: BDDModel,
@@ -167,10 +173,15 @@ def feature_inclusion_probability(bdd_model: BDDModel,
 #             cond_prob[(id_node, False)] = 1.0
 #         else:
 #             if mark[id_node] != mark[id_low]:
-#                 get_joint_pr(bdd_model, low, prob, joint_prob, joint_prob_nodes_n, joint_prob_nodes_phi, cond_prob, mark, complemented ^ bdd_model.negated(low))
-#             cond_prob[(id_node, False)] = joint_prob_nodes_phi[(id_low, None)] / (2 * prob[id_low])
-#         joint_prob_nodes_n[(id_node, False)] = cond_prob[(id_node, False)] * prob[id_node]
-        
+#                 get_joint_pr(bdd_model, low, prob, joint_prob, 
+#                       joint_prob_nodes_n, joint_prob_nodes_phi, 
+#                       cond_prob, mark, complemented ^ bdd_model.negated(low))
+#             cond_prob[(id_node, False)] = joint_prob_nodes_phi[
+#                                       (id_low, None)] / 
+#                                        (2 * prob[id_low])
+#         joint_prob_nodes_n[(id_node, False)] = cond_prob[
+#                                       (id_node, False)] * 
+#                                          prob[id_node]
 #         # explore high
 #         high = bdd_model.get_high_node(node)
 #         id_high = bdd_model.get_value(high, complemented)
@@ -180,13 +191,17 @@ def feature_inclusion_probability(bdd_model: BDDModel,
 #             cond_prob[(id_node, True)] = 1.0
 #         else:
 #             if mark[id_node] != mark[id_high]:
-#                 get_joint_pr(bdd_model, high, prob, joint_prob, joint_prob_nodes_n, joint_prob_nodes_phi, cond_prob, mark, complemented ^ bdd_model.negated(high))
-#             cond_prob[(id_node, True)] = joint_prob_nodes_phi[(id_high, None)] / (2 * prob[id_high])
+#                 get_joint_pr(bdd_model, high, prob, joint_prob, joint_prob_nodes_n, 
+# joint_prob_nodes_phi, cond_prob, mark, complemented ^ bdd_model.negated(high))
+#             cond_prob[(id_node, True)] = joint_prob_nodes_phi[(id_high, None)] 
+# / (2 * prob[id_high])
 #         joint_prob_nodes_n[(id_node, True)] = cond_prob[(id_node, True)] * prob[id_node]
 
 #         # Combine both low and high
-#         joint_prob_nodes_phi[(id_node, None)] = joint_prob_nodes_phi[(id_node, True)] + joint_prob_nodes_phi[(id_node, False)]
-#         joint_prob[bdd_model.index(node)] = prob[bdd_model.index(node)] + joint_prob_nodes_n[(id_node, True)]
+#         joint_prob_nodes_phi[(id_node, None)] = joint_prob_nodes_phi[(id_node, True)] + 
+# joint_prob_nodes_phi[(id_node, False)]
+#         joint_prob[bdd_model.index(node)] = prob[bdd_model.index(node)] 
+# + joint_prob_nodes_n[(id_node, True)]
 
 #         # Add joint probabilities of the removed nodes
 #         for xj in range(bdd_model.index(node) + 1, bdd_model.index(high)):

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/operations/bdd_homogeneity.py

@@ -28,8 +28,8 @@ def homogeneity(bdd_model: BDDModel) -> float:
     commonality_sum = 0.0
     commonality_op = BDDCommonalityFactor()
 
-    for feature in bdd_model.variables:
+    for feature in bdd_model.features_variables:
         config = Configuration(elements={feature: True})
         commonality_op.set_configuration(config)
         commonality_sum += commonality_op.execute(bdd_model).get_result()
-    return commonality_sum / len(bdd_model.variables)
+    return commonality_sum / len(bdd_model.variables_features)

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/operations/bdd_metrics.py

@@ -7,7 +7,7 @@ from flamapy.metamodels.bdd_metamodel.models import BDDModel
 from flamapy.metamodels.bdd_metamodel import operations as bdd_operations
 
 
-def metric_method(func: Callable) -> Callable:
+def metric_method(func: Callable[..., Any]) -> Callable[..., Any]:
     """Decorator to mark a method as a metric method.
     It has the value of the measure, it can also have a size and a ratio.
     Example:
@@ -23,8 +23,8 @@ def metric_method(func: Callable) -> Callable:
     return func
 
 
-class BDDMetrics(Metrics):
-
+class BDDMetrics(Metrics): 
+    # pylint: disable=too-many-instance-attributes
     def __init__(self) -> None:
         super().__init__()
         self.model: Optional[VariabilityModel] = None
@@ -46,11 +46,13 @@ class BDDMetrics(Metrics):
         #Do some basic calculations to speedup the rest
         self._features = self.model.variables
         self._configurations_number = bdd_operations.BDDConfigurationsNumber() \
-                                      .execute(self.model).get_result()
+            .execute(self.model) \
+            .get_result()        
         self._prod_dist_op = bdd_operations.BDDProductDistribution()
         self._prod_dist = self._prod_dist_op.execute(self.model).get_result()
         self._fip = bdd_operations.BDDFeatureInclusionProbability() \
-                    .execute(self.model).get_result()
+            .execute(self.model) \
+            .get_result()
         self._variant_features = [feat for feat, prob, in self._fip.items() if 0.0 < prob < 1.0]
         # Get all methods that are marked with the metric_method decorator
         metric_methods = [getattr(self, method_name) for method_name in dir(self)
@@ -94,7 +96,7 @@ class BDDMetrics(Metrics):
                                      result=_dead_features,
                                      size=len(_dead_features),
                                      ratio=self.get_ratio(_dead_features, self._features, 2))
-    
+
     @metric_method
     def pure_optional_features(self) -> dict[str, Any]:
         """Pure optional features are those feature with 0.5 (50%) probability of being selected 
@@ -139,7 +141,7 @@ class BDDMetrics(Metrics):
                                      size=len(_unique_features),
                                      ratio=self.get_ratio(_unique_features, 
                                                           self._features, 2))
-    
+
     @metric_method
     def total_variability(self) -> dict[str, Any]:
         """The total variability of an SPL, considered as a measure of its flexibility, is the 
@@ -165,7 +167,7 @@ class BDDMetrics(Metrics):
         return self.construct_result(name=name,
                                      doc=self.partial_variability.__doc__,
                                      result=_partial_variability)
-    
+
     @metric_method
     def homogeneity(self) -> dict[str, Any]:
         """The homogeneity of an SPL is the commonality mean, i.e., the sum of the commonality 
@@ -177,7 +179,7 @@ class BDDMetrics(Metrics):
         return self.construct_result(name=name,
                                      doc=self.homogeneity.__doc__,
                                      result=_homogeneity)
-    
+
     @metric_method
     def configurations(self) -> dict[str, Any]:
         """Configurations represented by the feature model."""

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/operations/bdd_product_distribution.py

@@ -1,6 +1,6 @@
 import math
 from collections import defaultdict
-from typing import cast, Any
+from typing import cast, Any, Optional
 
 from flamapy.core.models import VariabilityModel
 from flamapy.metamodels.bdd_metamodel.models import BDDModel
@@ -54,7 +54,8 @@ def product_distribution(bdd_model: BDDModel) -> list[int]:
     mark: dict[int, bool] = defaultdict(bool)
     get_prod_dist(bdd_model, root, dist, mark, bdd_model.negated(root))
     # Complete distribution
-    distribution = dist[id_root] + [0] * (len(bdd_model.variables) + 1 - len(dist[id_root]))
+    distribution = dist[id_root] + [0] * \
+        (len(bdd_model.variables_features) + 1 - len(dist[id_root]))
     return distribution
 
 
@@ -94,6 +95,7 @@ def get_prod_dist(bdd_model: BDDModel,
             for j in range(len(dist[id_high])):
                 high_dist[i + j] = high_dist[i + j] + dist[id_high][j] * (
                     math.comb(removed_nodes, i))
+        # combine low and high distributions
         combine_distributions(id_node, dist, low_dist, high_dist)
 
 
@@ -101,7 +103,6 @@ def combine_distributions(id_node: int,
                           dist: dict[int, list[int]], 
                           low_dist: list[int], 
                           high_dist: list[int]) -> None:
-    # combine low and high distributions
     if len(low_dist) > len(high_dist):
         dist_length = len(low_dist)
     else:
@@ -115,7 +116,7 @@ def combine_distributions(id_node: int,
     dist[id_node] = node_dist
 
 
-def descriptive_statistics(prod_dist: list[int]) -> dict[str, Any]:
+def descriptive_statistics(prod_dist: list[int]) -> dict[str, Any]: # noqa: MC0001
     total_elements = sum(prod_dist)
     if total_elements == 0:
         return {
@@ -131,20 +132,19 @@ def descriptive_statistics(prod_dist: list[int]) -> dict[str, Any]:
 
     total_sum = 0
     running_total = 0
-    median1 = None
-    median2 = None
+    median1: Optional[float] = None
+    median2: Optional[float] = None
     median_pos1 = (total_elements + 1) // 2
     median_pos2 = (total_elements + 2) // 2
     min_val = None
     max_val = None
     mode = None
-    mode_count = 0
 
-    sum_squared_diff = 0
-    abs_deviation_total = 0
+    sum_squared_diff = 0.0
+    abs_deviation_total = 0.0
     abs_deviation_running_total = 0
-    mad1 = None
-    mad2 = None
+    mad1: Optional[float] = None
+    mad2: Optional[float] = None
     mad_pos1 = (total_elements + 1) // 2
     mad_pos2 = (total_elements + 2) // 2
 
@@ -157,9 +157,8 @@ def descriptive_statistics(prod_dist: list[int]) -> dict[str, Any]:
             total_sum += i * count
             running_total += count
 
-            if mode is None or count > mode_count:
+            if mode is None:
                 mode = i
-                mode_count = count
 
             if median1 is None and running_total >= median_pos1:
                 median1 = i
@@ -167,7 +166,7 @@ def descriptive_statistics(prod_dist: list[int]) -> dict[str, Any]:
                 median2 = i
 
     mean = total_sum / total_elements
-    median = (median1 + median2) / 2
+    median = (median1 + median2) / 2 if median1 is not None and median2 is not None else 0
 
     running_total = 0
     for i, count in enumerate(prod_dist):
@@ -199,4 +198,4 @@ def descriptive_statistics(prod_dist: list[int]) -> dict[str, Any]:
         'Max': max_val,
         'Range': max_val - min_val if min_val is not None and max_val is not None else 0
     }
-    return statistics
+    return statistics

{flamapy-bdd-2.0.0.dev1 → flamapy-bdd-2.0.0.dev7}/flamapy/metamodels/bdd_metamodel/operations/bdd_sampling.py

@@ -75,19 +75,23 @@ def sample(model: BDDModel,
 def random_configuration(bdd_model: BDDModel,
                          p_config: Optional[Configuration] = None) -> Configuration:
     # Initialize the configurations and values for BDD nodes with already known features
-    values = {} if p_config is None else dict(p_config.elements.items())
+    if p_config is None:
+        values = {}
+    else:
+        values = {bdd_model.features_variables[f]: selected 
+                  for f, selected in p_config.elements.items()}
 
     # Set the BDD nodes with the already known features values
     u_func = bdd_model.bdd.let(values, bdd_model.root)
 
-    care_vars = set(bdd_model.variables) - values.keys()
+    care_vars = set(bdd_model.variables_features.keys()) - values.keys()
     n_vars = len(care_vars)
-    for feature in care_vars:
+    for variable in care_vars:
         # Number of configurations with the feature selected
-        v_sel = bdd_model.bdd.let({feature: True}, u_func)
+        v_sel = bdd_model.bdd.let({variable: True}, u_func)
         nof_configs_var_selected = bdd_model.bdd.count(v_sel, nvars=n_vars - 1)
         # Number of configurations with the feature unselected
-        v_unsel = bdd_model.bdd.let({feature: False}, u_func)
+        v_unsel = bdd_model.bdd.let({variable: False}, u_func)
         nof_configs_var_unselected = bdd_model.bdd.count(v_unsel, nvars=n_vars - 1)
 
         # Randomly select or not the feature
@@ -96,8 +100,9 @@ def random_configuration(bdd_model: BDDModel,
                                   k=1)[0]
 
         # Update configuration and BDD node for the new feature
-        values[feature] = selected
-        u_func = bdd_model.bdd.let({feature: selected}, u_func)
+        values[variable] = selected
+        u_func = bdd_model.bdd.let({variable: selected}, u_func)
 
         n_vars -= 1
-    return Configuration(values)
+    return Configuration({bdd_model.variables_features[v]: selected 
+                          for v, selected in values.items()})