westpa 2022.10__cp312-cp312-macosx_11_0_arm64.whl

westpa/oldtools/cmds/w_ttimes.py

@@ -0,0 +1,358 @@
+import argparse
+import logging
+
+import numpy as np
+
+import westpa
+
+from oldtools.aframe import (
+    WESTAnalysisTool,
+    BinningMixin,
+    WESTDataReaderMixin,
+    IterRangeMixin,
+    MCBSMixin,
+    TransitionAnalysisMixin,
+    KineticsAnalysisMixin,
+    CommonOutputMixin,
+    BFDataManager,
+    BFTransitionAnalysisMixin,
+)
+
+log = logging.getLogger('w_ttimes')
+
+
+ciinfo_dtype = np.dtype([('expectation', np.float64), ('ci_lower', np.float64), ('ci_upper', np.float64)])
+
+
+class WTTimesBase:
+    def __init__(self):
+        super().__init__()
+
+        self.ed_stats_filename = None
+        self.fpt_stats_filename = None
+        self.flux_stats_filename = None
+        self.rate_stats_filename = None
+        self.suppress_headers = None
+        self.print_bin_labels = None
+
+        self.ttimes_group = None
+
+        self.durations = None
+        self.fpts = None
+        self.fluxes = None
+        self.rates = None
+
+    def add_args(self, parser, upcall=True):
+        '''Add arguments to a parser common to all analyses of this type.'''
+        if upcall:
+            try:
+                upfunc = super().add_args
+            except AttributeError:
+                pass
+            else:
+                upfunc(parser)
+
+        output_options = parser.add_argument_group('kinetics analysis output options')
+        output_options.add_argument(
+            '--edstats',
+            dest='ed_stats',
+            default='edstats.txt',
+            help='Store event duration statistics in ED_STATS (default: edstats.txt)',
+        )
+        if self.bf_mode:
+            output_options.add_argument(
+                '--fptstats',
+                dest='fpt_stats',
+                default='fptstats.txt',
+                help='Store first passage time statistics in FPT_STATS (default: fptstats.txt).',
+            )
+        else:
+            output_options.add_argument(
+                '--fptstats', dest='fpt_stats', help='Store first passage time statistics in FPT_STATS (default: do not store).'
+            )
+        output_options.add_argument(
+            '--fluxstats',
+            dest='flux_stats',
+            default='fluxstats.txt',
+            help='Store flux statistics in FLUX_STATS (default: fluxstats.txt)',
+        )
+        output_options.add_argument(
+            '--ratestats',
+            dest='rate_stats',
+            default='ratestats.txt',
+            help='Store rate statistics in RATE_STATS (default: ratestats.txt)',
+        )
+        self.add_common_output_args(output_options)
+
+    def process_args(self, args, upcall=True):
+        self.ed_stats_filename = args.ed_stats
+        self.fpt_stats_filename = args.fpt_stats
+        self.flux_stats_filename = args.flux_stats
+        self.rate_stats_filename = args.rate_stats
+        self.process_common_output_args(args)
+        self.calc_fpts = bool(args.fpt_stats)
+
+        if upcall:
+            try:
+                upfunc = super().process_args
+            except AttributeError:
+                pass
+            else:
+                upfunc(args)
+
+    def gen_stats(self):
+        self.require_transitions_group()
+        westpa.rc.pstatus('Analyzing transition statistics...')
+
+        dt = self.dt
+        n_sets = self.mcbs_nsets
+        lbi, ubi = self.calc_ci_bound_indices()
+
+        total_time = self.get_total_time()
+        transdat_ds = self.trans_h5group['transitions']
+        transdat_ibin = transdat_ds['initial_bin']
+
+        if not self.bf_mode:
+            transdat_niter = transdat_ds['n_iter']
+            transdat_in_range = (transdat_niter >= self.first_iter) & (transdat_niter <= self.last_iter)
+
+        durations = np.zeros((self.n_bins, self.n_bins), ciinfo_dtype)
+        fpts = np.zeros((self.n_bins, self.n_bins), ciinfo_dtype)
+        fluxes = np.zeros((self.n_bins, self.n_bins), ciinfo_dtype)
+        rates = np.zeros((self.n_bins, self.n_bins), ciinfo_dtype)
+
+        syn_avg_durations = np.empty((n_sets,), np.float64)
+        syn_avg_fpts = np.empty((n_sets,), np.float64)
+        syn_avg_fluxes = np.empty((n_sets,), np.float64)
+        syn_avg_rates = np.empty((n_sets,), np.float64)
+
+        w_n_bins = len(str(self.n_bins))
+        w_n_sets = len(str(n_sets))
+
+        for ibin in self.analysis_initial_bins:
+            if self.bf_mode:
+                trans_ibin = transdat_ds[transdat_ibin == ibin]
+            else:
+                trans_ibin = transdat_ds[(transdat_ibin == ibin) & transdat_in_range]
+
+            for fbin in self.analysis_final_bins:
+                # trans_ifbins = trans_ibin[trans_ibin['final_bin'] == fbin]
+                trans_ifbins = np.extract(trans_ibin['final_bin'] == fbin, trans_ibin)
+                dlen = len(trans_ifbins)
+
+                if not dlen:
+                    continue
+
+                trans_weights = trans_ifbins['final_weight']
+                trans_durations = trans_ifbins['duration']
+                trans_fpts = trans_ifbins['fpt']
+                trans_ibinprobs = trans_ifbins['initial_bin_pop']
+
+                durations[ibin, fbin]['expectation'] = np.average(trans_durations, weights=trans_weights) * dt
+                fpts[ibin, fbin]['expectation'] = np.average(trans_fpts, weights=trans_weights) * dt
+                avg_flux = trans_weights.sum() / total_time
+                fluxes[ibin, fbin]['expectation'] = avg_flux
+                rates[ibin, fbin]['expectation'] = avg_flux / trans_ibinprobs.mean()
+
+                for iset in range(n_sets):
+                    westpa.rc.pstatus(
+                        '\r  {:{w_n_bins}d}->{:<{w_n_bins}d} set {:{w_n_sets}d}/{:<{w_n_sets}d}, set size {:<20d}'.format(
+                            ibin, fbin, iset + 1, n_sets, dlen, w_n_bins=w_n_bins, w_n_sets=w_n_sets
+                        ),
+                        end='',
+                    )
+                    westpa.rc.pflush()
+                    indices = np.random.randint(dlen, size=(dlen,))
+                    # syn_weights   = trans_weights[indices]
+                    # syn_durations = trans_durations[indices]
+                    # syn_fpts      = trans_fpts[indices]
+                    # syn_ibinprobs = trans_ibinprobs[indices]
+                    syn_weights = trans_weights.take(indices)
+                    syn_durations = trans_durations.take(indices)
+                    syn_fpts = trans_fpts.take(indices)
+                    syn_ibinprobs = trans_ibinprobs.take(indices)
+
+                    syn_avg_durations[iset] = np.average(syn_durations, weights=syn_weights) * dt
+                    syn_avg_fpts[iset] = np.average(syn_fpts, weights=syn_weights) * dt
+                    syn_avg_fluxes[iset] = syn_weights.sum() / total_time
+                    syn_avg_rates[iset] = syn_avg_fluxes[iset] / syn_ibinprobs.mean()
+
+                    del indices, syn_weights, syn_durations, syn_ibinprobs, syn_fpts
+
+                syn_avg_durations.sort()
+                syn_avg_fpts.sort()
+                syn_avg_fluxes.sort()
+                syn_avg_rates.sort()
+
+                durations[ibin, fbin]['ci_lower'] = syn_avg_durations[lbi]
+                durations[ibin, fbin]['ci_upper'] = syn_avg_durations[ubi]
+
+                fpts[ibin, fbin]['ci_lower'] = syn_avg_fpts[lbi]
+                fpts[ibin, fbin]['ci_upper'] = syn_avg_fpts[ubi]
+
+                fluxes[ibin, fbin]['ci_lower'] = syn_avg_fluxes[lbi]
+                fluxes[ibin, fbin]['ci_upper'] = syn_avg_fluxes[ubi]
+
+                rates[ibin, fbin]['ci_lower'] = syn_avg_rates[lbi]
+                rates[ibin, fbin]['ci_upper'] = syn_avg_rates[ubi]
+
+                del trans_weights, trans_durations, trans_ibinprobs, trans_ifbins, trans_fpts
+            westpa.rc.pstatus()
+            del trans_ibin
+
+        for dsname, data in (('duration', durations), ('fpt', fpts), ('flux', fluxes), ('rate', rates)):
+            try:
+                del self.ttimes_group[dsname]
+            except KeyError:
+                pass
+
+            ds = self.ttimes_group.create_dataset(dsname, data=data)
+            attrs = ds.attrs
+            attrs['dt'] = dt
+            attrs['total_time'] = total_time
+            attrs['ci_alpha'] = self.mcbs_alpha
+            attrs['ci_n_sets'] = self.mcbs_nsets
+
+            if not self.bf_mode:
+                self.record_data_iter_range(ds)
+            self.record_data_binhash(ds)
+
+        attrs = self.ttimes_group.attrs
+        attrs = ds.attrs
+        attrs['dt'] = dt
+        attrs['total_time'] = total_time
+        attrs['ci_alpha'] = self.mcbs_alpha
+        attrs['ci_n_sets'] = self.mcbs_nsets
+
+        self.durations = durations
+        self.fluxes = fluxes
+        self.rates = rates
+
+        if not self.bf_mode:
+            self.record_data_iter_range(self.ttimes_group)
+        self.record_data_binhash(self.ttimes_group)
+
+    def summarize_stats(self):
+        for array, dsname, argname, title in (
+            (self.durations, 'duration', 'ed_stats_filename', 'event duration'),
+            (self.fpts, 'fpt', 'fpt_stats_filename', 'first passage time'),
+            (self.fluxes, 'flux', 'flux_stats_filename', 'flux'),
+            (self.rates, 'rate', 'rate_stats_filename', 'rate'),
+        ):
+            filename = getattr(self, argname)
+            if filename:
+                if array is None:
+                    try:
+                        array = self.ttimes_group[dsname]
+                    except KeyError:
+                        westpa.rc.pstatus('{} data not found in {}'.format(title, self.anal_h5name))
+                        continue
+
+                self.summarize_ci(
+                    filename,
+                    array,
+                    title,
+                    self.mcbs_display_confidence,
+                    headers=(not self.suppress_headers),
+                    labels=self.print_bin_labels,
+                )
+
+    def summarize_ci(self, filename, array, title, confidence, headers, labels):
+        format_2d = (
+            '{ibin:{mw}d}    {fbin:{mw}d}    {0:20.15g}    {1:20.15g}    {2:20.15g}    {3:20.15g}    {4:20.15g}    {5:20.15g}\n'
+        )
+        max_ibin_width = len(str(self.n_bins - 1))
+
+        outfile = open(filename, 'wt')
+        if headers:
+            outfile.write(
+                '''\
+# {title:} statistics
+# confidence interval = {confidence}%
+# ----
+# column 0: initial bin index
+# column 1: final bin index
+# column 2: lower bound of confidence interval
+# column 3: upper bound of confidence interval
+# column 4: width of confidence interval
+# column 5: relative width of confidence interval [abs(width/average)]
+# column 6: symmetrized error [max(upper-average, average-lower)]
+# ----
+'''.format(
+                    title=title, confidence=confidence
+                )
+            )
+            if labels:
+                self.write_bin_labels(outfile)
+                outfile.write('----\n')
+
+        for ibin in self.analysis_initial_bins:
+            for fbin in self.analysis_final_bins:
+                mean = array[ibin, fbin]['expectation']
+                lb = array[ibin, fbin]['ci_lower']
+                ub = array[ibin, fbin]['ci_upper']
+                ciwidth = ub - lb
+                relciwidth = abs(ciwidth / mean)
+                symmerr = max(mean - lb, ub - mean)
+
+                outfile.write(
+                    format_2d.format(
+                        *list(map(float, (mean, lb, ub, ciwidth, relciwidth, symmerr))), ibin=ibin, fbin=fbin, mw=max_ibin_width
+                    )
+                )
+
+    def main(self):
+        parser = argparse.ArgumentParser('w_ttimes', description=self.description)
+        westpa.rc.add_args(parser)
+        self.add_args(parser)
+
+        args = parser.parse_args()
+        westpa.rc.process_args(args, config_required=False)
+        self.process_args(args)
+
+        self.check_iter_range()
+        self.check_bin_selection()
+        self.open_analysis_backing()
+        self.ttimes_group = self.require_analysis_group('w_ttimes', replace=False)
+        self.require_bin_assignments()
+        self.require_transitions()
+        self.gen_stats()
+        self.summarize_stats()
+
+
+class WTTimesWE(
+    WTTimesBase,
+    CommonOutputMixin,
+    MCBSMixin,
+    KineticsAnalysisMixin,
+    TransitionAnalysisMixin,
+    BinningMixin,
+    IterRangeMixin,
+    WESTDataReaderMixin,
+    WESTAnalysisTool,
+):
+    description = 'Trace the WEST trajectory tree and report on transition kinetics.'
+
+    def __init__(self):
+        super().__init__()
+
+
+class WTTimesBF(
+    WTTimesBase, CommonOutputMixin, MCBSMixin, KineticsAnalysisMixin, BFTransitionAnalysisMixin, BFDataManager, WESTAnalysisTool
+):
+    description = 'Trace one or more brute force trajectories and report on transition kinetics.'
+    default_chunksize = 65536 * 4
+
+    def __init__(self):
+        super().__init__()
+        self.bf_mode = True
+        self.config_required = False
+        self.usecols = None
+        self.input_files = None
+
+    def check_iter_range(self):
+        pass  # do nothing, since we don't do iteration ranges for brute force
+
+    def get_total_time(self):
+        self.require_bf_h5file()
+        return np.add.reduce([self.get_traj_len(traj_id) - 1 for traj_id in range(self.get_n_trajs())]) * self.dt

