first success with PADM

examples/bilevel-optimization/padm.example.cpp

@@ -6,7 +6,8 @@
 #include <idol/modeling/bilevel-optimization/LowerLevelDescription.h>
 #include <idol/modeling/models/KKT.h>
 #include <idol/optimizers/mixed-integer-optimization/wrappers/Gurobi/Gurobi.h>
-#include "idol/optimizers/mixed-integer-optimization/padm/PADM.h"
+#include "idol/optimizers/mixed-integer-optimization/padm/AlternatingDirectionMethod.h"
+#include "idol/optimizers/mixed-integer-optimization/padm/SubProblem.h"
 
 int main(int t_argc, const char** t_argv) {
 
@@ -40,17 +41,25 @@ int main(int t_argc, const char** t_argv) {
         var.set(decomposition, var.id() == delta.id());
     }
 
+    Annotation<Ctr, bool> penalize(env, "penalize");
+    for (const auto& ctr : single_level.ctrs()) {
+        ctr.set(penalize, true);
+    }
+
     single_level.use(
-        PADM(decomposition)
-            .with_default_sub_problem_spec(
-                PADM::SubProblem()
-                    .with_optimizer(Gurobi())
-            )
+            AlternatingDirectionMethod(decomposition)
+                .with_penalization(penalize)
+                .with_default_sub_problem_spec(
+            AlternatingDirection::SubProblem()
+                            .with_optimizer(Gurobi())
+                )
     );
 
     single_level.optimize();
 
-    //std::cout << save_primal(single_level) << std::endl;
+    std::cout << single_level.get_status() << std::endl;
+
+    std::cout << save_primal(single_level) << std::endl;
 
     return 0;
 }

lib/CMakeLists.txt

@@ -250,8 +250,14 @@ add_library(idol STATIC
         src/optimizers/robust-optimization/convexification/Convexification.cpp
         include/idol/modeling/models/KKT.h
         src/modeling/models/KKT.cpp
-        include/idol/optimizers/mixed-integer-optimization/padm/PADM.cpp
-        include/idol/optimizers/mixed-integer-optimization/padm/PADM.h
+        include/idol/optimizers/mixed-integer-optimization/padm/AlternatingDirectionMethod.cpp
+        include/idol/optimizers/mixed-integer-optimization/padm/AlternatingDirectionMethod.h
+        include/idol/optimizers/mixed-integer-optimization/padm/Optimizers_AlternatingDirectionMethod.cpp
+        include/idol/optimizers/mixed-integer-optimization/padm/Optimizers_AlternatingDirectionMethod.h
+        include/idol/optimizers/mixed-integer-optimization/padm/Formulation.cpp
+        include/idol/optimizers/mixed-integer-optimization/padm/Formulation.h
+        include/idol/optimizers/mixed-integer-optimization/padm/SubProblem.cpp
+        include/idol/optimizers/mixed-integer-optimization/padm/SubProblem.h
 )
 
 find_package(OpenMP REQUIRED)

lib/include/idol/optimizers/mixed-integer-optimization/padm/AlternatingDirectionMethod.cpp

