fmdtools 2.5.2__tar.gz → 2.5.4__tar.gz

{fmdtools-2.5.2 → fmdtools-2.5.4}/LICENSE

@@ -1,4 +1,4 @@
-fmdtools version 2.5.2
+fmdtools version 2.5.4
 ---------------------------
                                  Apache License
                            Version 2.0, January 2004

{fmdtools-2.5.2/fmdtools.egg-info → fmdtools-2.5.4}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fmdtools
-Version: 2.5.2
+Version: 2.5.4
 Summary: System resilience modelling, simulation, and assessment in Python
 Author: fmdtools Developers
 Maintainer-email: Daniel Hulse <daniel.e.hulse@nasa.gov>
-License: fmdtools version 2.5.2
+License: fmdtools version 2.5.4
         ---------------------------
                                          Apache License
                                    Version 2.0, January 2004
@@ -394,7 +394,7 @@ More guidance on development installations is provided in [How to Contribute](ht
 Note that this version reflects the latest version on the ``main`` git branch along with any local changes. To use a particular version of ``fmdtools`` in the context of a development install you can checkout the tag corresponding to the version you want, e.g.:
 
 ```
-   git checkout v2.5.2
+   git checkout v2.5.4
 ```
 
 
@@ -548,8 +548,8 @@ To cite a particular version of the fmdtools, you may use:
   author = {{NASA}},
   title = {fmdtools},
   url = {https://github.com/nasa/fmdtools},
-  version = {2.5.2},
-  date = {2026-9-28},
+  version = {2.5.4},
+  date = {2026-10-5},
 }
 ```
 

{fmdtools-2.5.2 → fmdtools-2.5.4}/README.md

@@ -123,7 +123,7 @@ More guidance on development installations is provided in [How to Contribute](ht
 Note that this version reflects the latest version on the ``main`` git branch along with any local changes. To use a particular version of ``fmdtools`` in the context of a development install you can checkout the tag corresponding to the version you want, e.g.:
 
 ```
-   git checkout v2.5.2
+   git checkout v2.5.4
 ```
 
 
@@ -277,8 +277,8 @@ To cite a particular version of the fmdtools, you may use:
   author = {{NASA}},
   title = {fmdtools},
   url = {https://github.com/nasa/fmdtools},
-  version = {2.5.2},
-  date = {2026-9-28},
+  version = {2.5.4},
+  date = {2026-10-5},
 }
 ```
 

{fmdtools-2.5.2 → fmdtools-2.5.4}/examples/airspacelib/base/state.py

@@ -41,19 +41,26 @@ class AircraftPosition(State):
     dy: float = 0.0
     dims = ('x', 'y')
 
-    def get_goal(self):
+    def get_dims(self, *dims):
+        """Get the dimensions to calculate over. Default is self.dims."""
+        if not dims:
+            return self.dims
+        else:
+            return dims
+
+    def get_goal(self, *dims):
         """Get the goal attributes (goal_x, goal_y) of the AircraftPosition."""
-        return self.get(*['goal_'+d for d in self.dims])
+        return self.get(*['goal_'+d for d in self.get_dims(*dims)])
 
-    def get_loc(self):
+    def get_loc(self, *dims):
         """Get the location (x, y) attributes of the AircraftPosition."""
-        return self.get(*self.dims)
+        return self.get(*self.get_dims(*dims))
 
-    def get_vel(self):
+    def get_vel(self, *dims):
         """Get the velocity attributes (dx, dy) of the AircraftPosition."""
-        return self.get(*['d'+d for d in self.dims])
+        return self.get(*['d'+d for d in self.get_dims(*dims)])
 
-    def find_direction(self):
+    def find_direction(self, *dims):
         """
         Find the (unit vector) direction from the x,y to goal_x, goal_y.
 
@@ -71,22 +78,22 @@ class AircraftPosition(State):
         >>> ap.find_direction()
         array([0., 1.])
         """
-        dist = self.calc_dist()
+        dist = self.calc_dist(*dims)
         if dist > 0.0:
             return self.calc_vector_dist()/self.calc_dist()
         else:
             return np.zeros(len(self.dims))
 
-    def calc_vector_dist(self):
+    def calc_vector_dist(self, *dims):
         """Calculate the vector distance from x,y to goal_x, goal_y."""
-        return self.get_goal() - self.get_loc()
+        return self.get_goal(*dims) - self.get_loc(*dims)
 
-    def calc_dist(self):
+    def calc_dist(self, *dims):
         """Calculate the scalar distance from x,y to goal_x, goal_y."""
-        vector_dist = self.calc_vector_dist()
+        vector_dist = self.calc_vector_dist(*dims)
         return np.sqrt(sum(vector_dist**2))
 
-    def at_goal(self):
+    def at_goal(self, *dims):
         """
         Determine if the aircraft is at its goal location.
 
@@ -99,17 +106,17 @@ class AircraftPosition(State):
         >>> ap.at_goal()
         True
         """
-        return all(self.get_goal() == self.get_loc())
+        return all(self.get_goal(*dims) == self.get_loc(*dims))
 
-    def in_range(self, dist_range=10.0):
+    def in_range(self, *dims, dist_range=10.0):
         """Determine if the aircraft is in the range of its goal location."""
-        return self.calc_dist() <= dist_range
+        return self.calc_dist(*dims) <= dist_range
 
-    def calc_dist_to_travel(self, dist_range=10.0):
+    def calc_dist_to_travel(self, *dims, dist_range=10.0):
         """Determine the distance to the goal location (under max dist dist_range)."""
-        return np.min([dist_range, self.calc_dist()])
+        return np.min([dist_range, self.calc_dist(*dims)])
 
-    def update_dist_to_travel(self, maxvel=10.0):
+    def update_dist_to_travel(self, *dims, maxvel=10.0):
         """
         Update dx, dy to reflect goal location (travelling at max velocity).
 
@@ -128,14 +135,14 @@ class AircraftPosition(State):
         >>> ap
         AircraftPosition(x=0.0, goal_x=10.0, dx=10.0, y=0.0, goal_y=0.0, dy=0.0)
         """
-        if self.in_range(dist_range=maxvel):
-            vel = self.calc_dist()
+        if self.in_range(*dims, dist_range=maxvel):
+            vel = self.calc_dist(*dims)
         else:
             vel = maxvel
-        vels = vel * self.find_direction()
-        self.put(**{'d'+dim: vels[i] for i, dim in enumerate(self.dims)})
+        vels = vel * self.find_direction(*dims)
+        self.put(**{'d'+dim: vels[i] for i, dim in enumerate(self.get_dims(*dims))})
 
-    def update_position(self, maxvel=10.0):
+    def update_position(self, *dims, maxvel=10.0):
         """
         Update x, y to reflect progress towards the goal location at maxvel.
 
@@ -157,12 +164,12 @@ class AircraftPosition(State):
         >>> ap
         AircraftPosition(x=10.0, goal_x=10.0, dx=0.0, y=10.0, goal_y=10.0, dy=0.0)
         """
-        self.update_dist_to_travel(maxvel=maxvel)
-        self.increment_position()
+        self.update_dist_to_travel(*dims, maxvel=maxvel)
+        self.increment_position(*dims)
 
-    def increment_position(self):
+    def increment_position(self, *dims):
         """Increment position (x,y) by (dx, dy)."""
-        self.inc(**{dim: getattr(self, 'd'+dim) for dim in self.dims})
+        self.inc(**{dim: getattr(self, 'd'+dim) for dim in self.get_dims(*dims)})
 
 
 class AircraftPosition3(AircraftPosition):

{fmdtools-2.5.2 → fmdtools-2.5.4}/examples/airspacelib/contingency_management/model_aircraft.py

@@ -148,9 +148,9 @@ class ContingencyControlFlight(ControlFlight):
         """Set new landing location in depletion scenario."""
         ts = self.trajectories.s.copy()
         ts.assign(self.environment.c.start, "goal_x", "goal_y")
-        dist_to_start = ts.calc_dist_to_travel(1000)
+        dist_to_start = ts.calc_dist_to_travel(dist_range=1000)
         ts.assign(self.environment.c.end, "goal_x", "goal_y")
-        dist_to_end = ts.calc_dist_to_travel(1000)
+        dist_to_end = ts.calc_dist_to_travel(dist_range=1000)
         if dist_to_end < self.electricity.s.charge:
             self.s.endpt = self.environment.c.end
         elif dist_to_start < self.electricity.s.charge:

{fmdtools-2.5.2 → fmdtools-2.5.4}/examples/airspacelib/contingency_management/model_environment.py

@@ -165,7 +165,7 @@ class Threat(GeomPoint):
 
     def update_position(self):
         """Update position given known speed."""
-        self.s.update_position(self.s.buffer_speed)
+        self.s.update_position(maxvel=self.s.buffer_speed)
 
     def get_shapely_args(self):
         return (self.s.x, self.s.y)

{fmdtools-2.5.2 → fmdtools-2.5.4}/examples/multirotor_drone/model_urban.py

@@ -322,6 +322,7 @@ class Drone(DroneRural):
                               ('taxi', 12, 20)),
                       end_time=30,
                       units='min',
