Merge#2045 (DougBurke) - Mark code as deprecated in sherpa.utils

Mark code as deprecated in sherpa.utils

sherpa/estmethods/__init__.py

@@ -25,8 +25,8 @@
 from numpy.linalg import LinAlgError
 
 from sherpa.utils import NoNewAttributesAfterInit, print_fields, Knuth_close, \
-    is_iterable, list_to_open_interval, mysgn, quad_coef, \
-    demuller, zeroin, OutOfBoundErr, func_counter
+    is_iterable, list_to_open_interval, quad_coef, \
+    demuller, zeroin, OutOfBoundErr, FuncCounter
 from sherpa.utils.parallel import multi, ncpus, context, process_tasks
 
 import sherpa.estmethods._est_funcs
@@ -719,7 +719,7 @@ def warn_user_about_open_interval(listval):
         xxx = self.trial_points[0]
         fff = self.trial_points[1]
 
-        if mysgn(fff[-2]) == mysgn(fff[-1]):
+        if np.sign(fff[-2]) == np.sign(fff[-1]):
             self.root = None
             return None
 
@@ -733,7 +733,7 @@ def warn_user_about_open_interval(listval):
             xbfb = answer[1][1]
             xb = xbfb[0]
             fb = xbfb[1]
-            if mysgn(fa) != mysgn(fb):
+            if np.sign(fa) != np.sign(fb):
                 if not self.open_interval:
                     warn_user_about_open_interval([xa, xb])
                     return (xa + xb) / 2.0
@@ -793,7 +793,7 @@ def Halley(self, coeffs, x, maxfev=8, tol=1.0e-3):
 
     def is_same_dir(self, dir, current_pos, proposed_pos):
         delta = proposed_pos - current_pos
-        return mysgn(delta) == ConfBracket.neg_pos[dir]
+        return np.sign(delta) == ConfBracket.neg_pos[dir]
 
     def quad(self, dir, iter, step_size, base, bloginfo):
 
@@ -1027,8 +1027,7 @@ def verbose_fcn(x, *args):
 
     def func(counter, singleparnum, lock=None):
 
-        # nfev contains the number of times it was fitted
-        nfev, counter_cb = func_counter(fit_cb)
+        counter_cb = FuncCounter(fit_cb)
 
         #
         # These are the bounds to be returned by this method
@@ -1101,7 +1100,7 @@ def func(counter, singleparnum, lock=None):
         store[par_name] = trial_points
 
         return (conf_int[0][0], conf_int[1][0], error_flags[0],
-                nfev[0], None)
+                counter_cb.nfev, None)
 
     if len(limit_parnums) < 2 or not multi or numcores < 2:
         do_parallel = False

sherpa/fit.py

@@ -28,7 +28,7 @@
     ones_like, isnan, isinf
 
 from sherpa.utils import NoNewAttributesAfterInit, print_fields, erf, \
-    bool_cast, is_in, is_iterable, list_to_open_interval, sao_fcmp
+    bool_cast, is_iterable, list_to_open_interval, sao_fcmp
 from sherpa.utils.err import DataErr, EstErr, FitErr, SherpaErr
 from sherpa.utils import formatting
 from sherpa.data import DataSimulFit
@@ -530,10 +530,8 @@ def myformat(hfmt, lowstr, lownum, highstr, highnum):
 
             return out
 
-        low = map(is_iterable, self.parmins)
-        high = map(is_iterable, self.parmaxes)
-        in_low = is_in(True, low)
-        in_high = is_in(True, high)
+        in_low = True in map(is_iterable, self.parmins)
+        in_high = True in map(is_iterable, self.parmaxes)
         mymethod = self.methodname == 'confidence'
 
         lowstr = '%12s '

sherpa/optmethods/ncoresde.py

@@ -279,7 +279,7 @@ def __call__(self, maxnfev, ftol):
 
         mypop = self.polytope
         npop_1 = self.npop - 1
-        while self.nfev[0] < maxnfev:
+        while self.nfev < maxnfev:
             for pop_index in range(self.npop):
                 key = self.calc_key([pop_index])
                 # trial = self.all_strategies(pop_index)
@@ -294,7 +294,7 @@ def __call__(self, maxnfev, ftol):
         best_vertex = mypop[0]
         best_par = best_vertex[:-1]
         best_val = best_vertex[-1]
-        return self.nfev[0], best_val, best_par
+        return self.nfev, best_val, best_par
 
     def all_strategies(self, key):
         rand, index = self.key2.parse(key)

sherpa/optmethods/ncoresnm.py

@@ -1,5 +1,5 @@
 #