@@ -0,0 +1,78 @@
+//
+// Created by henri on 18.09.24.
+//
+
+#include "AlternatingDirectionMethod.h"
+#include "Optimizers_AlternatingDirectionMethod.h"
+
+idol::AlternatingDirectionMethod::AlternatingDirectionMethod(idol::Annotation<idol::Var, unsigned int> t_decomposition)
+        : m_decomposition(t_decomposition) {
+
+}
+
+idol::AlternatingDirectionMethod &idol::AlternatingDirectionMethod::with_default_sub_problem_spec(idol::AlternatingDirection::SubProblem t_sub_problem) {
+
+    if (m_default_sub_problem_spec) {
+        throw Exception("The default sub-problem has already been set.");
+    }
+
+    m_default_sub_problem_spec = std::move(t_sub_problem);
+
+    return *this;
+
+}
+
+idol::Optimizer *idol::AlternatingDirectionMethod::operator()(const idol::Model &t_model) const {
+
+    if (!m_decomposition) {
+        throw Exception("The decomposition has not been set.");
+    }
+
+    AlternatingDirection::Formulation formulation(t_model,
+                                                  *m_decomposition,
+                                                  m_penalized_constraints);
+
+    // create sub-problems specs
+    auto sub_problem_specs = create_sub_problem_specs(t_model, formulation);
+
+    auto* result = new Optimizers::AlternatingDirectionMethod(
+                t_model,
+                std::move(formulation),
+                std::move(sub_problem_specs)
+            );
+
+    handle_default_parameters(result);
+
+    return result;
+}
+
+idol::OptimizerFactory *idol::AlternatingDirectionMethod::clone() const {
+    return new AlternatingDirectionMethod(*this);
+}
+
+idol::AlternatingDirectionMethod &
+idol::AlternatingDirectionMethod::with_penalization(const idol::Annotation<idol::Ctr, bool>& t_penalized_constraints) {
+
+    if (m_penalized_constraints) {
+        throw Exception("The penalized constraints have already been set.");
+    }
+
+    m_penalized_constraints = t_penalized_constraints;
+
+    return *this;
+}
+
+std::vector<idol::AlternatingDirection::SubProblem>
+idol::AlternatingDirectionMethod::create_sub_problem_specs(const idol::Model &t_model,
+                                                           const idol::AlternatingDirection::Formulation &t_formulation) const {
+
+    const unsigned int n_sub_problem = t_formulation.n_sub_problems();
+
+    auto result = std::vector<AlternatingDirection::SubProblem>(n_sub_problem, *m_default_sub_problem_spec);
+
+    for (const auto& [sub_problem_id, sub_problem_spec] : m_sub_problem_specs) {
+        result[sub_problem_id] = AlternatingDirection::SubProblem(sub_problem_spec);
+    }
+
+    return result;
+}

lib/include/idol/optimizers/mixed-integer-optimization/padm/AlternatingDirectionMethod.h

@@ -0,0 +1,47 @@
+//
+// Created by henri on 18.09.24.
+//
+
+#ifndef IDOL_ALTERNATINGDIRECTIONMETHOD_H
+#define IDOL_ALTERNATINGDIRECTIONMETHOD_H
+
+#include "idol/optimizers/OptimizerFactory.h"
+#include "idol/modeling/annotations/Annotation.h"
+#include "idol/containers/Map.h"
+#include "SubProblem.h"
+#include "Formulation.h"
+#include <optional>
+
+namespace idol {
+    class AlternatingDirectionMethod;
+}
+
+class idol::AlternatingDirectionMethod : public OptimizerFactoryWithDefaultParameters<AlternatingDirectionMethod> {
+public:
+    explicit AlternatingDirectionMethod(Annotation<Var, unsigned int> t_decomposition);
+
+    AlternatingDirectionMethod(const AlternatingDirectionMethod& t_src) = default;
+    AlternatingDirectionMethod(AlternatingDirectionMethod&&) = default;
+
+    AlternatingDirectionMethod& operator=(const AlternatingDirectionMethod&) = default;
+    AlternatingDirectionMethod& operator=(AlternatingDirectionMethod&&) = default;
+
+    AlternatingDirectionMethod& with_default_sub_problem_spec(AlternatingDirection::SubProblem t_sub_problem);
+
+    AlternatingDirectionMethod& with_penalization(const Annotation<Ctr, bool>& t_penalized_constraints);
+
+    Optimizer *operator()(const Model &t_model) const override;
+
+    OptimizerFactory *clone() const override;
+
+private:
+    std::optional<Annotation<Var, unsigned int>> m_decomposition;
+    std::optional<Annotation<Ctr, bool>> m_penalized_constraints;
+    std::optional<AlternatingDirection::SubProblem> m_default_sub_problem_spec;
+    Map<unsigned int, AlternatingDirection::SubProblem> m_sub_problem_specs;
+
+    std::vector<AlternatingDirection::SubProblem> create_sub_problem_specs(const Model& t_model, const AlternatingDirection::Formulation& t_formulation) const;
+};
+
+
+#endif //IDOL_ALTERNATINGDIRECTIONMETHOD_H