+                      use_local=False,
                       dt=0.1)
 
     def init_architecture(self, **kwargs):
@@ -499,6 +500,9 @@ if __name__ == "__main__":
     # UrbanDroneEnvironment("a")
     # PlanPath._init_environment("a")
     # p = PlanPath("test", {})
+    mdl = Drone(sp={'end_condition': 'scenario_finished', 'dt': 0.1}, t={'local_dt': 0.1})
+    results_fault, hist_fault = propagate.one_fault(mdl, "affect_dof.ca.comps.lr", "mechbreak", time=1.4)
+    fig, ax = plot_env_with_traj_z(hist_fault, mdl, title = "Urban Drone Trajectory")
 
     e = UrbanDroneEnvironment("env")
     e.c.show({"height": {}})

{fmdtools-2.5.2 → fmdtools-2.5.4}/examples/water_pump/test_pump_stochastic.py

@@ -48,7 +48,7 @@ class StochasticPumpTests(unittest.TestCase, CommonTests):
                     49.32124529702974,
                     0.31327201999190035,
                     21.386958080811567,
-                    3.3311929677576186,
+                    3.331196298953918,
                     9.066120598345039,
                     131.79987407014573,
                     5.81402243889764,
@@ -277,7 +277,7 @@ class StochasticPumpTests(unittest.TestCase, CommonTests):
 
 if __name__ == '__main__':
     # suite = unittest.TestSuite()