westpa/oldtools/files.py

@@ -0,0 +1,34 @@
+import warnings
+import numpy
+
+
+def load_npy_or_text(filename):
+    '''Load an array from an existing .npy file, or read a text file and
+    convert to a NumPy array.  In either case, return a NumPy array.  If a
+    pickled NumPy dataset is found, memory-map it read-only.  If the specified
+    file does not contain a pickled NumPy array, attempt to read the file using
+    numpy.loadtxt(filename, **kwargs).'''
+
+    f = open(filename, 'rb')
+    try:
+        f.seek(0)
+    except IOError:
+        # Not seekable - assume a text stream
+        return numpy.loadtxt(filename)
+    else:
+        f.close()
+
+    # File is seekable
+    try:
+        # try to mmap it
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            return numpy.load(filename, 'r')
+
+    except IOError as e:
+        if 'Failed to interpret' in str(e):
+            pass
+        else:
+            raise
+
+    return numpy.loadtxt(filename)

westpa/oldtools/miscfn.py

@@ -0,0 +1,23 @@
+'''Miscellaneous support functions for WEST and WEST tools'''
+
+import re
+
+
+def parse_int_list(list_string):
+    '''Parse a simple list consisting of integers or ranges of integers separated by commas. Ranges are specified
+    as min:max, and include the maximum value (unlike Python's ``range``).  Duplicate values are ignored.
+    Returns the result as a sorted list.  Raises ValueError if the list cannot be parsed.'''
+
+    try:
+        entries = set()
+        fields = re.split(r'\s*[;,]\s*', list_string)
+        for field in fields:
+            if ':' in field:
+                lb, ub = list(map(int, re.split(r'\s*:\s*', field)))
+                entries.update(list(range(lb, ub + 1)))
+            else:
+                entries.add(int(field))
+    except (ValueError, TypeError):
+        raise ValueError('invalid integer range string {!r}'.format(list_string))
+    else:
+        return sorted(entries)

