Remove unneeded extern "C".

[simgrid.git] / src / kernel / lmm / lagrange.cpp

diff --git a/src/kernel/lmm/lagrange.cpp b/src/kernel/lmm/lagrange.cpp
index 98b6fd2..17fe3d0 100644 (file)
--- a/src/kernel/lmm/lagrange.cpp
+++ b/src/kernel/lmm/lagrange.cpp
@@ -8,6 +8,7 @@
  * "ssh://username@scm.gforge.inria.fr/svn/memo/people/pvelho/lagrange/ppf.ps".
  */
 #include "src/kernel/lmm/maxmin.hpp"
+#include "src/surf/surf_interface.hpp"
 #include "xbt/log.h"
 #include "xbt/sysdep.h"
 
@@ -26,23 +27,11 @@ namespace simgrid {
 namespace kernel {
 namespace lmm {
 
-double (*func_f_def)(const Variable&, double);
-double (*func_fp_def)(const Variable&, double);
-double (*func_fpi_def)(const Variable&, double);
-
 System* make_new_lagrange_system(bool selective_update)
 {
   return new Lagrange(selective_update);
 }
 
-/*
- * Local prototypes to implement the Lagrangian optimization with optimal step, also called dichotomy.
- */
-// computes the value of the dichotomy using a initial values, init, with a specific variable or constraint
-static double dichotomy(double init, double diff(double, const Constraint&), const Constraint& cnst, double min_error);
-// computes the value of the differential of constraint cnst applied to lambda
-static double partial_diff_lambda(double lambda, const Constraint& cnst);
-
 bool Lagrange::check_feasible(bool warn)
 {
   for (Constraint const& cnst : active_constraint_set) {
@@ -77,7 +66,7 @@ bool Lagrange::check_feasible(bool warn)
   return true;
 }
 
-static double new_value(const Variable& var)
+double Lagrange::new_value(const Variable& var)
 {
   double tmp = 0;
 
@@ -88,10 +77,10 @@ static double new_value(const Variable& var)
     tmp += var.mu;
   XBT_DEBUG("\t Working on var (%p). cost = %e; Weight = %e", &var, tmp, var.sharing_weight);
   // uses the partial differential inverse function
-  return var.func_fpi(var, tmp);
+  return func_fpi(var, tmp);
 }
 
-static double new_mu(const Variable& var)
+double Lagrange::new_mu(const Variable& var)
 {
   double mu_i    = 0.0;
   double sigma_i = 0.0;
@@ -99,7 +88,7 @@ static double new_mu(const Variable& var)
   for (Element const& elem : var.cnsts) {
     sigma_i += elem.constraint->lambda;
   }
-  mu_i = var.func_fp(var, var.bound) - sigma_i;
+  mu_i = func_fp(var, var.bound) - sigma_i;
   if (mu_i < 0.0)
     return 0.0;
   return mu_i;
@@ -123,7 +112,7 @@ double Lagrange::dual_objective()
 
     XBT_DEBUG("var %p : sigma_i = %1.20f", &var, sigma_i);
 
-    obj += var.func_f(var, var.func_fpi(var, sigma_i)) - sigma_i * var.func_fpi(var, sigma_i);
+    obj += func_f(var, func_fpi(var, sigma_i)) - sigma_i * func_fpi(var, sigma_i);
 
     if (var.bound > 0)
       obj += var.mu * var.bound;
@@ -154,22 +143,20 @@ void Lagrange::lagrange_solve()
     print();
   }
 
-  if (not modified)
+  if (not modified_)
     return;
 
   /* Initialize lambda. */
-  auto& cnst_list = active_constraint_set;
-  for (Constraint& cnst : cnst_list) {
+  for (Constraint& cnst : active_constraint_set) {
     cnst.lambda     = 1.0;
     cnst.new_lambda = 2.0;
     XBT_DEBUG("#### cnst(%p)->lambda :  %e", &cnst, cnst.lambda);
   }
 
   /*
-   * Initialize the var_list variable with only the active variables. Initialize mu.
+   * Initialize the active variables. Initialize mu.
    */
-  auto& var_list = variable_set;
-  for (Variable& var : var_list) {
+  for (Variable& var : variable_set) {
     if (not var.sharing_weight)
       var.value = 0.0;
     else {
@@ -203,7 +190,7 @@ void Lagrange::lagrange_solve()
     XBT_DEBUG("-------------- Gradient Descent ----------");
 
     /* Improve the value of mu_i */
-    for (Variable& var : var_list) {
+    for (Variable& var : variable_set) {
       if (var.sharing_weight && var.bound >= 0) {
         XBT_DEBUG("Working on var (%p)", &var);
         var.new_mu = new_mu(var);
@@ -218,7 +205,7 @@ void Lagrange::lagrange_solve()
     }
 
     /* Improve the value of lambda_i */
-    for (Constraint& cnst : cnst_list) {
+    for (Constraint& cnst : active_constraint_set) {
       XBT_DEBUG("Working on cnst (%p)", &cnst);
       cnst.new_lambda = dichotomy(cnst.lambda, partial_diff_lambda, cnst, dichotomy_min_error);
       XBT_DEBUG("Updating lambda : cnst->lambda (%p) : %1.20f -> %1.20f", &cnst, cnst.lambda, cnst.new_lambda);
@@ -233,7 +220,7 @@ void Lagrange::lagrange_solve()
     /* Now computes the values of each variable (\rho) based on the values of \lambda and \mu. */
     XBT_DEBUG("-------------- Check convergence ----------");
     overall_modification = 0;
-    for (Variable& var : var_list) {
+    for (Variable& var : variable_set) {
       if (var.sharing_weight <= 0)
         var.value = 0.0;
       else {
@@ -277,7 +264,8 @@ void Lagrange::lagrange_solve()
  *
  * @return a double corresponding to the result of the dichotomy process
  */
-static double dichotomy(double init, double diff(double, const Constraint&), const Constraint& cnst, double min_error)
+double Lagrange::dichotomy(double init, double diff(double, const Constraint&), const Constraint& cnst,
+                           double min_error)
 {
   double min = init;
   double max = init;
@@ -377,7 +365,7 @@ static double dichotomy(double init, double diff(double, const Constraint&), con
   return ((min + max) / 2.0);
 }
 
-static double partial_diff_lambda(double lambda, const Constraint& cnst)
+double Lagrange::partial_diff_lambda(double lambda, const Constraint& cnst)
 {
   double diff           = 0.0;
 
@@ -403,7 +391,7 @@ static double partial_diff_lambda(double lambda, const Constraint& cnst)
     // replace value of cnst.lambda by the value of parameter lambda
     sigma_i = (sigma_i - cnst.lambda) + lambda;
 
-    diff += -var.func_fpi(var, sigma_i);
+    diff += -func_fpi(var, sigma_i);
   }
 
   diff += cnst.bound;
@@ -417,19 +405,21 @@ static double partial_diff_lambda(double lambda, const Constraint& cnst)
  *
  *  \param func_fpi  inverse of the partial differential of f (f prime inverse, (f')^{-1})
  *
- *  Set default functions to the ones passed as parameters. This is a polymorphism in C pure, enjoy the roots of
- *  programming.
- *
+ *  Set default functions to the ones passed as parameters.
  */
-void set_default_protocol_function(double (*func_f)(const Variable& var, double x),
-                                   double (*func_fp)(const Variable& var, double x),
-                                   double (*func_fpi)(const Variable& var, double x))
+void Lagrange::set_default_protocol_function(double (*func_f)(const Variable& var, double x),
+                                             double (*func_fp)(const Variable& var, double x),
+                                             double (*func_fpi)(const Variable& var, double x))
 {
-  func_f_def   = func_f;
-  func_fp_def  = func_fp;
-  func_fpi_def = func_fpi;
+  Lagrange::func_f   = func_f;
+  Lagrange::func_fp  = func_fp;
+  Lagrange::func_fpi = func_fpi;
 }
 
+double (*Lagrange::func_f)(const Variable&, double);
+double (*Lagrange::func_fp)(const Variable&, double);
+double (*Lagrange::func_fpi)(const Variable&, double);
+
 /**************** Vegas and Reno functions *************************/
 /* NOTE for Reno: all functions consider the network coefficient (alpha) equal to 1. */