Merge from ReForm

EigenSolver/ArpackSolver.hh

@@ -42,17 +42,9 @@ namespace COMISO {
 class COMISODLLEXPORT ArpackSolver
 {
 public:
-
   // sparse matrix type
   typedef EigenArpackMatrixT<double,Eigen::SparseMatrix<double,Eigen::ColMajor> > Matrix;
 
-
-  /// Constructor
-  ArpackSolver() {}
- 
-  /// Destructor
-  ~ArpackSolver() {}
-
   // solve eigenproblem
   // number of desired eigenvalues -> _n_eigenvalues
   // which eigenvalues -> one of {LA (largest algebraic), SA (smalles algebraic), LM (largest magnitude), SM(smallest magnitued), BE(both ends)}
@@ -77,9 +69,6 @@ public:
   // check resulting eigenvalues/eigenvectors
   template<class MatrixT,class MatrixT2>
   void check_result(const MatrixT& _A, std::vector<double>& _eigenvalues, MatrixT2& _eigenvectors);
-
-private:
-  
 };
 
 

EigenSolver/EigenArpackMatrixT.hh

@@ -74,9 +74,6 @@ public:
     }
   }
  
-  /// Destructor
-  ~EigenArpackMatrixT() {}
-  
   // get reference on matrix
   Matrix& matrix() { return mat_; }
 

NSolver/AcceleratedQuadraticProxy.hh

@@ -45,9 +45,6 @@ public:
   AcceleratedQuadraticProxy(const double _eps = 1e-6, const int _max_iters = 1000, const double _accelerate = 100.0, const double _alpha_ls=0.2, const double _beta_ls = 0.6)
     : eps_(_eps), max_iters_(_max_iters), accelerate_(_accelerate), alpha_ls_(_alpha_ls), beta_ls_(_beta_ls) {}
  
-  /// Destructor
-  ~AcceleratedQuadraticProxy() {}
-
   // solve without linear constraints
   int solve(NProblemInterface* _quadratic_problem, NProblemInterface* _nonlinear_problem, bool _update_factorization = true)
   {

NSolver/BoundConstraint.cc

@@ -30,14 +30,6 @@ BoundConstraint(const unsigned int  _var_idx,   // index of variable for bound c
 }
 
 
-//-----------------------------------------------------------------------------
-
-BoundConstraint::
-~BoundConstraint()
-{
-}
-
-
 //-----------------------------------------------------------------------------
 
 

NSolver/BoundConstraint.hh

@@ -47,10 +47,6 @@ public:
                   const unsigned int   _n      = 0,   // number of unknowns in problem
                   const ConstraintType _type   = NC_LESS_EQUAL); // type of bound upper, lower or both (equal)
 
- 
-  /// Destructor
-  virtual ~BoundConstraint();
-
   virtual int    n_unknowns      (                                      );
   virtual double eval_constraint ( const double* _x                     );
   virtual void   eval_gradient   ( const double* _x, SVectorNC& _g      );

NSolver/CBCSolver.hh