westpa/oldtools/stats/__init__.py

@@ -0,0 +1,4 @@
+from . import accumulator  # noqa
+from .accumulator import RunningStatsAccumulator  # noqa
+
+from . import mcbs  # noqa

westpa/oldtools/stats/accumulator.py

@@ -0,0 +1,35 @@
+import numpy
+
+NAN = float('nan')
+
+
+class RunningStatsAccumulator:
+    def __init__(self, shape, dtype=numpy.float64, count_dtype=numpy.uint, weight_dtype=numpy.float64, mask_value=NAN):
+        self.sum = numpy.zeros(shape, dtype)
+        self.sqsum = numpy.zeros(shape, dtype)
+        self.weight = numpy.zeros(shape, weight_dtype)
+        self.count = numpy.zeros(shape, count_dtype)
+        self.mask_value = mask_value
+
+    def incorporate(self, index, value, weight):
+        self.count[index] += 1
+        self.weight[index] += weight
+        self.sum[index] += weight * value
+        self.sqsum[index] += weight * value * value
+
+    def average(self):
+        valid = self.count > 0
+        avg = numpy.empty_like(self.sum)
+        avg[valid] = self.sum[valid] / self.weight[valid]
+        avg[~valid] = self.mask_value
+        return avg
+
+    mean = average
+
+    def std(self):
+        valid = self.count > 0
+        vavg = self.average()[valid]
+        std = numpy.empty_like(self.sqsum)
+        std[valid] = (self.sqsum[valid] / self.weight[valid] - vavg * vavg) ** 0.5
+        std[~valid] = self.mask_value
+        return std