-    # suite.addTest(StochasticPumpTests("test_model_copy_same"))
+    # suite.addTest(StochasticPumpTests("test_stochastic_pdf"))
     # suite.addTest(StochasticPumpTests("test_save_load_nominalapproach_indiv"))
     # runner = unittest.TextTestRunner()
     # runner.run(suite)

{fmdtools-2.5.2 → fmdtools-2.5.4/fmdtools.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fmdtools
-Version: 2.5.2
+Version: 2.5.4
 Summary: System resilience modelling, simulation, and assessment in Python
 Author: fmdtools Developers
 Maintainer-email: Daniel Hulse <daniel.e.hulse@nasa.gov>
-License: fmdtools version 2.5.2
+License: fmdtools version 2.5.4
         ---------------------------
                                          Apache License
                                    Version 2.0, January 2004
@@ -394,7 +394,7 @@ More guidance on development installations is provided in [How to Contribute](ht
 Note that this version reflects the latest version on the ``main`` git branch along with any local changes. To use a particular version of ``fmdtools`` in the context of a development install you can checkout the tag corresponding to the version you want, e.g.:
 
 ```
-   git checkout v2.5.2
+   git checkout v2.5.4
 ```
 
 
@@ -548,8 +548,8 @@ To cite a particular version of the fmdtools, you may use:
   author = {{NASA}},
   title = {fmdtools},
   url = {https://github.com/nasa/fmdtools},
-  version = {2.5.2},
-  date = {2026-9-28},
+  version = {2.5.4},
+  date = {2026-10-5},
 }
 ```
 

{fmdtools-2.5.2 → fmdtools-2.5.4}/fmdtools.egg-info/SOURCES.txt

@@ -127,31 +127,112 @@ src/fmdtools/sim/scenario.py
 src/fmdtools/sim/search.py
 tests/__init__.py
 tests/common.py
+tests/test_appended_history_snapshots.py
+tests/test_approach_joint_domains.py
+tests/test_approach_model_timestep.py
+tests/test_approach_phase_map_ownership.py
+tests/test_array_differences.py
 tests/test_array_random_states.py
+tests/test_array_result_equality.py
+tests/test_array_state_limits.py
+tests/test_bootstrap_statistic_arguments.py
+tests/test_bounded_array_increments.py
 tests/test_calc_metric_ci_constant_outputs.py
+tests/test_callable_parameter_domains.py
+tests/test_choice_draw_mass.py
+tests/test_choice_probability_precision.py
+tests/test_common.py
 tests/test_comparison_groups.py
 tests/test_confidence_history_clipping.py
+tests/test_coordinate_cell_boundaries.py
+tests/test_default_fault_sample_timestep.py
+tests/test_degradation_path_boundaries.py
+tests/test_dirichlet_batches.py
+tests/test_disconnected_graph_robustness.py
+tests/test_discrete_sample_sizes.py
 tests/test_error_history_plots.py
+tests/test_exact_nominal_expectation.py
+tests/test_explicit_result_file_formats.py
+tests/test_exponential_rayleigh_draw_sizes.py
+tests/test_factor_sort_priority.py
+tests/test_fault_history_paths.py
 tests/test_fault_sample_without_nominal.py
 tests/test_fault_time_without_traces.py
+tests/test_fault_weight_arrays.py
+tests/test_faulty_scenario_selection.py
+tests/test_fmea_input_ownership.py
+tests/test_gamma_sampling_density.py
+tests/test_generated_history_phase_timestep.py
 tests/test_geom.py
 tests/test_graph.py
+tests/test_graph_edge_comparison.py
 tests/test_hierarchical.py
+tests/test_history_phase_identifiers.py
 tests/test_history_standard_deviation.py
+tests/test_independent_single_replicate_seeds.py
+tests/test_individual_result_paths.py
+tests/test_integer_draw_mass.py
+tests/test_join_phase_timestep.py
 tests/test_join_phasemaps.py
+tests/test_joint_fault_metadata_order.py
+tests/test_joint_fault_phase_map.py
 tests/test_joint_fault_weights.py
+tests/test_json_result_arrays.py
+tests/test_location_scale_draw_sizes.py
+tests/test_lognormal_defaults.py
+tests/test_metric_weight_alignment.py
+tests/test_mixed_shape_degradation.py
+tests/test_multidimensional_state_comparison.py
+tests/test_multinomial_sampling_arguments.py
+tests/test_multivariate_hypergeometric_options.py
+tests/test_multivariate_normal_arguments.py
+tests/test_named_default_restoration.py
+tests/test_named_metric_rounding.py
+tests/test_nearest_point_exclusion.py
+tests/test_nested_history_summary.py
 tests/test_nested_nominal_groups.py
+tests/test_nested_parameter_constraints.py
+tests/test_nested_scenario_parameters.py
 tests/test_nesting_custom_separators.py
+tests/test_not_equal_constraints.py
+tests/test_object_history_copy.py
 tests/test_packages.py
+tests/test_parameter_grid_bounds.py
+tests/test_parameter_sample_defaults.py
 tests/test_parameter_sample_seeds.py
 tests/test_parameter_subsampling_types.py
+tests/test_pareto_density.py
 tests/test_pathplan.py
+tests/test_permutation_axis_probabilities.py
+tests/test_permuted_slice_probabilities.py
+tests/test_phase_map_default_isolation.py
 tests/test_phase_timestep.py
 tests/test_pruned_fault_times.py
+tests/test_ragged_confidence_histories.py
+tests/test_rand.py
+tests/test_random_combination_types.py
 tests/test_result.py
+tests/test_result_constructor_input.py
+tests/test_result_folder_selection.py
 tests/test_sample.py
 tests/test_scenario.py
 tests/test_scenario_defaults.py
+tests/test_shape_distribution_sizes.py
+tests/test_simple_problem_vector_inputs.py
+tests/test_simulation_exposure.py
+tests/test_standard_draw_arguments.py
+tests/test_standard_t_density.py
+tests/test_string_state_histories.py
 tests/test_table_factor_indices.py
 tests/test_time.py
-tests/test_uniform_density.py
+tests/test_time_reset.py
+tests/test_triangular_arraylike_parameters.py
+tests/test_tuple_table_factors.py
+tests/test_uniform_density.py
+tests/test_unit_random_density.py
+tests/test_vonmises_density.py
+tests/test_wald_density.py
+tests/test_weighted_percent_metrics.py
+tests/test_zero_fault_start_times.py
+tests/test_zero_time_objectives.py
+tests/test_zero_timer_increment.py

{fmdtools-2.5.2 → fmdtools-2.5.4}/pyproject.toml

@@ -18,7 +18,7 @@ classifiers = [
 description = "System resilience modelling, simulation, and assessment in Python"
 license = {file="LICENSE"}
 name = "fmdtools"
-version="2.5.2"
+version="2.5.4"
 readme = "README.md"
 requires-python = ">=3.12"
 

{fmdtools-2.5.2 → fmdtools-2.5.4}/src/fmdtools/__init__.py

@@ -22,6 +22,6 @@ import fmdtools.sim as sim
 import fmdtools.analyze as analyze
 
 __all__ = ['analyze', 'sim', 'define']
-__version__ = '2.5.2'
+__version__ = '2.5.4'
 __copyright__ = "Copyright 2024 United States Government"
 __license__ = "Apache-2.0"

{fmdtools-2.5.2 → fmdtools-2.5.4}/src/fmdtools/analyze/common.py

@@ -35,6 +35,7 @@ under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 CONDITIONS OF ANY KIND, either express or implied. See the License for the
 specific language governing permissions and limitations under the License.
 """
+import math
 import numpy as np
 import os
 import matplotlib.pyplot as plt
@@ -42,6 +43,7 @@ from matplotlib import rcParams
 import inspect
 from scipy.stats import bootstrap
 from fmdtools.define.base import filter_kwargs, round_float
+from functools import partial
 
 
 plt.rcParams['pdf.fonttype'] = 42
@@ -180,11 +182,11 @@ def create_indiv_filename(filename, indiv_id, splitchar='_'):
     --------
     >>> create_indiv_filename("hi.csv", "4")
     'hi_4.csv'
+    >>> create_indiv_filename("runs.v1/results.v2.csv", "4", splitchar="/")
+    'runs.v1/results.v2/4.csv'
     """
-    filename_parts = filename.split(".")
-    filename_parts.insert(1, '.')
-    filename_parts.insert(1, splitchar+indiv_id)
-    return "".join(filename_parts)
+    stem, extension = os.path.splitext(filename)
+    return stem + splitchar + indiv_id + extension
 
 
 def load_folder(folder, filetype):
@@ -198,20 +200,17 @@ def load_folder(folder, filetype):
     folder : str
         Name of the folder. Must be in the current directory
     filetype : str
-        Type of files in the folder ('pickle', 'csv', or 'json')
+        Type of files in the folder ('npz', 'csv', or 'json'). Other extensions
+        and subdirectories are ignored; matching files are not searched recursively.
 
     Returns
     -------
     files_to_read : list
         files to load for results/mdlhists.
     """
-    files = os.listdir(folder)
-    files_toread = []
-    for file in files:
-        read_filetype = auto_filetype(file)
-        if read_filetype == filetype:
-            files_toread.append(file)
-    return files_toread
+    return [file for file in os.listdir(folder)
+            if file.endswith('.' + filetype)
+            and os.path.isfile(os.path.join(folder, file))]
 
 
 def metric_preamble(data, dtype=None, rates=None, r_dtype=None, r_norm=False):
@@ -255,7 +254,8 @@ def calc_metric(data, method=np.average, args=(), axis=None, dtype=None,
     r_norm : bool, optional
         Whether to normalize rates. The default is False.
     round_value : bool, optional
-        Whether to round the value. Default is True.
+        Whether to round the final value, including named metrics.
+        Applied once after evaluation. Default is True.
     res : float
         Resolution to round to. Default is 1e-6.
     min_r : int
@@ -283,8 +283,9 @@ def calc_metric(data, method=np.average, args=(), axis=None, dtype=None,
     """
     if isinstance(method, str):
         method = eval("calc_"+method)
+        # Named helpers call calc_metric again; round only the final result.
         metric = method(data, args=args, axis=axis, dtype=dtype, rates=rates,
-                      r_dtype=r_dtype, r_norm=r_norm, **kwargs)
+                      r_dtype=r_dtype, r_norm=r_norm, round_value=False, **kwargs)
     else:
         vals = metric_preamble(data, dtype, rates, r_dtype, r_norm)
         metric = method(vals, *args, **filter_kwargs(method, **kwargs, axis=axis))
@@ -309,7 +310,8 @@ def calc_metric_ci(data, method=np.average, return_anyway=False, interval=None,
     axis : int
         Axis along which to calculate the confidence interval(s). The default is 0.
     **kwargs : kwargs
-        Keyword arguments to calc_metric or scipy.bootstrap.
+        Keyword arguments to the statistic, preprocessing, or scipy.bootstrap.
+        Statistic arguments are used for both the point estimate and resamples.
 
     Returns
     -------
@@ -339,15 +341,16 @@ def calc_metric_ci(data, method=np.average, return_anyway=False, interval=None,
     val = np.take(vals, [0], axis=axis)
     if "weights" in kwargs and kwargs['weights'] is not None:
         raise Exception("Weights not able to be used w- bootstrap--use rates instead.")
-    met_val = method(vals, axis=axis, **filter_kwargs(method, **kwargs))
+    statistic = partial(method, **filter_kwargs(method, **kwargs))
+    met_val = statistic(vals, axis=axis)
     vals_vary = vals == val
     # Preserve the existing policy for globally identical data.
     if not np.all(vals == vals.flat[0]):
         if np.any(np.all(vals_vary, axis=axis)):
             # use more robust/basic algorithm if some indices don't vary
-            bs = bootstrap([vals], method, axis=axis, method="basic", **bs_kwar)
+            bs = bootstrap([vals], statistic, axis=axis, method="basic", **bs_kwar)
         else:
-            bs = bootstrap([vals], method, axis=axis, **bs_kwar)
+            bs = bootstrap([vals], statistic, axis=axis, **bs_kwar)
         return met_val, bs.confidence_interval.low, bs.confidence_interval.high
     elif return_anyway:
         return met_val, met_val, met_val
@@ -355,10 +358,26 @@ def calc_metric_ci(data, method=np.average, return_anyway=False, interval=None,
         raise Exception("All data are the same!")
 
 
+def _uniform_rate(data, axis=None):
+    """Assign uniform mass over reduced axes, preserving unreduced dimensions."""
+    shape = np.shape(data)
+    if axis is None:
+        count = np.size(data)
+    elif not shape:
+        count = 1  # NumPy's subsequent reduction validates scalar axes.
+    else:
+        axes = axis if isinstance(axis, tuple) else (axis,)
+        count = math.prod(shape[a] for a in axes)
+    return 1 / count
+
+
 def calc_rate(data, rates=None, weights=None, **kwargs):
     """
     Calculate a rate of a non-zero value in data using calc_metric.
 
+    With no explicit rates, use equal probability over the selected axis/axes.
+    Other dimensions, such as history time, do not dilute each reduced rate.
+
     Examples
     --------
     >>> calc_rate([0, 10, 0]) # defaults to equal rate
@@ -367,21 +386,24 @@ def calc_rate(data, rates=None, weights=None, **kwargs):
     np.float64(0.2)
     """
     if rates is None:
-        rates = 1/np.size(data)
+        rates = _uniform_rate(data, kwargs.get('axis'))
     kwar = {**kwargs, 'method': np.sum, 'dtype': bool, 'rates': rates}
     return calc_metric(data, **kwar)
 
 
 def calc_percent(data, weights=None, rates=None, **kwargs):
     """
-    Calculate a percent of a non-zero value in data using calc_metric.
+    Calculate a weighted fraction of non-zero values using calc_metric.
+
+    Weights are passed to the averaging method; omitted weights give each value
+    equal influence. Rates remain separate from percentage weights.
 
     Examples
     --------
     >>> calc_percent([0, 10, 0])
     np.float64(0.333333)
     """
-    return calc_metric(data, **{**kwargs, 'dtype': bool})
+    return calc_metric(data, **{**kwargs, 'dtype': bool, 'weights': weights})
 
 
 def calc_total(data, weights=None, **kwargs):
@@ -402,6 +424,9 @@ def calc_expected(data, rates=None, weights=None, **kwargs):
     """
     Calculate the expected value of given data using calc_metric.
 
+    With no explicit rates, use equal probability over the selected axis/axes.
+    Explicit rates retain their existing weighted-sum interpretation.
+
     Examples
     --------
     >>> calc_expected([0, 5, 10]) # defaults to average
@@ -410,7 +435,7 @@ def calc_expected(data, rates=None, weights=None, **kwargs):
     np.float64(3.5)
     """
     if rates is None:
-        rates = 1/np.size(data)
+        rates = _uniform_rate(data, kwargs.get('axis'))
     return calc_metric(data, **{**kwargs, 'method': np.sum, 'rates': rates})
 
 

{fmdtools-2.5.2 → fmdtools-2.5.4}/src/fmdtools/analyze/graph/base.py

@@ -841,6 +841,9 @@ class Graph(object):
         """
         Compute robustness coefficient of graph representation of model mdl.
 
+        Each trial removes nodes from the entire graph, including disconnected
+        components, to integrate the complete largest-component curve.
+
         Parameters
         ----------
         trials : int
@@ -865,9 +868,9 @@ class Graph(object):
             N = float(len(tmp))
             largestCC = max(nx.connected_components(tmp), key=len)
             s = [float(len(largestCC))]
-            rs = rng.choice(range(int(s[0])), int(s[0]), replace=False)
+            rs = rng.choice(range(int(N)), int(N), replace=False)
             nodes = list(g)
-            for i in range(int(s[0])-1):
+            for i in range(int(N)-1):
                 tmp.remove_node(nodes[rs[i]])
                 largestCC = max(nx.connected_components(tmp), key=len)
                 s.append(float(len(largestCC)))
@@ -1228,6 +1231,9 @@ class Graph(object):
         Useful for comparing different model variants, design alternatives, or
         tracking how model structure evolves across versions.
 
+        When both graphs are undirected, edge endpoint order is ignored.
+        Added and removed edges retain the endpoint tuples from their source graph.
+
         Parameters
         ----------
         other_graph : Graph
@@ -1267,6 +1273,10 @@ class Graph(object):
         nodes_other = set(other_graph.g.nodes())
         edges_this = set(self.g.edges())
         edges_other = set(other_graph.g.edges())
+        if not (self.g.is_directed() or other_graph.g.is_directed()):
+            # Give shared undirected edges the same orientation for comparison.
+            edges_other = {edge[::-1] if edge[::-1] in edges_this else edge
+                           for edge in edges_other}
 
         nodes_added = nodes_other - nodes_this
         nodes_removed = nodes_this - nodes_other