add interface for Bilevel::PessimisticAsOptimistic

hlefebvr · Feb 20, 2025 · d2adc0f · d2adc0f
1 parent d0ae88d
commit d2adc0f
Show file tree

Hide file tree

Showing 4 changed files with 76 additions and 12 deletions.
diff --git a/examples/robust/ccg-discrete-uncertainty.example.cpp b/examples/robust/ccg-discrete-uncertainty.example.cpp
@@ -27,6 +27,7 @@
 #include "idol/mixed-integer/optimizers/padm/PenaltyUpdates.h"
 #include "idol/bilevel/optimizers/StrongDuality/StrongDuality.h"
 #include "idol/mixed-integer/optimizers/padm/PADM.h"
+#include "idol/bilevel/optimizers/PessimisticAsOptimistic/PessimisticAsOptimistic.h"
 
 using namespace idol;
 
@@ -130,16 +131,17 @@ int main(int t_argc, const char** t_argv) {
 
     model.use(
             Robust::ColumnAndConstraintGeneration(robust_description, bilevel_description)
-                    //.with_initial_scenario_by_maximization(Gurobi())
-                    //.with_initial_scenario_by_minimization(Gurobi())
+
+                    .with_initial_scenario_by_maximization(Gurobi())
+                    .with_initial_scenario_by_minimization(Gurobi())
 
                     .with_master_optimizer(Gurobi())
 
                     .add_feasibility_separation_optimizer(padm)
-                    .add_feasibility_separation_optimizer(mibs)
+                    .add_feasibility_separation_optimizer(Bilevel::PessimisticAsOptimistic() + mibs)
 
                     .add_optimality_separation_optimizer(padm)
-                    .add_optimality_separation_optimizer(mibs)
+                    .add_optimality_separation_optimizer(Bilevel::PessimisticAsOptimistic() + mibs)
                     .with_logs(true)
     );
     model.optimize();

diff --git a/lib/include/idol/bilevel/optimizers/PessimisticAsOptimistic/PessimisticAsOptimistic.h b/lib/include/idol/bilevel/optimizers/PessimisticAsOptimistic/PessimisticAsOptimistic.h
@@ -7,17 +7,43 @@
 
 #include "idol/general/optimizers/OptimizerFactory.h"
 #include "idol/bilevel/modeling/Description.h"
+#include "idol/bilevel/optimizers/BilevelOptimizerInterface.h"
 
 namespace idol::Bilevel {
     class PessimisticAsOptimistic;
 }
 
-class idol::Bilevel::PessimisticAsOptimistic : public OptimizerFactoryWithDefaultParameters<PessimisticAsOptimistic> {
-    //const Bilevel::Description &m_robust_description;
-    //std::unique_ptr<OptimizerFactory> m_single_level_optimizer;
+class idol::Bilevel::PessimisticAsOptimistic : public OptimizerFactoryWithDefaultParameters<PessimisticAsOptimistic>, public Bilevel::OptimizerInterface {
+    const Bilevel::Description* m_description = nullptr;
+    std::unique_ptr<OptimizerFactory> m_optimistic_bilevel_optimizer;
 public:
+    PessimisticAsOptimistic() = default;
+
+    explicit PessimisticAsOptimistic(const Bilevel::Description& t_description);
+
+    PessimisticAsOptimistic(const PessimisticAsOptimistic& t_src);
+
+    PessimisticAsOptimistic& with_optimistic_bilevel_optimizer(const OptimizerFactory& t_optimizer);
+
+    PessimisticAsOptimistic& operator+=(const OptimizerFactory& t_optimizer) {
+        return with_optimistic_bilevel_optimizer(t_optimizer);
+    }
+
+    void set_bilevel_description(const Description &t_bilevel_description) override;
+
+    Optimizer *operator()(const Model &t_model) const override;
+
+    [[nodiscard]] OptimizerFactory *clone() const override;
 
     static std::pair<Model, Bilevel::Description> make_model(const Model &t_model, const Bilevel::Description &t_description);
 };
 
+namespace idol {
+    static Bilevel::PessimisticAsOptimistic operator+(const Bilevel::PessimisticAsOptimistic& t_pessimistic_as_optimistic, const OptimizerFactory& t_optimizer) {
+        Bilevel::PessimisticAsOptimistic result(t_pessimistic_as_optimistic);
+        result += t_optimizer;
+        return result;
+    }
+}
+
 #endif //IDOL_PESSIMISTICASOPTIMISTIC_H
diff --git a/lib/src/bilevel/optimizers/PessimisticAsOptimistic/PessimisticAsOptimistic.cpp b/lib/src/bilevel/optimizers/PessimisticAsOptimistic/PessimisticAsOptimistic.cpp
@@ -166,3 +166,39 @@ idol::Bilevel::PessimisticAsOptimistic::make_model(const Model &t_model, const B
     };
 }
 
+void idol::Bilevel::PessimisticAsOptimistic::set_bilevel_description(const idol::Bilevel::Description &t_bilevel_description) {
+    m_description = &t_bilevel_description;
+}
+
+idol::Optimizer *idol::Bilevel::PessimisticAsOptimistic::operator()(const idol::Model &t_model) const {
+    throw Exception("Not implemented.");
+}
+
+idol::OptimizerFactory *idol::Bilevel::PessimisticAsOptimistic::clone() const {
+    return new PessimisticAsOptimistic(*this);
+}
+
+idol::Bilevel::PessimisticAsOptimistic &idol::Bilevel::PessimisticAsOptimistic::with_optimistic_bilevel_optimizer(const idol::OptimizerFactory &t_optimizer) {
+
+    if (m_optimistic_bilevel_optimizer) {
+        throw Exception("Single level optimizer already set.");
+    }
+
+    if (!t_optimizer.is<Bilevel::OptimizerInterface>()) {
+        throw Exception("The optimistic optimizer must be a Bilevel::OptimizerInterface.");
+    }
+
+    m_optimistic_bilevel_optimizer.reset(t_optimizer.clone());
+
+    return *this;
+}
+
+idol::Bilevel::PessimisticAsOptimistic::PessimisticAsOptimistic(const idol::Bilevel::Description &t_description)
+    :
+    OptimizerFactoryWithDefaultParameters<PessimisticAsOptimistic>(),
+    m_description(&t_description) {}
+
+idol::Bilevel::PessimisticAsOptimistic::PessimisticAsOptimistic(const idol::Bilevel::PessimisticAsOptimistic &t_src)
+    : OptimizerFactoryWithDefaultParameters<PessimisticAsOptimistic>(t_src),
+      m_optimistic_bilevel_optimizer(t_src.m_optimistic_bilevel_optimizer ? t_src.m_optimistic_bilevel_optimizer->clone() : nullptr),
+      m_description(t_src.m_description) {}
diff --git a/.../optimizers/column-and-constraint-generation/Optimizers_ColumnAndConstraintGeneration.cpp b/.../optimizers/column-and-constraint-generation/Optimizers_ColumnAndConstraintGeneration.cpp
@@ -337,13 +337,13 @@ void idol::Optimizers::Robust::ColumnAndConstraintGeneration::log_iteration(
         }
     }
 
-    std::cout << std::setw(12) << time().count() << "s\t"
+    std::cout << std::setw(12) << pretty_double(time().count(), 5) << "s\t"
               << std::setw(5) << m_n_iterations << "\t"
               << std::setw(5) << m_formulation->n_added_scenarios() << "\t"
-              << std::setw(12) << get_best_bound() << "\t"
-              << std::setw(12) << get_best_obj() << "\t"
-              << std::setw(12) << get_relative_gap() * 100 << "\t"
-              << std::setw(12) << get_absolute_gap() << "\t"
+              << std::setw(12) << pretty_double(get_best_bound(), 5) << "\t"
+              << std::setw(12) << pretty_double(get_best_obj(), 5) << "\t"
+              << std::setw(12) << pretty_double(get_relative_gap() * 100, 5) << "\t"
+              << std::setw(12) << pretty_double(get_absolute_gap(), 5) << "\t"
               << std::setw(35) << master_status.str() << "\t"
               << std::setw(35) << separation_status.str() << "\t"
               << std::setw(8) << separation_outcome.str()