westpa/oldtools/stats/edfs.py

@@ -0,0 +1,129 @@
+import numpy
+
+
+class EDF:
+    '''A class for creating and manipulating empirical distribution functions (cumulative
+    distribution functions derived from sample data).
+    '''
+
+    @staticmethod
+    def from_array(array):
+        edf = EDF(None, None)
+        edf.x = array[:, 0]
+        edf.F = array[:, 1]
+        edf.dF = numpy.diff(edf.F)
+        return edf
+
+    @staticmethod
+    def from_arrays(x, F):
+        edf = EDF(None, None)
+        edf.x = x
+        edf.F = F
+        edf.dF = numpy.diff(edf.F)
+        return edf
+
+    def __init__(self, values, weights=None):
+        '''Construct a new EDF from the given values and (optionally) weights.'''
+
+        if values is None:
+            self.x = None
+            self.F = None
+            self.dF = None
+            return
+
+        if weights is None:
+            weights = numpy.ones((len(values)), numpy.float64)
+        elif numpy.isscalar(weights):
+            tweights = numpy.empty((len(values)), numpy.float64)
+            tweights[:] = weights
+            weights = tweights
+        else:
+            if len(weights) != len(values):
+                raise TypeError('values and weights have different lengths')
+
+        # Sort values
+        sort_indices = numpy.argsort(values)
+        values = values[sort_indices]
+        weights = weights[sort_indices]
+
+        # Determine unique abcissae; this is essentially stolen from numpy.lib.arraysetops.unique()
+        x = values[numpy.concatenate(([True], values[1:] != values[:-1]))]
+        F = numpy.empty((len(x),), numpy.float64)
+
+        # ``values`` is arranged in increasing order, so we can walk along it and add up weights
+        # as we go
+        ival_last = 0
+        ival = 0
+        for ibin in range(0, len(x)):
+            while ival < len(values) and values[ival] <= x[ibin]:
+                ival += 1
+            F[ibin] = weights[ival_last:ival].sum()
+            ival_last = ival
+        F = numpy.add.accumulate(F)
+        F /= F[-1]
+
+        self.x = x
+        self.F = F
+        self.dF = numpy.diff(F)
+
+    def __len__(self):
+        return len(self.x)
+
+    def __call__(self, x):
+        '''Evaluate this EDF at the given abcissae.'''
+        indices = numpy.digitize(x, self.x)
+        indices[indices >= len(self.x)] = len(self.x) - 1
+        return self.F[indices]
+
+    def as_array(self):
+        '''Return this EDF as a (N,2) array, where N is the number of unique values passed to
+        the constructor.  Numpy type casting rules are applied (so, for instance, integral abcissae
+        are converted to floating-point values).'''
+
+        result = numpy.empty((len(self.F), 2), dtype=numpy.result_type(self.x, self.F))
+        result[:, 0] = self.x
+        result[:, 1] = self.F
+        return result
+
+    def quantiles(self, p):
+        '''Treating the EDF as a quantile function, return the values of the (statistical) variable whose
+        probabilities are at least p.  That is, Q(p) = inf {x: p <= F(x) }.'''
+
+        indices = numpy.searchsorted(self.F, p)
+        indices[indices >= len(self.x)] = len(self.x) - 1
+        return self.x[indices]
+
+    def quantile(self, p):
+        return self.quantiles([p])[0]
+
+    def median(self):
+        return self.quantiles([0.5])[0]
+
+    def moment(self, n):
+        '''Calculate the nth moment of this probability distribution
+
+        <x^n> = int_{-inf}^{inf} x^n dF(x)
+        '''
+
+        if n == 1:
+            return (self.x[:-1] * self.dF).sum()
+        else:
+            return (self.x[:-1] ** n * self.dF).sum()
+
+    def cmoment(self, n):
+        '''Calculate the nth central moment of this probability distribution'''
+
+        if n < 2:
+            return 0
+        return ((self.x[:-1] - self.moment(1)) ** n * self.dF).sum()
+
+    def mean(self):
+        return self.moment(1)
+
+    def var(self):
+        '''Return the second central moment of this probability distribution.'''
+        return self.cmoment(2)
+
+    def std(self):
+        '''Return the standard deviation (root of the variance) of this probability distribution.'''
+        return self.cmoment(2) ** 0.5