-#  Copyright (C) 2019, 2020, 2021, 2023
+#  Copyright (C) 2019- 2021, 2023, 2024
 #  Smithsonian Astrophysical Observatory
 #
 #
@@ -42,16 +42,13 @@ def __init__(self, fcn, xmin, xmax):
 
     def __call__(self, xpar, maxnfev, tol, step, finalsimplex, verbose):
 
-        # print('MyNelderMead::__call__ xpar =', xpar)
         npar = len(xpar)
         simplex = SimplexStep(func=self.func, npop=npar + 1,
                               xpar=xpar, xmin=self.xmin,
                               xmax=self.xmax, step=step, seed=None,
                               factor=None)
-        result = self.optimize(xpar, simplex, maxnfev, tol,
-                               finalsimplex, verbose)
-        # print('MyNelderMead::__call__ result =', result)
-        return result
+        return self.optimize(xpar, simplex, maxnfev, tol,
+                             finalsimplex, verbose)
 
     def contract_in_out(self, simplex, centroid, reflection_pt, rho_gamma,
                         contraction_coef, badindex, maxnfev, verbose):
@@ -95,7 +92,7 @@ def optimize(self, xpar, simplex, maxnfev, tol, finalsimplex, verbose):
         rho_gamma = self.reflection_coef * self.contraction_coef
         bad_index = len(xpar)
 
-        while self.nfev[0] < maxnfev:
+        while self.nfev < maxnfev:
 
             simplex.sort()
             if verbose > 2:
@@ -135,7 +132,7 @@ def optimize(self, xpar, simplex, maxnfev, tol, finalsimplex, verbose):
         best_vertex = simplex[0]
         best_par = best_vertex[:-1]
         best_val = best_vertex[-1]
-        return self.nfev[0], best_val, best_par
+        return self.nfev, best_val, best_par
 
 
 class NelderMeadBase:
@@ -167,10 +164,8 @@ class NelderMead0(NelderMeadBase):
 
     def __call__(self, fcn, x, xmin, xmax, tol=1.0e-6,  maxnfev=None, step=None,
                  finalsimplex=1, verbose=0):
-        nfev, fmin, par = \
-            self.neldermead0(fcn, x, xmin, xmax, step, finalsimplex, maxnfev,
-                             tol, verbose)
-        return nfev, fmin, par
+        return self.neldermead0(fcn, x, xmin, xmax, step, finalsimplex, maxnfev,
+                                tol, verbose)
 
     def calc_step(self, x):
         return 1.2 * x
@@ -183,10 +178,8 @@ def neldermead0(self, fcn, x0, xmin, xmax, step=None, finalsimplex=1,
         my_nm = MyNelderMead(fcn, xmin, xmax)
         if step is None:
             step = self.calc_step(x0)
-        nfev, fmin, par = my_nm(x0, maxnfev, tol, step, finalsimplex, verbose)
-        # print('f', par, '=', fmin, '@', nfev, 'nfevs')
-        # print('neldermead0 covar=\n', my_nm.calc_covar())
-        return nfev, fmin, par
+
+        return my_nm(x0, maxnfev, tol, step, finalsimplex, verbose)
 
 
 class NelderMead1(NelderMead0):
@@ -279,18 +272,15 @@ def __call__(self, x, maxnfev, tol, step, finalsimplex, verbose):
                                     xpar=x, xmin=self.xmin,
                                     xmax=self.xmax, step=None,
                                     seed=None, factor=None)
-            result = self.optimize(x, simplex, maxnfev, tol,
-                                   finalsimplex, verbose)
-            # print('MyNelderMead6::__call__ result =', result)
-            return result
+            return self.optimize(x, simplex, maxnfev, tol,
+                                 finalsimplex, verbose)
 
     def __call__(self, fcn, x, xmin, xmax, tol=1.0e-6,  maxnfev=None,
                  step=None, finalsimplex=1, verbose=0):
         my_nm_6 = NelderMead6.MyNelderMead6(fcn, xmin, xmax)
         if maxnfev is None:
             maxnfev = 512 * len(x)
-        result = my_nm_6(x, maxnfev, tol, step, finalsimplex, verbose)
-        return result
+        return my_nm_6(x, maxnfev, tol, step, finalsimplex, verbose)
 
 
 class NelderMead7(NelderMeadBase):
@@ -304,18 +294,15 @@ def __call__(self, x, maxnfev, tol, step, finalsimplex, verbose):
             simplex = SimplexRandom(func=self.func, npop=npar + 1, xpar=x,
                                     xmin=self.xmin, xmax=self.xmax,
                                     step=None, seed=None, factor=factor)
-            result = self.optimize(x, simplex, maxnfev, tol,
-                                   finalsimplex, verbose)
-            # print('MyNelderMead7::__call__ result =', result)
-            return result
+            return self.optimize(x, simplex, maxnfev, tol,
+                                 finalsimplex, verbose)
 
     def __call__(self, fcn, x, xmin, xmax, tol=1.0e-6,  maxnfev=None,
                  step=None, finalsimplex=1, verbose=0):
         my_nm_7 = NelderMead7.MyNelderMead7(fcn, xmin, xmax)
         if maxnfev is None:
             maxnfev = 512 * len(x)
-        result = my_nm_7(x, maxnfev, tol, step, finalsimplex, verbose)
-        return result
+        return my_nm_7(x, maxnfev, tol, step, finalsimplex, verbose)
 
 
 class nmNcores(MyNcores):

sherpa/optmethods/opt.py

@@ -20,7 +20,7 @@
 
 import numpy as np
 
-from sherpa.utils import Knuth_close, func_counter
+from sherpa.utils import Knuth_close, FuncCounter
 from sherpa.utils.parallel import multi, context, run_tasks
 from sherpa.utils.random import uniform
 
@@ -70,17 +70,34 @@ def my_worker(self, opt, idval, out_q, err_q, *args):
 
 
 class Opt:
+    """Base optimisation class.
 
+    .. versionchanged:: 4.17.0
+       The class structure has been changed (e.g. `nfev` is now a
+       scalar and not a single-element list).
+
+    """
+
+    # QUS: we support xmin or xmax being None, but do we ever use
+    # this capability?
+    #
     def __init__(self, func, xmin, xmax):
         self.npar = len(xmin)
-        self.nfev, self.func = \
-            self.func_counter_bounds_wrappers(func, self.npar, xmin, xmax)
         self.xmin = np.asarray(xmin)
         self.xmax = np.asarray(xmax)
+        self.func_count = FuncCounter(func)
+        self.func = self.func_bounds(self.func_count, self.npar, xmin, xmax)
+
+    @property
+    def nfev(self):
+        return self.func_count.nfev
 
     def _outside_limits(self, x, xmin, xmax):
         return (np.any(x < xmin) or np.any(x > xmax))
 
+    # We should be able to take these parameters from the class, or
+    # re-write this logic.
+    #
     def func_bounds(self, func, npar, xmin=None, xmax=None):
         """In order to keep the current number of function evaluations:
         func_counter should be called before func_bounds. For example,
@@ -113,12 +130,6 @@ def func_bounds_wrapper(x, *args):
 
         return func_bounds_wrapper
 
-    def func_counter_bounds_wrappers(self, func, npar, xmin, xmax):
-        """Wraps the calls to func_counter then func_bounds"""
-        nfev, afunc = func_counter(func)
-        myfunc = self.func_bounds(afunc, npar, xmin, xmax)
-        return nfev, myfunc
-
 
 class SimplexBase:
 

sherpa/optmethods/optfcts.py

@@ -73,7 +73,8 @@
 from sherpa.optmethods.ncoresde import ncoresDifEvo
 from sherpa.optmethods.ncoresnm import ncoresNelderMead
 
-from sherpa.utils import parallel_map, func_counter
+from sherpa.utils import FuncCounter
+from sherpa.utils.parallel import parallel_map
 from sherpa.utils._utils import sao_fcmp  # type: ignore
 from sherpa.utils import random
 
@@ -1220,7 +1221,7 @@ def fcn_parallel(pars, fvec):
         fjac = parallel_map(fd_jac, params, numcores)
         return numpy.concatenate(fjac)
 
-    num_parallel_map, fcn_parallel_counter = func_counter(fcn_parallel)
+    fcn_parallel_counter = FuncCounter(fcn_parallel)
 
     # TO DO: reduce 1 model eval by passing the resulting 'fvec' to cpp_lmdif
     m = numpy.asanyarray(stat_cb1(x)).size
@@ -1262,11 +1263,9 @@ def fcn_parallel(pars, fvec):
         info = 3
     status, msg = _get_saofit_msg(maxfev, info)
 
+    imap = {'info': info, 'nfev': nfev,
+            'num_parallel_map': fcn_parallel_counter.nfev}
     if info == 0:
-        rv = (status, x, fval, msg, {'info': info, 'nfev': nfev,
-                                     'covar': covar,
-                                     'num_parallel_map': num_parallel_map[0]})
-    else:
-        rv = (status, x, fval, msg, {'info': info, 'nfev': nfev,
-                                     'num_parallel_map': num_parallel_map[0]})
-    return rv
+        imap['covar'] = covar
+
+    return (status, x, fval, msg, imap)