@@ -39,12 +39,6 @@ namespace COMISO {
 class COMISODLLEXPORT CBCSolver
 {
 public:
-  /// Default constructor
-  CBCSolver() {}
-
-  /// Destructor
-  ~CBCSolver() {}
-
   // ********** SOLVE **************** //
   //! \throws Outcome
   bool solve(

NSolver/COMISOSolver.hh

@@ -44,12 +44,6 @@ public:
    
   typedef std::pair<unsigned int, VariableType> PairUiV;
 
-  /// Default constructor
-  COMISOSolver() {}
- 
-  /// Destructor
-  ~COMISOSolver() {}
-
   // ********** SOLVE **************** //
   void solve(NProblemInterface*                  _problem,                      // problem instance
              std::vector<NConstraintInterface*>& _constraints,                  // linear constraints

NSolver/CPLEXSolver.cc

@@ -1300,14 +1300,6 @@ add_constraint_to_model( NConstraintInterface* _constraint, std::vector<IloNumVa
 }
 
 
-
-
-CPLEXSolver::
-CPLEXSolver()
-{
-}
-
-
 //-----------------------------------------------------------------------------
 
 

NSolver/CPLEXSolver.hh

@@ -45,12 +45,6 @@ class COMISODLLEXPORT CPLEXSolver
 {
 public:
 
-  /// Default constructor
-  CPLEXSolver();
- 
-  /// Destructor
-  ~CPLEXSolver() { /*env_.end();*/}
-
   // ********** SOLVE **************** //
   // this function has to be inline due to static linking issues
   bool solve(NProblemInterface*                  _problem,                // problem instance

NSolver/CombinedProblem.cc

@@ -5,22 +5,20 @@
 //== INCLUDES =================================================================
 #include "CombinedProblem.hh"
 
+#include <Base/Debug/DebOut.hh>
 
 namespace COMISO {
 
 CombinedProblem::CombinedProblem (NProblemInterface* _p1, NProblemInterface* _p2, const double _c1, const double _c2)
   : p1_(_p1) , p2_(_p2), c1_(_c1), c2_(_c2)
 {
-  if(p1_->n_unknowns() != p2_->n_unknowns())
-    std::cerr << "Warning: CombinedProblem received two problems with different #unknowns!!!" << std::endl;
+  DEB_enter_func;
+  DEB_warning_if(p1_->n_unknowns() != p2_->n_unknowns(), 1,
+    "CombinedProblem received two problems with different unknowns #");
 
   g_temp_.resize(p1_->n_unknowns());
 }
 
-CombinedProblem::~CombinedProblem()
-{
-}
-
 int  CombinedProblem::n_unknowns()
 {
   return p1_->n_unknowns();

NSolver/CombinedProblem.hh

@@ -48,9 +48,6 @@ public:
   /// Default constructor
   CombinedProblem (NProblemInterface* _p1, NProblemInterface* _p2, const double _c1 = 1.0, const double _c2 = 1.0);
  
-  /// Destructor
-  virtual ~CombinedProblem();
-
   // problem definition
   virtual int    n_unknowns();
 

NSolver/ConeConstraint.cc

@@ -39,9 +39,6 @@ ConeConstraint::ConeConstraint(const double _c, const int _i, const SMatrixNC& _
 {
 }
 
-/// Destructor
-ConeConstraint::~ConeConstraint() {}
-
 int ConeConstraint::n_unknowns()
 {
   return Q_.cols();

NSolver/ConeConstraint.hh

@@ -39,9 +39,6 @@ public:
   // cone constraint of the form -> 0.5*(c_ * x(i_)^2 - x^T Q_ x) >= 0
   ConeConstraint(const double _c, const int _i, const SMatrixNC& _Q);
 
-  /// Destructor
-  virtual ~ConeConstraint();
-
   virtual int n_unknowns();
 
   // resize coefficient vector = #unknowns

NSolver/ConstraintTools.cc

@@ -13,17 +13,6 @@
 
 namespace COMISO {
 
-ConstraintTools::ConstraintTools()
-{
-}
-
-//-----------------------------------------------------------------------------
-
-
-ConstraintTools::~ConstraintTools()
-{
-}
-
 //-----------------------------------------------------------------------------
 
 void

NSolver/ConstraintTools.hh

@@ -47,12 +47,6 @@ public:
   typedef gmm::row_matrix< SVectorGMM > RMatrixGMM;
   typedef gmm::col_matrix< SVectorGMM > CMatrixGMM;
 
-  /// Default constructor
-  ConstraintTools();
- 
-  /// Destructor
-  ~ConstraintTools();
-
   // remove all linear dependent linear equality constraints. the remaining constraints are a subset of the original ones
   // nonlinear or equality constraints are preserved.
   static void remove_dependent_linear_constraints(std::vector<NConstraintInterface*>& _constraints, const double _eps = 1e-8);

NSolver/DOCloudJob.cc

@@ -242,8 +242,6 @@ private:
 
 Job::~Job()
 {
-  DEB_enter_func;
-
   delete stts_;
 
   if (url_.empty()) // not setup

NSolver/FiniteElementProblem.cc

@@ -13,11 +13,6 @@ FiniteElementProblem::FiniteElementProblem(const unsigned int _n)
 {
 }
 
-/// Destructor
-FiniteElementProblem::~FiniteElementProblem()
-{
-}
-
 void FiniteElementProblem::add_set(FiniteElementSetBase* _fe_set)
 {
   fe_sets_.push_back(_fe_set);

NSolver/FiniteElementProblem.hh

@@ -237,9 +237,6 @@ public:
   /// Default constructor
   FiniteElementProblem(const unsigned int _n);
 
-  /// Destructor
-  virtual ~FiniteElementProblem();
-
   void add_set(FiniteElementSetBase* _fe_set);
 
   void clear_sets();

NSolver/GUROBISolver.cc

@@ -59,13 +59,6 @@ void add_constraint_to_model(COMISO::NConstraintInterface* _constraint,
 //-----------------------------------------------------------------------------
 
 
-GUROBISolver::
-GUROBISolver()
-{
-}
-
-//-----------------------------------------------------------------------------
-
 static void process_gurobi_exception(const GRBException& _exc)
 {
   DEB_enter_func;

NSolver/GUROBISolver.hh

@@ -42,13 +42,6 @@ namespace COMISO {
 class COMISODLLEXPORT GUROBISolver
 {
 public:
-
-  /// Default constructor
-  GUROBISolver();
- 
-  /// Destructor
-  ~GUROBISolver() {}
-
   // ********** SOLVE **************** //
   bool solve(NProblemInterface*                  _problem,                // problem instance
              std::vector<NConstraintInterface*>& _constraints,            // linear constraints

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

@@ -42,10 +42,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,10 +43,10 @@ public:
 
   /// Default constructor
   NProblemGmmInterface()
-  {std::cerr << "Warning: NProblemGmmInterface is deprecated -> use NProblemInterface instead!!!" << std::endl;}
- 
-  /// Destructor
-  ~NProblemGmmInterface() {}
+  {
+    DEB_error(
+      "NProblemGmmInterface is deprecated -> use NProblemInterface instead");
+  }
  
   virtual int    n_unknowns   (                                ) = 0;
   virtual void   initial_x    (       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)
   {

NSolver/SuperSparseMatrixT.hh

@@ -81,9 +81,6 @@ public:
   : n_rows_(_n_rows), n_cols_(_n_cols)
   {}
  
-  /// Destructor
-  ~SuperSparseMatrixT() {}
-
   // iterate over non-zeros
   iterator begin() { return iterator(data_.begin()); }
   iterator end()   { return iterator(data_.end());   }

NSolver/TAOSolver.hh

@@ -42,14 +42,6 @@ namespace COMISO {
 class COMISODLLEXPORT TAOSolver
 {
 public:
-   
-  /// Default constructor
-  TAOSolver() {}
-
-
-  /// Destructor
-  ~TAOSolver() {}
-
   // solve problem