Merge from ReForm

NSolver/IPOPTSolver.hh

@@ -52,9 +52,6 @@ public:
   /// Default constructor -> set up IpOptApplication
   IPOPTSolver();
  
-  /// Destructor
-  ~IPOPTSolver() {}
-
   // ********** SOLVE **************** //
   // solve -> returns ipopt status code
 //------------------------------------------------------

NSolver/IPOPTSolverLean.cc

@@ -171,12 +171,16 @@ static void throw_ipopt_solve_failure(Ipopt::ApplicationReturnStatus const statu
   //      Internal_Error=-199
   //    };
   //------------------------------------------------------
-  switch(status) {
+  switch (status) 
+  {
   case Ipopt::Maximum_Iterations_Exceeded:
     COMISO_THROW(IPOPT_MAXIMUM_ITERATIONS_EXCEEDED);
+  case Ipopt::NonIpopt_Exception_Thrown:  
+    // this could be due to a thrown PROGRESS_ABORTED exception, ...
+    PROGRESS_RESUME_ABORT; // ... so check if we need to resume it
   default:
     COMISO_THROW(IPOPT_OPTIMIZATION_FAILED);
-  } // endswicth
+  }
 }
 
 static void check_ipopt_status(Ipopt::ApplicationReturnStatus const _stat)
@@ -185,7 +189,6 @@ static void check_ipopt_status(Ipopt::ApplicationReturnStatus const _stat)
     throw_ipopt_solve_failure(_stat);
 }
 