westpa/oldtools/stats/mcbs.py

@@ -0,0 +1,89 @@
+'''
+Tools for Monte Carlo bootstrap error analysis
+'''
+
+import math
+
+import numpy as np
+
+
+def add_mcbs_options(parser):
+    '''Add arguments concerning Monte Carlo bootstrap (``confidence`` and ``bssize``) to the given parser'''
+
+    group = parser.add_argument_group('bootstrapping options')
+    group.add_argument(
+        '--confidence',
+        dest='confidence',
+        type=float,
+        default=0.95,
+        help='Construct a confidence interval of width CONFIDENCE (default: 0.95=95%%)',
+    )
+    group.add_argument(
+        '--bssize',
+        dest='bssize',
+        type=int,
+        help='Use a bootstrap of BSSIZE samples to calculate error (default: chosen from confidence)',
+    )
+
+
+def get_bssize(alpha):
+    '''Return a bootstrap data set size appropriate for the given confidence level'''
+    return int(10 ** (math.ceil(-math.log10(alpha)) + 1))
+
+
+def bootstrap_ci(estimator, data, alpha, n_sets=None, args=(), kwargs={}, sort=np.msort, extended_output=False):
+    '''Perform a Monte Carlo bootstrap of a (1-alpha) confidence interval for the given ``estimator``.
+    Returns (fhat, ci_lower, ci_upper), where fhat is the result of ``estimator(data, *args, **kwargs)``,
+    and ``ci_lower`` and ``ci_upper`` are the lower and upper bounds of the surrounding confidence
+    interval, calculated by calling ``estimator(syndata, *args, **kwargs)`` on each synthetic data
+    set ``syndata``.  If ``n_sets`` is provided, that is the number of synthetic data sets generated,
+    otherwise an appropriate size is selected automatically (see ``get_bssize()``).
+
+    ``sort``, if given, is applied to sort the results of calling ``estimator`` on each
+    synthetic data set prior to obtaining the confidence interval.
+
+    Individual entries in synthetic data sets are selected by the first index of ``data``, allowing this
+    function to be used on arrays of multidimensional data.
+
+    If ``extended_output`` is True (by default not), instead of returning (fhat, lb, ub), this function returns
+    (fhat, lb, ub, ub-lb, abs((ub-lb)/fhat), and max(ub-fhat,fhat-lb)) (that is, the estimated value, the
+    lower and upper bounds of the confidence interval, the width of the confidence interval, the relative
+    width of the confidence interval, and the symmetrized error bar of the confidence interval).'''
+
+    data = np.asanyarray(data)
+
+    fhat = estimator(data, *args, **kwargs)
+
+    try:
+        estimator_shape = fhat.shape
+    except AttributeError:
+        estimator_shape = ()
+
+    try:
+        estimator_dtype = fhat.dtype
+    except AttributeError:
+        estimator_dtype = type(fhat)
+
+    dlen = len(data)
+    n_sets = n_sets or get_bssize(alpha)
+
+    f_synth = np.empty((n_sets,) + estimator_shape, dtype=estimator_dtype)
+
+    for i in range(0, n_sets):
+        indices = np.random.randint(dlen, size=(dlen,))
+        f_synth[i] = estimator(data[indices], *args, **kwargs)
+
+    f_synth_sorted = sort(f_synth)
+    lbi = int(math.floor(n_sets * alpha / 2))
+    ubi = int(math.ceil(n_sets * (1 - alpha / 2)))
+    lb = f_synth_sorted[lbi]
+    ub = f_synth_sorted[ubi]
+
+    try:
+        if extended_output:
+            return (fhat, lb, ub, ub - lb, abs((ub - lb) / fhat) if fhat else 0, max(ub - fhat, fhat - lb))
+        else:
+            return (fhat, lb, ub)
+    finally:
+        # Do a little explicit memory management
+        del f_synth, f_synth_sorted