Added versions of find_min_box_constrained() and find_max_box_constrained()

that allow you to easily set uniform upper and lower bounds.

dlib/optimization/optimization.h

@@ -514,6 +514,35 @@ namespace dlib
         return f_value;
     }
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename search_strategy_type,
+        typename stop_strategy_type,
+        typename funct, 
+        typename funct_der, 
+        typename T
+        >
+    double find_min_box_constrained (
+        search_strategy_type search_strategy,
+        stop_strategy_type stop_strategy,
+        const funct& f, 
+        const funct_der& der, 
+        T& x,
+        double x_lower,
+        double x_upper
+    )
+    {
+        typedef typename T::type scalar_type;
+        return find_min_box_constrained(search_strategy,
+                                        stop_strategy,
+                                        f,
+                                        der,
+                                        x,
+                                        uniform_matrix<scalar_type>(x.size(),1,x_lower),
+                                        uniform_matrix<scalar_type>(x.size(),1,x_upper) );
+    }
+
 // ----------------------------------------------------------------------------------------
 
     template <
@@ -600,6 +629,35 @@ namespace dlib
         return -f_value;
     }
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename search_strategy_type,
+        typename stop_strategy_type,
+        typename funct, 
+        typename funct_der, 
+        typename T
+        >
+    double find_max_box_constrained (
+        search_strategy_type search_strategy,
+        stop_strategy_type stop_strategy,
+        const funct& f, 
+        const funct_der& der, 
+        T& x,
+        double x_lower,
+        double x_upper
+    )
+    {
+        typedef typename T::type scalar_type;
+        return find_max_box_constrained(search_strategy,
+                                        stop_strategy,
+                                        f,
+                                        der,
+                                        x,
+                                        uniform_matrix<scalar_type>(x.size(),1,x_lower),
+                                        uniform_matrix<scalar_type>(x.size(),1,x_upper) );
+    }
+
 // ----------------------------------------------------------------------------------------
 
 }

dlib/optimization/optimization_abstract.h

@@ -332,6 +332,43 @@ namespace dlib
               the box constraints defined by x_lower and x_upper.
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename search_strategy_type,
+        typename stop_strategy_type,
+        typename funct, 
+        typename funct_der, 
+        typename T
+        >
+    double find_min_box_constrained (
+        search_strategy_type search_strategy,
+        stop_strategy_type stop_strategy,
+        const funct& f, 
+        const funct_der& der, 
+        T& x,
+        const double x_lower,
+        const double x_upper
+    );
+    /*!
+        requires
+            - search_strategy == an object that defines a search strategy such as one 
+              of the objects from dlib/optimization/optimization_search_strategies_abstract.h
+            - stop_strategy == an object that defines a stop strategy such as one of 
+              the objects from dlib/optimization/optimization_stop_strategies_abstract.h
+            - f(x) must be a valid expression that evaluates to a double
+            - der(x) must be a valid expression that evaluates to the derivative of f() at x.
+            - is_col_vector(x) == true
+            - x_lower < x_upper
+        ensures
+            - This function is identical to find_min_box_constrained() as defined above
+              except that it takes x_lower and x_upper as doubles rather than column
+              vectors.  In this case, all variables have the same lower bound of x_lower
+              and similarly have the same upper bound of x_upper.  Therefore, this is just
+              a convenience function for calling find_max_box_constrained() when all
+              variables have the same bound constraints.
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
     template <
@@ -390,6 +427,45 @@ namespace dlib
               value.
     !*/
 
+// ----------------------------------------------------------------------------------------
+    
+    template <
+        typename search_strategy_type,
+        typename stop_strategy_type,
+        typename funct, 
+        typename funct_der, 
+        typename T
+        >
+    double find_max_box_constrained (
+        search_strategy_type search_strategy,
+        stop_strategy_type stop_strategy,
+        const funct& f, 
+        const funct_der& der, 
+        T& x,
+        const double x_lower,
+        const double x_upper
+    );
+    /*!
+        requires
+            - search_strategy == an object that defines a search strategy such as one 
+              of the objects from dlib/optimization/optimization_search_strategies_abstract.h
+            - stop_strategy == an object that defines a stop strategy such as one of 
+              the objects from dlib/optimization/optimization_stop_strategies_abstract.h
+            - f(x) must be a valid expression that evaluates to a double
+            - der(x) must be a valid expression that evaluates to the derivative of f() at x.
+            - is_col_vector(x) == true
+            - x_lower < x_upper
+        ensures
+            - This function is identical to find_max_box_constrained() as defined above
+              except that it takes x_lower and x_upper as doubles rather than column
+              vectors.  In this case, all variables have the same lower bound of x_lower
+              and similarly have the same upper bound of x_upper.  Therefore, this is just
+              a convenience function for calling find_max_box_constrained() when all
+              variables have the same bound constraints.
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
 }
 
 #endif // DLIB_OPTIMIZATIOn_ABSTRACT_

dlib/test/optimization.cpp

@@ -1037,6 +1037,14 @@ namespace
             lower = rnd.get_random_double()+1, rnd.get_random_double()+1;
             lower = upper - lower;
         }
+        const bool pick_uniform_bounds = rnd.get_random_double() > 0.9;
+        if (pick_uniform_bounds)
+        {
+            double x = rnd.get_random_gaussian()*2;
+            double y = rnd.get_random_gaussian()*2;
+            lower = min(x,y);
+            upper = max(x,y);
+        }
 
         starting_point = rnd.get_random_double()*(upper(0)-lower(0))+lower(0), 
                        rnd.get_random_double()*(upper(1)-lower(1))+lower(1);
@@ -1046,13 +1054,28 @@ namespace
         dlog << LINFO << "starting: "<< trans(starting_point);
 
         x = starting_point;
-        double val = find_min_box_constrained( 
+        double val;
+        if (!pick_uniform_bounds)
+        {
+            val = find_min_box_constrained( 
                 search_strategy,
                 objective_delta_stop_strategy(1e-16, 500), 
                 rosen, der_rosen, x,
                 lower,  
                 upper   
             );
+        }
+        else
+        {
+            val = find_min_box_constrained( 
+                search_strategy,
+                objective_delta_stop_strategy(1e-16, 500), 
+                rosen, der_rosen, x,
+                lower(0),  
+                upper(0)   
+            );
+        }
+
 
         DLIB_TEST(std::abs(val - rosen(x)) < 1e-14);
         dlog << LINFO << "rosen solution:\n" << x;