-
 void IPOPTSolverLean::solve(NProblemInterface* _problem, 
   const std::vector<NConstraintInterface*>& _constraints)
 {

NSolver/LeastSquaresProblem.hh

@@ -41,10 +41,6 @@ public:
    
   /// Default constructor
   LeastSquaresProblem(const int _n_unknowns = 0) :n_(_n_unknowns), x_(_n_unknowns, 0.0) {}
- 
-  /// Destructor
-  ~LeastSquaresProblem() {}
-
 
   void add_term(NConstraintInterface* _term);
   void clear_terms() {terms_.clear();}

NSolver/LinearConstraint.cc

@@ -35,9 +35,6 @@ LinearConstraint::LinearConstraint(const SVectorNC& _coeffs, const double _b, co
   b_ = _b;
 }
 
-/// Destructor
-LinearConstraint::~LinearConstraint() {}
-
 int LinearConstraint::n_unknowns()
 {
   return coeffs_.innerSize();

NSolver/LinearConstraint.hh

@@ -48,9 +48,6 @@ public:
   // linear equation of the form -> coeffs_^T *x  + b_=_type= 0
   LinearConstraint(const SVectorNC& _coeffs, const double _b, const ConstraintType _type = NC_EQUAL);
 
-  /// Destructor
-  virtual ~LinearConstraint();
-
   virtual int n_unknowns();
 
   // resize coefficient vector = #unknowns

NSolver/LinearConstraintHandlerElimination.hh

@@ -52,10 +52,6 @@ public:
   LinearConstraintHandlerElimination( const MatrixT& _C, const VectorT& _c)
   {initialize(_C, _c); }
 
- 
-  /// Destructor
-  ~LinearConstraintHandlerElimination() {}
-
   // number of variables
   int n() {return n_;}
   // number of reduced variables (after elimination)

NSolver/LinearConstraintHandlerPenalty.cc

@@ -20,13 +20,6 @@ namespace COMISO {
 /// Constructor
 LinearConstraintHandlerPenalty::LinearConstraintHandlerPenalty() : penalty_(10000) {}
 
-
-//-----------------------------------------------------------------------------
-
-/// Destructor
-LinearConstraintHandlerPenalty::~LinearConstraintHandlerPenalty()
-{}
-
 //-----------------------------------------------------------------------------
 
 // penalty weight

NSolver/LinearConstraintHandlerPenalty.hh

@@ -51,9 +51,6 @@ public:
   template<class MatrixT, class VectorT>
   LinearConstraintHandlerPenalty( const MatrixT& _C, const VectorT& _c);
  
-  /// Destructor
-  ~LinearConstraintHandlerPenalty();
-
   // penalty weight
   double& penalty();
 

NSolver/LinearProblem.cc

@@ -15,10 +15,6 @@ namespace COMISO {
   x_.resize(_dimension, 0.0);
 }
 
-LinearProblem::~LinearProblem()
-{
-}
-
 int LinearProblem::n_unknowns()
 {
   return static_cast<int>(coeffs_.size());

NSolver/LinearProblem.hh

@@ -45,9 +45,6 @@ public:
   /// Default constructor
   LinearProblem (std::size_t _dimension = 0);
  
-  /// Destructor
-  virtual ~LinearProblem();
-
   // problem definition
   virtual int    n_unknowns();
 

NSolver/NPDerivativeChecker.cc

@@ -2,10 +2,4 @@
 
 namespace COMISO {
 
-NPDerivativeChecker::NPDerivativeChecker() 
-{}
-
-NPDerivativeChecker::~NPDerivativeChecker() 
-{}
-
 }

NSolver/NPDerivativeChecker.hh

@@ -60,12 +60,6 @@ public:
     double relativeEps;
   };
   
-  /// Default constructor
-  NPDerivativeChecker();
-
-  /// Destructor
-  ~NPDerivativeChecker();
-
   template<class ProblemInterface>
   bool check_all(ProblemInterface* _np, double _dx, double _eps)
   {

NSolver/NPLinearConstraints.cc

@@ -31,9 +31,6 @@ NPLinearConstraintsElimination::NPLinearConstraintsElimination(NProblemGmmInterf
   this->initialize_identity(base_->n_unknowns());
 }
 
-/// Destructor
-NPLinearConstraintsElimination::~NPLinearConstraintsElimination() {}
-
 // NSolverInterface
 int NPLinearConstraintsElimination::n_unknowns   ()
 { return this->n_reduced(); }
@@ -126,10 +123,6 @@ double* NPLinearConstraintsElimination::P(const std::vector<double>& _v)
 NPLinearConstraintsPenalty::NPLinearConstraintsPenalty( NProblemGmmInterface* _np) : base_(_np)
 { if( !base_) std::cerr << "Warning: initialized NPLinearConstraints with zero pointer...\n"; }
 
-  /// Destructor
-NPLinearConstraintsPenalty::~NPLinearConstraintsPenalty()
-{}
-
 // NSolverInterface
 int    NPLinearConstraintsPenalty::n_unknowns   ()
 { return base_->n_unknowns(); }

NSolver/NPLinearConstraints.hh

@@ -47,9 +47,6 @@ public:
   /// Default constructor having a pointer to the main problem
   NPLinearConstraintsElimination( NProblemGmmInterface* _np);
  
-  /// Destructor
-  ~NPLinearConstraintsElimination();
-
   // initialize constraints
   template<class MatrixT, class VectorT>
   void initialize_constraints( const MatrixT& _C, const VectorT& _c);
@@ -100,9 +97,6 @@ public:
   /// Default constructor having a pointer to the main problem
   NPLinearConstraintsPenalty( NProblemGmmInterface* _np);
 
-  /// Destructor
-  ~NPLinearConstraintsPenalty();
-
   // initialize constraints
   template<class MatrixT, class VectorT>
   void initialize_constraints( const MatrixT& _C, const VectorT& _c);

NSolver/NPTiming.cc

@@ -23,10 +23,7 @@ namespace COMISO {
 /// Default constructor
 NPTiming::NPTiming(NProblemInterface* _base) : base_(_base) {start_timing();}
 
-/// Destructor
-NPTiming::~NPTiming() {}
-
-int NPTiming::n_unknowns   ()
+int NPTiming::n_unknowns()
 {
   return base_->n_unknowns();
 }

NSolver/NPTiming.hh

@@ -39,9 +39,6 @@ public:
   /// Default constructor
   NPTiming(NProblemInterface* _base);
  
-  /// Destructor
-  ~NPTiming();
-
   virtual int    n_unknowns   ();
 
   virtual void   initial_x( double* _x );

NSolver/NProblemGmmInterface.hh

@@ -14,6 +14,7 @@
 #include <gmm/gmm.h>
 
 #include <CoMISo/Config/CoMISoDefines.hh>
+#include <Base/Debug/DebOut.hh>
 
 //== FORWARDDECLARATIONS ======================================================
 
@@ -42,11 +43,11 @@ public:
 
   /// Default constructor
   NProblemGmmInterface()
-  {std::cerr << "Warning: NProblemGmmInterface is deprecated -> use NProblemInterface instead!!!" << std::endl;}
+  {
+    DEB_error(
+      "NProblemGmmInterface is deprecated -> use NProblemInterface instead");
+  }
  
-  /// Destructor
-  ~NProblemGmmInterface() {}
-
   virtual int    n_unknowns   (                                ) = 0;
   virtual void   initial_x    (       double* _x               ) = 0;
   virtual double eval_f       ( const double* _x               ) = 0;

NSolver/NProblemIPOPT.hh

@@ -72,9 +72,6 @@ public:
     analyze_special_properties(_problem, _constraints);
   }
 
-  /** default destructor */
-  virtual ~NProblemIPOPT() {};
-
   /**@name Overloaded from TNLP */
   //@{
   /** Method to return some info about the nlp */
@@ -218,9 +215,6 @@ public:
    : problem_(_problem), constraints_(_constraints), nnz_jac_g_(0), nnz_h_lag_(0)
    {}
 
-  /** default destructor */
-  virtual ~NProblemGmmIPOPT() {};
-
   /**@name Overloaded from TNLP */
   //@{
   /** Method to return some info about the nlp */

NSolver/NewtonSolver.cc

@@ -183,10 +183,11 @@ int NewtonSolver::solve(NProblemInterface* _problem, const SMatrixD& _A,
 
       if(!fact_ok || kkt_res2 > KKT_res_eps || constraint_res2 > max_allowed_constraint_violation2)
       {
-        // alternatingly regularize hessian and constraints
+        DEB_warning(2, "Numerical issues in KKT system"); 
+        // alternate hessian and constraints regularization
         if(reg_iters % 2 == 0 || regularize_constraints >= regularize_constraints_limit)
         {
-          DEB_line(2, "Warning: numerical issues in KKT system with residual^2 " << kkt_res2 << " (" << constraint_res2 << ") -> regularize hessian");
+          DEB_line(2, "residual ^ 2 " << kkt_res2 << "->regularize hessian");
           if(regularize_hessian == 0.0)
             regularize_hessian = 1e-6;
           else
@@ -194,7 +195,7 @@ int NewtonSolver::solve(NProblemInterface* _problem, const SMatrixD& _A,
         }
         else
         {
-          DEB_line(2, "Warning: numerical issues in KKT system with residual^2 " << kkt_res2 << " (" << constraint_res2 << ") -> regularize constraints");
+          DEB_line(2, "residual^2 " << kkt_res2 << " -> regularize constraints");
           if(regularize_constraints == 0.0)
             regularize_constraints = 1e-8;
           else
@@ -208,7 +209,8 @@ int NewtonSolver::solve(NProblemInterface* _problem, const SMatrixD& _A,
     // no valid step could be found?
     if(kkt_res2 > KKT_res_eps || constraint_res2 > max_allowed_constraint_violation2 || reg_iters >= max_KKT_regularization_iters)
     {
-      DEB_line(2, "Warning: numerical issues in KKT system could not be resolved -> terminating NewtonSolver with current solution");
+      DEB_error("numerical issues in KKT system could not be resolved "
+        "-> terminating NewtonSolver with current solution");
       _problem->store_result(x.data());
       return 0;
     }
@@ -229,7 +231,8 @@ int NewtonSolver::solve(NProblemInterface* _problem, const SMatrixD& _A,
 
     if(constraint_violation2 > 2*initial_constraint_violation2 && constraint_violation2 > max_allowed_constraint_violation2)
     {
-      DEB_line(2, "Warning: numerical issues in KKT system leads to constraint violation -> recovery phase");
+      DEB_warning(2, "Numerical issues in KKT system lead to "
+        "constraint violation -> recovery phase");
       // restore old solution
       x -= dx.head(n)*t;
 

NSolver/NewtonSolver.hh

@@ -65,9 +65,6 @@ public:
 //#endif
   }
 
-  /// Destructor
-  ~NewtonSolver() {}
-
   // solve without linear constraints
   int solve(NProblemInterface* _problem)
   {