Merge pull request #1 from logangrado/feat/args

Feature: Added optional argument `args`

Author: lindonroberts

docs/userguide.rst

@@ -65,13 +65,14 @@ The :code:`solve` function has several optional arguments which the user may pro
 
   .. code-block:: python
   
-      pybobyqa.solve(objfun, x0, bounds=None, npt=None, rhobeg=None, 
-                  rhoend=1e-8, maxfun=None, nsamples=None, 
+      pybobyqa.solve(objfun, x0, args=(), bounds=None, npt=None,
+		  rhobeg=None, rhoend=1e-8, maxfun=None, nsamples=None, 
                   user_params=None, objfun_has_noise=False, 
                   scaling_within_bounds=False)
 
 These arguments are:
 
+* :code:`args` - a tuple of extra arguments passed to the objective function
 * :code:`bounds` - a tuple :code:`(lower, upper)` with the vectors :math:`a` and :math:`b` of lower and upper bounds on :math:`x` (default is :math:`a_i=-10^{20}` and :math:`b_i=10^{20}`). To set bounds for either :code:`lower` or :code:`upper`, but not both, pass a tuple :code:`(lower, None)` or :code:`(None, upper)`.
 * :code:`npt` - the number of interpolation points to use (default is :code:`2*len(x0)+1`). Py-BOBYQA requires :code:`n+1 <= npt <= (n+1)*(n+2)/2` for a problem with :code:`len(x0)=n`. Larger values are particularly useful for noisy problems.
 * :code:`rhobeg` - the initial value of the trust region radius (default is :math:`0.1\max(\|x_0\|_{\infty}, 1)`).

pybobyqa/controller.py

@@ -93,9 +93,10 @@ def able_to_do_restart(self):
 
 
 class Controller(object):
-    def __init__(self, objfun, x0, f0, f0_nsamples, xl, xu, npt, rhobeg, rhoend, nf, nx, maxfun, params, scaling_changes):
+    def __init__(self, objfun, x0, args, f0, f0_nsamples, xl, xu, npt, rhobeg, rhoend, nf, nx, maxfun, params, scaling_changes):
         self.objfun = objfun
         self.maxfun = maxfun
+        self.args = args
         self.model = Model(npt, x0, f0, xl, xu, f0_nsamples, abs_tol=params("model.abs_tol"),
                            precondition=params("interpolation.precondition"))
         self.nf = nf
@@ -341,7 +342,7 @@ def evaluate_objective(self, x, number_of_samples, params):
             if not incremented_nx:
                 self.nx += 1
                 incremented_nx = True
-            f_list[i] = eval_objective(self.objfun, remove_scaling(x, self.scaling_changes), eval_num=self.nf, pt_num=self.nx,
+            f_list[i] = eval_objective(self.objfun, remove_scaling(x, self.scaling_changes), self.args, eval_num=self.nf, pt_num=self.nx,
                                             full_x_thresh=params("logging.n_to_print_whole_x_vector"),
                                             check_for_overflow=params("general.check_objfun_for_overflow"))
             num_samples_run += 1

pybobyqa/solver.py

@@ -90,15 +90,15 @@ def __str__(self):
         return output
 
 
-def solve_main(objfun, x0, xl, xu, npt, rhobeg, rhoend, maxfun, nruns_so_far, nf_so_far, nx_so_far, nsamples, params,
+def solve_main(objfun, x0, args, xl, xu, npt, rhobeg, rhoend, maxfun, nruns_so_far, nf_so_far, nx_so_far, nsamples, params,
                diagnostic_info, scaling_changes, f0_avg_old=None, f0_nsamples_old=None):
     # Evaluate at x0 (keep nf, nx correct and check for f small)
     if f0_avg_old is None:
         number_of_samples = max(nsamples(rhobeg, rhobeg, 0, nruns_so_far), 1)
         # Evaluate the first time...
         nf = nf_so_far + 1
         nx = nx_so_far + 1
-        f0 = eval_objective(objfun, remove_scaling(x0, scaling_changes), eval_num=nf, pt_num=nx,
+        f0 = eval_objective(objfun, remove_scaling(x0, scaling_changes), args, eval_num=nf, pt_num=nx,
                                                 full_x_thresh=params("logging.n_to_print_whole_x_vector"),
                                               check_for_overflow=params("general.check_objfun_for_overflow"))
 
@@ -116,7 +116,7 @@ def solve_main(objfun, x0, xl, xu, npt, rhobeg, rhoend, maxfun, nruns_so_far, nf
 
             nf += 1
             # Don't increment nx for x0 - we did this earlier
-            f_list[i] = eval_objective(objfun, remove_scaling(x0, scaling_changes), eval_num=nf, pt_num=nx,
+            f_list[i] = eval_objective(objfun, remove_scaling(x0, scaling_changes), args, eval_num=nf, pt_num=nx,
                                                 full_x_thresh=params("logging.n_to_print_whole_x_vector"),
                                                 check_for_overflow=params("general.check_objfun_for_overflow"))
             num_samples_run += 1
@@ -136,7 +136,7 @@ def solve_main(objfun, x0, xl, xu, npt, rhobeg, rhoend, maxfun, nruns_so_far, nf
         nx = nx_so_far
 
     # Initialise controller
-    control = Controller(objfun, x0, f0_avg, num_samples_run, xl, xu, npt, rhobeg, rhoend, nf, nx, maxfun, params, scaling_changes)
+    control = Controller(objfun, x0, args, f0_avg, num_samples_run, xl, xu, npt, rhobeg, rhoend, nf, nx, maxfun, params, scaling_changes)
 
     # Initialise interpolation set
     number_of_samples = max(nsamples(control.delta, control.rho, 0, nruns_so_far), 1)
@@ -631,7 +631,7 @@ def solve_main(objfun, x0, xl, xu, npt, rhobeg, rhoend, maxfun, nruns_so_far, nf
     return x, f, gradmin, hessmin, nsamples, control.nf, control.nx, nruns_so_far, exit_info, diagnostic_info
 
 
-def solve(objfun, x0, bounds=None, npt=None, rhobeg=None, rhoend=1e-8, maxfun=None, nsamples=None, user_params=None,
+def solve(objfun, x0, args=(), bounds=None, npt=None, rhobeg=None, rhoend=1e-8, maxfun=None, nsamples=None, user_params=None,
           objfun_has_noise=False, scaling_within_bounds=False):
     n = len(x0)
 
@@ -765,7 +765,7 @@ def solve(objfun, x0, bounds=None, npt=None, rhobeg=None, rhoend=1e-8, maxfun=No
     nf = 0
     nx = 0
     xmin, fmin, gradmin, hessmin, nsamples_min, nf, nx, nruns, exit_info, diagnostic_info = \
-        solve_main(objfun, x0, xl, xu, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
+        solve_main(objfun, x0, args, xl, xu, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
                     diagnostic_info, scaling_changes)
 
     # Hard restarts loop
@@ -778,11 +778,11 @@ def solve(objfun, x0, bounds=None, npt=None, rhobeg=None, rhoend=1e-8, maxfun=No
                      % (fmin, nf, rhobeg, rhoend))
         if params("restarts.hard.use_old_fk"):
             xmin2, fmin2, gradmin2, hessmin2, nsamples2, nf, nx, nruns, exit_info, diagnostic_info = \
-                solve_main(objfun, xmin, xl, xu, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
+                solve_main(objfun, xmin, args, xl, xu, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
                             diagnostic_info, scaling_changes, f0_avg_old=fmin, f0_nsamples_old=nsamples_min)
         else:
             xmin2, fmin2, gradmin2, hessmin2, nsamples2, nf, nx, nruns, exit_info, diagnostic_info = \
-                solve_main(objfun, xmin, xl, xu, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
+                solve_main(objfun, xmin, args, xl, xu, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
                            diagnostic_info, scaling_changes)
 
         if fmin2 < fmin or np.isnan(fmin):

pybobyqa/util.py

@@ -44,15 +44,15 @@ def sumsq(x):
     return np.dot(x, x)
 
 
-def eval_objective(objfun, x, verbose=True, eval_num=0, pt_num=0, full_x_thresh=6, check_for_overflow=True):
+def eval_objective(objfun, x, args, verbose=True, eval_num=0, pt_num=0, full_x_thresh=6, check_for_overflow=True):
     # Evaluate objective function
     if check_for_overflow:
         try:
-            f = objfun(x)
+            f = objfun(x, *args)
         except OverflowError:
             f = sys.float_info.max
     else:
-        f = objfun(x)
+        f = objfun(x, *args)
 
     if verbose:
         if len(x) < full_x_thresh: