added test

Author: Teseo Schneider

non-linear-solver-spec.json

@@ -190,6 +190,9 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "Newton",
+        "required": [
+            "type"
+        ],
         "optional": [
             "residual_tolerance"
         ],
@@ -199,6 +202,9 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "ProjectedNewton",
+        "required": [
+            "type"
+        ],
         "optional": [
             "residual_tolerance"
         ],
@@ -208,6 +214,9 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "RegularizedNewton",
+        "required": [
+            "type"
+        ],
         "optional": [
             "residual_tolerance",
             "reg_weight_min",
@@ -220,6 +229,9 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "DenseNewton",
+        "required": [
+            "type"
+        ],
         "optional": [
             "residual_tolerance"
         ],
@@ -229,6 +241,9 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "DenseProjectedNewton",
+        "required": [
+            "type"
+        ],
         "optional": [
             "residual_tolerance"
         ],
@@ -238,6 +253,9 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "DenseRegularizedNewton",
+        "required": [
+            "type"
+        ],
         "optional": [
             "residual_tolerance",
             "reg_weight_min",
@@ -250,12 +268,18 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "GradientDescent",
+        "required": [
+            "type"
+        ],
         "doc": "Options for Gradient Descent."
     },
     {
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "StochasticGradientDescent",
+        "required": [
+            "type"
+        ],
         "optional": [
             "erase_component_probability"
         ],
@@ -265,8 +289,10 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "L-BFGS",
+        "required": [
+            "type"
+        ],
         "optional": [
-            "erase_component_probability",
             "history_size"
         ],
         "doc": "Options for L-BFGS."
@@ -275,11 +301,28 @@
         "pointer": "/solver/*",
         "type": "object",
         "type_name": "BFGS",
-        "optional": [
-            "erase_component_probability"
+        "required": [
+            "type"
         ],
         "doc": "Options for BFGS."
     },
+    {
+        "pointer": "/solver/*/type",
+        "type": "string",
+        "options": [
+            "Newton",
+            "DenseNewton",
+            "ProjectedNewton",
+            "DenseProjectedNewton",
+            "RegularizedNewton",
+            "DenseRegularizedNewton",
+            "GradientDescent",
+            "StochasticGradientDescent",
+            "L-BFGS",
+            "BFGS"
+        ],
+        "doc": "Nonlinear solver type"
+    },
     {
         "pointer": "/solver/*/residual_tolerance",
         "default": 1e-5,

src/polysolve/Utils.cpp

@@ -71,4 +71,12 @@ namespace polysolve
         return I;
     }
 
+    double extract_param(const std::string &key, const std::string &name, const json &json)
+    {
+        if (json.find(key) != json.end())
+            return json[key][name];
+
+        return json[name];
+    }
+
 } // namespace polysolve

src/polysolve/Utils.hpp

@@ -60,4 +60,6 @@ namespace polysolve
 
     Eigen::SparseMatrix<double> sparse_identity(int rows, int cols);
 
+    double extract_param(const std::string &key, const std::string &name, const json &json);
+
 } // namespace polysolve

src/polysolve/nonlinear/Solver.cpp

@@ -124,7 +124,7 @@ namespace polysolve::nonlinear
         {
             for (const auto &j : solver_params["solver"])
             {
-                const std::string solver_name = solver_params["type"];
+                const std::string solver_name = j["type"];
                 solver->add_strategy(crate_solver(solver_name, j, linear_solver_params, characteristic_length, logger));
             }
         }

src/polysolve/nonlinear/descent_strategies/GradientDescent.cpp

@@ -1,5 +1,7 @@
 #include "GradientDescent.hpp"
 
+#include <polysolve/Utils.hpp>
+
 namespace polysolve::nonlinear
 {
 
@@ -10,7 +12,7 @@ namespace polysolve::nonlinear
         : Superclass(solver_params_, characteristic_length, logger), is_stochastic_(is_stochastic)
     {
         if (is_stochastic_)
-            erase_component_probability_ = solver_params_["StochasticGradientDescent"]["erase_component_probability"];
+            erase_component_probability_ = extract_param("StochasticGradientDescent", "erase_component_probability", solver_params_);
     }
 
     bool GradientDescent::compute_update_direction(

src/polysolve/nonlinear/descent_strategies/LBFGS.cpp

@@ -2,6 +2,8 @@
 
 #include "LBFGS.hpp"
 
+#include <polysolve/Utils.hpp>
+
 namespace polysolve::nonlinear
 {
     LBFGS::LBFGS(const json &solver_params,
@@ -11,7 +13,7 @@ namespace polysolve::nonlinear
                      characteristic_length,
                      logger)
     {
-        m_history_size = solver_params["L-BFGS"]["history_size"];
+        m_history_size = extract_param("L-BFGS", "history_size", solver_params);
         if (m_history_size <= 0)
             log_and_throw_error(logger, "L-BFGS history_size must be >=1, instead got {}", m_history_size);
     }

src/polysolve/nonlinear/descent_strategies/Newton.cpp

@@ -1,5 +1,7 @@
 #include "Newton.hpp"
 
+#include <polysolve/Utils.hpp>
+
 namespace polysolve::nonlinear
 {
 
@@ -71,7 +73,7 @@ namespace polysolve::nonlinear
         const json &linear_solver_params,
         const double characteristic_length,
         spdlog::logger &logger)
-        : Newton(sparse, solver_params["Newton"]["residual_tolerance"], solver_params, linear_solver_params, characteristic_length, logger)
+        : Newton(sparse, extract_param("Newton", "residual_tolerance", solver_params), solver_params, linear_solver_params, characteristic_length, logger)
     {
     }
 
@@ -81,7 +83,7 @@ namespace polysolve::nonlinear
         const json &linear_solver_params,
         const double characteristic_length,
         spdlog::logger &logger)
-        : Superclass(sparse, solver_params["ProjectedNewton"]["residual_tolerance"], solver_params, linear_solver_params, characteristic_length, logger)
+        : Superclass(sparse, extract_param("ProjectedNewton", "residual_tolerance", solver_params), solver_params, linear_solver_params, characteristic_length, logger)
     {
     }
 
@@ -91,11 +93,11 @@ namespace polysolve::nonlinear
         const json &linear_solver_params,
         const double characteristic_length,
         spdlog::logger &logger)
-        : Superclass(sparse, solver_params["RegularizedNewton"]["residual_tolerance"], solver_params, linear_solver_params, characteristic_length, logger)
+        : Superclass(sparse, extract_param("RegularizedNewton", "residual_tolerance", solver_params), solver_params, linear_solver_params, characteristic_length, logger)
     {
-        reg_weight_min = solver_params["RegularizedNewton"]["reg_weight_min"];
-        reg_weight_max = solver_params["RegularizedNewton"]["reg_weight_max"];
-        reg_weight_inc = solver_params["RegularizedNewton"]["reg_weight_inc"];
+        reg_weight_min = extract_param("RegularizedNewton", "reg_weight_min", solver_params);
+        reg_weight_max = extract_param("RegularizedNewton", "reg_weight_max", solver_params);
+        reg_weight_inc = extract_param("RegularizedNewton", "reg_weight_inc", solver_params);
 
         reg_weight = reg_weight_min;
 

tests/test_nonlinear_solver.cpp

@@ -424,6 +424,65 @@ TEST_CASE("non-linear", "[solver]")
     // test_solvers({"L-BFGS"}, 1000, false);
 }
 
+TEST_CASE("non-linear-fallbacks", "[solver]")
+{
+    json solver_params = R"({"solver": [
+        {
+            "type": "Newton"
+        },
+        {
+            "type": "RegularizedNewton"
+        },
+        {
+            "type": "L-BFGS",
+            "history_size": 10
+        },
+        {
+            "type": "StochasticGradientDescent",
+            "erase_component_probability": 0.5
+        }
+    ]
+    })"_json;
+    json linear_solver_params;
+    linear_solver_params["solver"] = "Eigen::SimplicialLDLT";
+
+    const double characteristic_length = 1;
+
+    static std::shared_ptr<spdlog::logger> logger = spdlog::stdout_color_mt("test_logger");
+    logger->set_level(spdlog::level::info);
+    TestProblem::TVector g;
+    auto prob = std::make_unique<QuadraticProblem>();
+
+    TestProblem::TVector x(prob->size());
+    x.setZero();
+
+    std::cout << solver_params << std::endl;
+
+    for (int i = 0; i < N_RANDOM; ++i)
+    {
+        auto solver = Solver::create(solver_params,
+                                     linear_solver_params,
+                                     characteristic_length,
+                                     *logger);
+
+        solver->minimize(*prob, x);
+
+        double err = std::numeric_limits<double>::max();
+        for (auto sol : prob->solutions())
+            err = std::min(err, (x - sol).norm());
+        if (err >= 1e-7)
+        {
+            prob->gradient(x, g);
+            err = g.norm();
+        }
+        CHECK(err < 1e-7);
+        if (err >= 1e-7)
+            break;
+
+        x.setRandom();
+    }
+}
+
 TEST_CASE("non-linear-gradient-fd", "[solver]")
 {
     test_solvers_gradient_fd(false);