doku

1 files changed, 26 insertions, 14 deletions

diff --git a/lib/dfatool.py b/lib/dfatool.py
index ac0885b..17a5d43 100755
--- a/lib/dfatool.py
+++ b/lib/dfatool.py
@@ -472,7 +472,7 @@ class ParamStats:
         influencer_parameters = self._reduce_param_matrix(dep_by_value, other_param_list)
         return influencer_parameters
 
-    def _param_independence_ratio(self, state_or_trans, attribute, param):
+    def _param_independence_ratio(self, state_or_trans: str, attribute: str, param: str) -> float:
         """
         Return the heuristic ratio of parameter independence for state_or_trans, attribute, and param.
 
@@ -488,20 +488,37 @@ class ParamStats:
             # This means that the variation of param does not affect the model quality -> no influence, return 1
             return 1.
 
-        influencer_parameters = self._get_codependent_parameters(statistics, param)
-        if len(influencer_parameters):
-            print('{}/{} {} <-> {}'.format(state_or_trans, attribute, param, influencer_parameters))
-
         return statistics['std_param_lut'] / statistics['std_by_param'][param]
 
-    def param_dependence_ratio(self, state_or_trans, attribute, param):
+    def param_dependence_ratio(self, state_or_trans: str, attribute: str, param: str) -> float:
         """
         Return the heuristic ratio of parameter dependence for state_or_trans, attribute, and param.
 
         A value close to 0 means no influence, a value close to 1 means high probability of influence.
+
+        :param state_or_trans: state or transition name
+        :param attribute: model attribute
+        :param param: parameter name
+
+        :returns: parameter dependence (float between 0 == no influence and 1 == high probability of influence)
         """
         return 1 - self._param_independence_ratio(state_or_trans, attribute, param)
 
+    def reverse_dependent_parameters(self, state_or_trans: str, attribute: str, param: str) -> list:
+        """
+        Return parameters whose value influences whether `attribute` of `state_or_trans` depends on `param` or not.
+
+        For example, a radio's TX POWER is only influenced by the packet length if dynamically sized payloads are enabled.
+        So reverse_dependent_parameters('TX', 'POWER', 'packet_length') == ['dynamic_payload_size'].
+
+        :param state_or_trans: state or transition name
+        :param attribute: model attribute
+        :param param: parameter name
+
+        :returns: list of parameters
+        """
+        return self._get_codependent_parameters(self.stats[state_or_trans][attribute], param)
+
     def _arg_independence_ratio(self, state_or_trans, attribute, arg_index):
         statistics = self.stats[state_or_trans][attribute]
         if self.use_corrcoef:
@@ -514,7 +531,7 @@ class ParamStats:
             return 1
         return statistics['std_param_lut'] / statistics['std_by_arg'][arg_index]
 
-    def arg_dependence_ratio(self, state_or_trans, attribute, arg_index):
+    def arg_dependence_ratio(self, state_or_trans: str, attribute: str, arg_index: int) -> float:
         return 1 - self._arg_independence_ratio(state_or_trans, attribute, arg_index)
 
     # This heuristic is very similar to the "function is not much better than
@@ -1570,14 +1587,14 @@ def _add_trace_data_to_aggregate(aggregate, key, element):
 
 def filter_aggregate_by_param(aggregate, parameters, parameter_filter):
     """
-    Remove entries with certain parameter values from `aggregate`.
+    Remove entries which do not have certain parameter values from `aggregate`.
 
     :param aggregate: aggregated measurement data, must be a dict conforming to
         aggregate[state or transition name]['param'] = (first parameter value, second parameter value, ...)
         and
         aggregate[state or transition name]['attributes'] = [list of keys with measurement data, e.g. 'power' or 'duration']
     :param parameters: list of parameters, used to map parameter index to parameter name. parameters=['foo', ...] means 'foo' is the first parameter
-    :param parameter_filter: [[name, value], [name, value], ...] list of parameter values to remove. Values refer to normalizad parameter data.
+    :param parameter_filter: [[name, value], [name, value], ...] list of parameter values to keep, all others are removed. Values refer to normalizad parameter data.
     """
     for param_name_and_value in parameter_filter:
         param_index = parameters.index(param_name_and_value[0])
@@ -1741,11 +1758,6 @@ class PTAModel:
         self.ignore_trace_indexes = ignore_trace_indexes
         self._aggregate_to_ndarray(self.by_name)
 
-    def distinct_param_values(self, state_or_tran, param_index = None, arg_index = None):
-        if param_index != None:
-            param_values = map(lambda x: x[param_index], self.by_name[state_or_tran]['param'])
-        return sorted(set(param_values))
-
     def _aggregate_to_ndarray(self, aggregate):
         for elem in aggregate.values():
             for key in elem['attributes']: