pyGSTi 0.9.12.1__cp310-cp310-win32.whl → 0.9.13__cp310-cp310-win32.whl

pygsti/optimize/customlm.py

@@ -10,6 +10,7 @@ Custom implementation of the Levenberg-Marquardt Algorithm
 # http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.
 #***************************************************************************************************
 
+import os as _os
 import signal as _signal
 import time as _time
 
@@ -18,94 +19,19 @@ import scipy as _scipy
 
 from pygsti.optimize import arraysinterface as _ari
 from pygsti.optimize.customsolve import custom_solve as _custom_solve
+from pygsti.optimize.simplerlm import Optimizer, OptimizerResult
 from pygsti.baseobjs.verbosityprinter import VerbosityPrinter as _VerbosityPrinter
 from pygsti.baseobjs.resourceallocation import ResourceAllocation as _ResourceAllocation
 from pygsti.baseobjs.nicelyserializable import NicelySerializable as _NicelySerializable
 
-# from scipy.optimize import OptimizeResult as _optResult
-
-#Make sure SIGINT will generate a KeyboardInterrupt (even if we're launched in the background)
-_signal.signal(_signal.SIGINT, _signal.default_int_handler)
+# Make sure SIGINT will generate a KeyboardInterrupt (even if we're launched in the background)
+# This may be problematic for multithreaded parallelism above pyGSTi, e.g. Dask,
+# so this can be turned off by setting the PYGSTI_NO_CUSTOMLM_SIGINT environment variable
+if 'PYGSTI_NO_CUSTOMLM_SIGINT' not in _os.environ:
+    _signal.signal(_signal.SIGINT, _signal.default_int_handler)
 
 #constants
 _MACH_PRECISION = 1e-12
-#MU_TOL1 = 1e10 # ??
-#MU_TOL2 = 1e3  # ??
-
-
-class OptimizerResult(object):
-    """
-    The result from an optimization.
-
-    Parameters
-    ----------
-    objective_func : ObjectiveFunction
-        The objective function that was optimized.
-
-    opt_x : numpy.ndarray
-        The optimal argument (x) value.  Often a vector of parameters.
-
-    opt_f : numpy.ndarray
-        the optimal objective function (f) value.  Often this is the least-squares
-        vector of objective function values.
-
-    opt_jtj : numpy.ndarray, optional
-        the optimial `dot(transpose(J),J)` value, where `J`
-        is the Jacobian matrix.  This may be useful for computing
-        approximate error bars.
-
-    opt_unpenalized_f : numpy.ndarray, optional
-        the optimal objective function (f) value with any
-        penalty terms removed.
-
-    chi2_k_distributed_qty : float, optional
-        a value that is supposed to be chi2_k distributed.
-
-    optimizer_specific_qtys : dict, optional
-        a dictionary of additional optimization parameters.
-    """
-    def __init__(self, objective_func, opt_x, opt_f=None, opt_jtj=None,
-                 opt_unpenalized_f=None, chi2_k_distributed_qty=None,
-                 optimizer_specific_qtys=None):
-        self.objective_func = objective_func
-        self.x = opt_x
-        self.f = opt_f
-        self.jtj = opt_jtj  # jacobian.T * jacobian
-        self.f_no_penalties = opt_unpenalized_f
-        self.optimizer_specific_qtys = optimizer_specific_qtys
-        self.chi2_k_distributed_qty = chi2_k_distributed_qty
-
-
-class Optimizer(_NicelySerializable):
-    """
-    An optimizer.  Optimizes an objective function.
-    """
-
-    @classmethod
-    def cast(cls, obj):
-        """
-        Cast `obj` to a :class:`Optimizer`.
-
-        If `obj` is already an `Optimizer` it is just returned,
-        otherwise this function tries to create a new object
-        using `obj` as a dictionary of constructor arguments.
-
-        Parameters
-        ----------
-        obj : Optimizer or dict
-            The object to cast.
-
-        Returns
-        -------
-        Optimizer
-        """
-        if isinstance(obj, cls):
-            return obj
-        else:
-            return cls(**obj) if obj else cls()
-
-    def __init__(self):
-        super().__init__()
 
 
 class CustomLMOptimizer(Optimizer):
@@ -371,13 +297,6 @@ class CustomLMOptimizer(Optimizer):
         return OptimizerResult(objective, opt_x, norm_f, opt_jtj, unpenalized_normf, chi2k_qty,
                                {'msg': msg, 'mu': mu, 'nu': nu, 'fvec': f})
 
-#Scipy version...
-#            opt_x, _, _, msg, flag = \
-#                _spo.leastsq(objective_func, x0, xtol=tol['relx'], ftol=tol['relf'], gtol=tol['jac'],
-#                             maxfev=maxfev * (len(x0) + 1), full_output=True, Dfun=jacobian)  # pragma: no cover
-#            printer.log("Least squares message = %s; flag =%s" % (msg, flag), 2)            # pragma: no cover
-#            opt_state = (msg,)
-
 
 def custom_leastsq(obj_fn, jac_fn, x0, f_norm2_tol=1e-6, jac_norm_tol=1e-6,
                    rel_ftol=1e-6, rel_xtol=1e-6, max_iter=100, num_fd_iters=0,
@@ -891,7 +810,6 @@ def custom_leastsq(obj_fn, jac_fn, x0, f_norm2_tol=1e-6, jac_norm_tol=1e-6,
                 reject_msg = ""
                 if profiler: profiler.memory_check("custom_leastsq: after linsolve")
                 if success:  # linear solve succeeded
-                    #dx = _hack_dx(obj_fn, x, dx, Jac, JTJ, JTf, f, norm_f)
 
                     if damping_mode != 'adaptive':
                         new_x[:] = x + dx
@@ -1311,239 +1229,127 @@ def custom_leastsq(obj_fn, jac_fn, x0, f_norm2_tol=1e-6, jac_norm_tol=1e-6,
     #return solution
 
 
-def _hack_dx(obj_fn, x, dx, jac, jtj, jtf, f, norm_f):
-    #HACK1
-    #if nRejects >= 2:
-    #    dx = -(10.0**(1-nRejects))*x
-    #    print("HACK - setting dx = -%gx!" % 10.0**(1-nRejects))
-    #    return dx
-
-    #HACK2
-    if True:
-        print("HACK2 - trying to find a good dx by iteratively stepping in each direction...")
-
-        test_f = obj_fn(x + dx); cmp_normf = _np.dot(test_f, test_f)
-        print("Compare with suggested step => ", cmp_normf)
-        STEP = 0.0001
-
-        #import bpdb; bpdb.set_trace()
-        #gradient = -jtf
-        test_dx = _np.zeros(len(dx), 'd')
-        last_normf = norm_f
-        for ii in range(len(dx)):
-
-            #Try adding
-            while True:
-                test_dx[ii] += STEP
-                test_f = obj_fn(x + test_dx); test_normf = _np.dot(test_f, test_f)
-                if test_normf < last_normf:
-                    last_normf = test_normf
+"""
+def custom_leastsq_wikip(obj_fn, jac_fn, x0, f_norm_tol=1e-6, jac_norm_tol=1e-6,
+                  rel_tol=1e-6, max_iter=100, comm=None, verbosity=0, profiler=None):
+    #
+    # Wikipedia-version of LM algorithm, testing mu and mu/nu damping params and taking
+    # mu/nu => new_mu if acceptable...  This didn't seem to perform well, but maybe just
+    # needs some tweaking, so leaving it commented here for reference
+    #
+    msg = ""
+    converged = False
+    x = x0
+    f = obj_fn(x)
+    norm_f = _np.linalg.norm(f)
+    tau = 1e-3 #initial mu
+    nu = 1.3
+    my_cols_slice = None
+
+
+    if not _np.isfinite(norm_f):
+        msg = "Infinite norm of objective function at initial point!"
+
+    for k in range(max_iter): #outer loop
+        # assume x, f, fnorm hold valid values
+
+        if len(msg) > 0:
+            break #exit outer loop if an exit-message has been set
+
+        if norm_f < f_norm_tol:
+            msg = "norm(objectivefn) is small"
+            converged = True; break
+
+        if verbosity > 0:
+            print("--- Outer Iter %d: norm_f = %g" % (k,norm_f))
+
+        if profiler: profiler.mem_check("custom_leastsq: begin outer iter *before de-alloc*")
+        jac = None; jtj = None; jtf = None
+
+        if profiler: profiler.mem_check("custom_leastsq: begin outer iter")
+        jac = jac_fn(x)
+        if profiler: profiler.mem_check("custom_leastsq: after jacobian:"
+                                        + "shape=%s, GB=%.2f" % (str(jac.shape),
+                                                        jac.nbytes/(1024.0**3)) )
+
+        tm = _time.time()
+        if my_cols_slice is None:
+            my_cols_slice = _mpit.distribute_for_dot(jac.shape[0], comm)
+        jtj = _mpit.mpidot(jac.T,jac,my_cols_slice,comm)   #_np.dot(jac.T,jac)
+        jtf = _np.dot(jac.T,f)
+        if profiler: profiler.add_time("custom_leastsq: dotprods",tm)
+
+        idiag = _np.diag_indices_from(jtj)
+        norm_JTf = _np.linalg.norm(jtf) #, ord='inf')
+        norm_x = _np.linalg.norm(x)
+        undampled_JTJ_diag = jtj.diagonal().copy()
+
+        if norm_JTf < jac_norm_tol:
+            msg = "norm(jacobian) is small"
+            converged = True; break
+
+        if k == 0:
+            mu = tau #* _np.max(undampled_JTJ_diag) # initial damping element
+        #mu = tau #* _np.max(undampled_JTJ_diag) # initial damping element
+
+        #determing increment using adaptive damping
+        while True:  #inner loop
+
+            ### Evaluate with mu' = mu / nu
+            mu = mu / nu
+            if profiler: profiler.mem_check("custom_leastsq: begin inner iter")
+            jtj[idiag] *= (1.0 + mu) # augment normal equations
+            #jtj[idiag] += mu # augment normal equations
+
+            try:
+                if profiler: profiler.mem_check("custom_leastsq: before linsolve")
+                tm = _time.time()
+                success = True
+                dx = _np.linalg.solve(jtj, -jtf)
+                if profiler: profiler.add_time("custom_leastsq: linsolve",tm)
+            except _np.linalg.LinAlgError:
+                success = False
+
+            if profiler: profiler.mem_check("custom_leastsq: after linsolve")
+            if success: #linear solve succeeded
+                new_x = x + dx
+                norm_dx = _np.linalg.norm(dx)
+
+                #if verbosity > 1:
+                #    print("--- Inner Loop: mu=%g, norm_dx=%g" % (mu,norm_dx))
+
+                if norm_dx < rel_tol*norm_x: #use squared qtys instead (speed)?
+                    msg = "relative change in x is small"
+                    converged = True; break
+
+                if norm_dx > (norm_x+rel_tol)/_MACH_PRECISION:
+                    msg = "(near-)singular linear system"; break
+
+                new_f = obj_fn(new_x)
+                if profiler: profiler.mem_check("custom_leastsq: after obj_fn")
+                norm_new_f = _np.linalg.norm(new_f)
+                if not _np.isfinite(norm_new_f): # avoid infinite loop...
+                    msg = "Infinite norm of objective function!"; break
+
+                dF = norm_f - norm_new_f
+                if dF > 0: #accept step
+                    #print("      Accepted!")
+                    x,f, norm_f = new_x, new_f, norm_new_f
+                    nu = 1.3
+                    break # exit inner loop normally
                 else:
-                    test_dx[ii] -= STEP
-                    break
-
-            if test_dx[ii] == 0:  # then try subtracting
-                while True:
-                    test_dx[ii] -= STEP
-                    test_f = obj_fn(x + test_dx); test_normf = _np.dot(test_f, test_f)
-                    if test_normf < last_normf:
-                        last_normf = test_normf
-                    else:
-                        test_dx[ii] += STEP
-                        break
-
-            if abs(test_dx[ii]) > 1e-6:
-                test_prediction = norm_f + _np.dot(-2 * jtf, test_dx)
-                tp2_f = f + _np.dot(jac, test_dx)
-                test_prediction2 = _np.dot(tp2_f, tp2_f)
-                cmp_dx = dx  # -jtf
-                print(" -> Adjusting index ", ii, ":", x[ii], "+", test_dx[ii], " => ", last_normf, "(cmp w/dx: ",
-                      cmp_dx[ii], test_prediction, test_prediction2, ") ",
-                      "YES" if test_dx[ii] * cmp_dx[ii] > 0 else "NO")
-
-        if _np.linalg.norm(test_dx) > 0 and last_normf < cmp_normf:
-            print("FOUND HACK dx w/norm = ", _np.linalg.norm(test_dx))
-            return test_dx
-        else:
-            print("KEEPING ORIGINAL dx")
-
-    #HACK3
-    if False:
-        print("HACK3 - checking if there's a simple dx that is better...")
-        test_f = obj_fn(x + dx); cmp_normf = _np.dot(test_f, test_f)
-        orig_prediction = norm_f + _np.dot(2 * jtf, dx)
-        Jdx = _np.dot(jac, dx)
-        op2_f = f + Jdx
-        orig_prediction2 = _np.dot(op2_f, op2_f)
-        # main objective = fT*f = norm_f
-        # at new x => (f+J*dx)T * (f+J*dx) = norm_f + JdxT*f + fT*Jdx
-        #                                  = norm_f + 2*(fT*J)dx (b/c transpose of real# does nothing)
-        #                                  = norm_f + 2*dxT*(JT*f)
-        # prediction 2 also includes (J*dx)T * (J*dx) term = dxT * (jtj) * dx
-        orig_prediction3 = orig_prediction + _np.dot(Jdx, Jdx)
-        norm_dx = _np.linalg.norm(dx)
-        print("Compare with suggested |dx| = ", norm_dx, " => ", cmp_normf,
-              "(predicted: ", orig_prediction, orig_prediction2, orig_prediction3)
-        STEP = norm_dx  # 0.0001
-
-        #import bpdb; bpdb.set_trace()
-        test_dx = _np.zeros(len(dx), 'd')
-        best_ii = -1; best_normf = norm_f; best_dx = 0
-        for ii in range(len(dx)):
-
-            #Try adding a small amount
-            test_dx[ii] = STEP
-            test_f = obj_fn(x + test_dx); test_normf = _np.dot(test_f, test_f)
-            if test_normf < best_normf:
-                best_normf = test_normf
-                best_dx = STEP
-                best_ii = ii
+                    mu *= nu #increase mu
             else:
-                test_dx[ii] = -STEP
-                test_f = obj_fn(x + test_dx); test_normf = _np.dot(test_f, test_f)
-                if test_normf < best_normf:
-                    best_normf = test_normf
-                    best_dx = -STEP
-                    best_ii = ii
-            test_dx[ii] = 0
-
-        test_dx[best_ii] = best_dx
-        test_prediction = norm_f + _np.dot(2 * jtf, test_dx)
-        tp2_f = f + _np.dot(jac, test_dx)
-        test_prediction2 = _np.dot(tp2_f, tp2_f)
-
-        jj = _np.argmax(_np.abs(dx))
-        print("Best decrease = index", best_ii, ":", x[best_ii], '+', best_dx, "==>",
-              best_normf, " (predictions: ", test_prediction, test_prediction2, ")")
-        print(" compare with original dx[", best_ii, "]=", dx[best_ii],
-              "YES" if test_dx[best_ii] * dx[best_ii] > 0 else "NO")
-        print(" max of abs(dx) is index ", jj, ":", dx[jj], "yes" if jj == best_ii else "no")
-
-        if _np.linalg.norm(test_dx) > 0 and best_normf < cmp_normf:
-            print("FOUND HACK dx w/norm = ", _np.linalg.norm(test_dx))
-            return test_dx
-        else:
-            print("KEEPING ORIGINAL dx")
-    return dx
-
-
-#Wikipedia-version of LM algorithm, testing mu and mu/nu damping params and taking
-# mu/nu => new_mu if acceptable...  This didn't seem to perform well, but maybe just
-# needs some tweaking, so leaving it commented here for reference
-#def custom_leastsq_wikip(obj_fn, jac_fn, x0, f_norm_tol=1e-6, jac_norm_tol=1e-6,
-#                   rel_tol=1e-6, max_iter=100, comm=None, verbosity=0, profiler=None):
-#    msg = ""
-#    converged = False
-#    x = x0
-#    f = obj_fn(x)
-#    norm_f = _np.linalg.norm(f)
-#    tau = 1e-3 #initial mu
-#    nu = 1.3
-#    my_cols_slice = None
-#
-#
-#    if not _np.isfinite(norm_f):
-#        msg = "Infinite norm of objective function at initial point!"
-#
-#    for k in range(max_iter): #outer loop
-#        # assume x, f, fnorm hold valid values
-#
-#        if len(msg) > 0:
-#            break #exit outer loop if an exit-message has been set
-#
-#        if norm_f < f_norm_tol:
-#            msg = "norm(objectivefn) is small"
-#            converged = True; break
-#
-#        if verbosity > 0:
-#            print("--- Outer Iter %d: norm_f = %g" % (k,norm_f))
-#
-#        if profiler: profiler.mem_check("custom_leastsq: begin outer iter *before de-alloc*")
-#        jac = None; jtj = None; jtf = None
-#
-#        if profiler: profiler.mem_check("custom_leastsq: begin outer iter")
-#        jac = jac_fn(x)
-#        if profiler: profiler.mem_check("custom_leastsq: after jacobian:"
-#                                        + "shape=%s, GB=%.2f" % (str(jac.shape),
-#                                                        jac.nbytes/(1024.0**3)) )
-#
-#        tm = _time.time()
-#        if my_cols_slice is None:
-#            my_cols_slice = _mpit.distribute_for_dot(jac.shape[0], comm)
-#        jtj = _mpit.mpidot(jac.T,jac,my_cols_slice,comm)   #_np.dot(jac.T,jac)
-#        jtf = _np.dot(jac.T,f)
-#        if profiler: profiler.add_time("custom_leastsq: dotprods",tm)
-#
-#        idiag = _np.diag_indices_from(jtj)
-#        norm_JTf = _np.linalg.norm(jtf) #, ord='inf')
-#        norm_x = _np.linalg.norm(x)
-#        undampled_JTJ_diag = jtj.diagonal().copy()
-#
-#        if norm_JTf < jac_norm_tol:
-#            msg = "norm(jacobian) is small"
-#            converged = True; break
-#
-#        if k == 0:
-#            mu = tau #* _np.max(undampled_JTJ_diag) # initial damping element
-#        #mu = tau #* _np.max(undampled_JTJ_diag) # initial damping element
-#
-#        #determing increment using adaptive damping
-#        while True:  #inner loop
-#
-#            ### Evaluate with mu' = mu / nu
-#            mu = mu / nu
-#            if profiler: profiler.mem_check("custom_leastsq: begin inner iter")
-#            jtj[idiag] *= (1.0 + mu) # augment normal equations
-#            #jtj[idiag] += mu # augment normal equations
-#
-#            try:
-#                if profiler: profiler.mem_check("custom_leastsq: before linsolve")
-#                tm = _time.time()
-#                success = True
-#                dx = _np.linalg.solve(jtj, -jtf)
-#                if profiler: profiler.add_time("custom_leastsq: linsolve",tm)
-#            except _np.linalg.LinAlgError:
-#                success = False
-#
-#            if profiler: profiler.mem_check("custom_leastsq: after linsolve")
-#            if success: #linear solve succeeded
-#                new_x = x + dx
-#                norm_dx = _np.linalg.norm(dx)
-#
-#                #if verbosity > 1:
-#                #    print("--- Inner Loop: mu=%g, norm_dx=%g" % (mu,norm_dx))
-#
-#                if norm_dx < rel_tol*norm_x: #use squared qtys instead (speed)?
-#                    msg = "relative change in x is small"
-#                    converged = True; break
-#
-#                if norm_dx > (norm_x+rel_tol)/_MACH_PRECISION:
-#                    msg = "(near-)singular linear system"; break
-#
-#                new_f = obj_fn(new_x)
-#                if profiler: profiler.mem_check("custom_leastsq: after obj_fn")
-#                norm_new_f = _np.linalg.norm(new_f)
-#                if not _np.isfinite(norm_new_f): # avoid infinite loop...
-#                    msg = "Infinite norm of objective function!"; break
-#
-#                dF = norm_f - norm_new_f
-#                if dF > 0: #accept step
-#                    #print("      Accepted!")
-#                    x,f, norm_f = new_x, new_f, norm_new_f
-#                    nu = 1.3
-#                    break # exit inner loop normally
-#                else:
-#                    mu *= nu #increase mu
-#            else:
-#                #Linear solve failed:
-#                mu *= nu #increase mu
-#                nu = 2*nu
-#
-#            jtj[idiag] = undampled_JTJ_diag #restore diagonal for next inner loop iter
-#        #end of inner loop
-#    #end of outer loop
-#    else:
-#        #if no break stmt hit, then we've exceeded max_iter
-#        msg = "Maximum iterations (%d) exceeded" % max_iter
-#
-#    return x, converged, msg
+                #Linear solve failed:
+                mu *= nu #increase mu
+                nu = 2*nu
+
+            jtj[idiag] = undampled_JTJ_diag #restore diagonal for next inner loop iter
+        #end of inner loop
+    #end of outer loop
+    else:
+        #if no break stmt hit, then we've exceeded max_iter
+        msg = "Maximum iterations (%d) exceeded" % max_iter
+
+    return x, converged, msg
+"""

pygsti/optimize/customsolve.py

@@ -13,7 +13,7 @@ A custom MPI-enabled linear solver.
 import numpy as _np
 import scipy as _scipy
 
-from pygsti.optimize.arraysinterface import UndistributedArraysInterface as _UndistributedArraysInterface
+from pygsti.optimize.arraysinterface import DistributedArraysInterface as _DistributedArraysInterface
 from pygsti.tools import sharedmemtools as _smt
 from pygsti.tools import slicetools as _slct
 
@@ -90,7 +90,7 @@ def custom_solve(a, b, x, ari, resource_alloc, proc_threshold=100):
     host_comm = resource_alloc.host_comm
     ok_buf = _np.empty(1, _np.int64)
 
-    if comm is None or isinstance(ari, _UndistributedArraysInterface):
+    if comm is None or (not isinstance(ari, _DistributedArraysInterface)):
         x[:] = _scipy.linalg.solve(a, b, assume_a='pos')
         return
 

pygsti/optimize/optimize.py

@@ -662,90 +662,6 @@ def _fmin_evolutionary(f, x0, num_generations, num_individuals, printer):
     return solution
 
 
-#def fmin_homebrew(f, x0, maxiter):
-#    """
-#    Cooked up by Erik, this algorithm is similar to basinhopping but with some tweaks.
-#
-#    Parameters
-#    ----------
-#    fn : function
-#        The function to minimize.
-#
-#    x0 : numpy array
-#        The starting point (argument to fn).
-#
-#    maxiter : int
-#        The maximum number of iterations.
-#
-#    Returns
-#    -------
-#    scipy.optimize.Result object
-#        Includes members 'x', 'fun', 'success', and 'message'.
-#    """
-#
-#    STEP = 0.01
-#    MAX_STEPS = int(2.0 / STEP) # allow a change of at most 2.0
-#    MAX_DIR_TRIES = 1000
-#    T = 1.0
-#
-#    global_best_params = cur_x0 = x0
-#    global_best = cur_f = f(x0)
-#    N = len(x0)
-#    trial_x0 = x0.copy()
-#
-#    for it in range(maxiter):
-#
-#        #Minimize using L-BFGS-B
-#        opts = {'maxiter': maxiter, 'maxfev': maxiter, 'disp': False }
-#        soln = _spo.minimize(f,trial_x0,options=opts, method='L-BFGS-B',callback=None, tol=1e-8)
-#
-#        # Update global best
-#        if soln.fun < global_best:
-#            global_best_params = soln.x
-#            global_best = soln.fun
-#
-#        #check if we accept the new minimum
-#        if soln.fun < cur_f or _np.random.random() < _np.exp( -(soln.fun - cur_f)/T ):
-#            cur_x0 = soln.x; cur_f = soln.fun
-#            print "Iter %d: f=%g accepted -- global best = %g" % (it, cur_f, global_best)
-#        else:
-#            print "Iter %d: f=%g declined" % (it, cur_f)
-#
-#        trial_x0 = None; numTries = 0
-#        while trial_x0 is None and numTries < MAX_DIR_TRIES:
-#            #choose a random direction
-#            direction = _np.random.random( N )
-#            numTries += 1
-#
-#            #print "DB: test dir %d" % numTries #DEBUG
-#
-#            #kick solution along random direction until the value of f starts to get smaller again (if it ever does)
-#            #  (this indicates we've gone over a maximum along this direction)
-#            last_f = cur_f
-#            for i in range(1,MAX_STEPS):
-#                test_x = cur_x0 + i*STEP * direction
-#                test_f = f(test_x)
-#                #print "DB: test step=%f: f=%f" % (i*STEP, test_f)
-#                if test_f < last_f:
-#                    trial_x0 = test_x
-#                    print "Found new direction in %d tries, new f(x0) = %g" % (numTries,test_f)
-#                    break
-#                last_f = test_f
-#
-#        if trial_x0 is None:
-#            raise ValueError("Maximum number of direction tries exceeded")
-#
-#    solution = _optResult()
-#    solution.x = global_best_params; solution.fun = global_best
-#    solution.success = True
-##    if it < maxiter:
-##        solution.success = True
-##    else:
-##        solution.success = False
-##        solution.message = "Maximum iterations exceeded"
-#    return solution
-
-
 def create_objfn_printer(obj_func, start_time=None):
     """
     Create a callback function that prints the value of an objective function.