BonCurvatureEstimator.hpp

Go to the documentation of this file.

// Copyright (C) 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: BonCurvatureEstimator.hpp 1758 2010-12-09 12:23:50Z pbonami $
//
// Author:   Andreas Waechter                 IBM    2006-10-11

#ifndef __BONCURVATUREESTIMATOR_HPP__
#define __BONCURVATUREESTIMATOR_HPP__
#error "Not supported currently"
#include "IpTNLP.hpp"
#include "IpOptionsList.hpp"
#include "IpCompoundSymMatrix.hpp"
#include "IpCompoundVector.hpp"
#include <vector>

namespace Ipopt {
  //forward declarations
  class TSymLinearSolver;
}

namespace Bonmin
{
  using namespace Ipopt;

  class CurvatureEstimator: public ReferencedObject
  {
  public:
    CurvatureEstimator(
      SmartPtr<Journalist> jnlst,
      SmartPtr<OptionsList> options,
      SmartPtr<TNLP> tnlp);

    virtual ~CurvatureEstimator();

    bool ComputeNullSpaceCurvature(
      int n,
      const Number* x,
      bool new_x,
      const Number* x_l,
      const Number* x_u,
      const Number* g_l,
      const Number* g_u,
      bool new_bounds,
      const Number* z_L,
      const Number* z_U,
      int m,
      const Number* lam,
      bool new_mults,
      const Number* orig_d,
      Number* projected_d,
      Number& gradLagTd,
      Number& dTHLagd);

  private:
    CurvatureEstimator();

    CurvatureEstimator(const CurvatureEstimator&);

    void operator=(const CurvatureEstimator&);

    SmartPtr<Journalist> jnlst_;
    SmartPtr<OptionsList> options_;
    std::string prefix_;
    SmartPtr<TSymLinearSolver> eq_tsymlinearsolver_;
    SmartPtr<TSymLinearSolver> all_tsymlinearsolver_;

    SmartPtr<TNLP> tnlp_;
    Index n_;
    Number* grad_f_;
    Index m_;
    Index nnz_jac_;
    Index* irows_jac_;
    Index* jcols_jac_;
    Number* jac_vals_;
    Index nnz_hess_;
    Index* irows_hess_;
    Index* jcols_hess_;
    Number* hess_vals_;

    Index eq_nx_free_;
    Index* eq_x_free_map_;
    Index eq_ng_fixed_;
    Index* eq_g_fixed_map_;

    Index all_nx_free_;
    Index* all_x_free_map_;
    Index all_ng_fixed_;
    Index* all_g_fixed_map_;

    Number* lambda_;

    Number* eq_projected_d_;

    SmartPtr<CompoundSymMatrixSpace> eq_comp_proj_matrix_space_;
    SmartPtr<CompoundSymMatrix> eq_comp_proj_matrix_;
    SmartPtr<CompoundVectorSpace> eq_comp_vec_space_;

    SmartPtr<CompoundSymMatrixSpace> all_comp_proj_matrix_space_;
    SmartPtr<CompoundSymMatrix> all_comp_proj_matrix_;
    SmartPtr<CompoundVectorSpace> all_comp_vec_space_;

    std::vector<int> active_x_;
    std::vector<int> active_g_;

    bool initialized_;

    bool Initialize();

    bool PrepareNewMatrixStructure(
      const Number* x_l,
      const Number* x_u,
      const Number* g_l,
      const Number* g_u,
      std::vector<int>& active_x,
      std::vector<int>& active_g,
      Index& nx_free,
      Index* x_free_map,
      Index& ng_fixed,
      Index* g_fixed_map,
      SmartPtr<CompoundSymMatrixSpace>& comp_proj_matrix_space,
      SmartPtr<CompoundVectorSpace>& comp_vec_space);

    bool PrepareNewMatrixValues(
      const Index* x_free_map,
      const Index* g_fixed_map,
      SmartPtr<CompoundSymMatrixSpace>& comp_proj_matrix_space,
      SmartPtr<CompoundSymMatrix>& comp_proj_matrix,
      SmartPtr<TSymLinearSolver>& tsymlinearsolver);

    bool SolveSystem(
      const Number* rhs_x,
      const Number* rhs_g,
      Number* sol_x, Number* sol_g,
      const Index* x_free_map,
      const Index* g_fixed_map,
      SmartPtr<CompoundVectorSpace>& comp_vec_space,
      SmartPtr<CompoundSymMatrix>& comp_proj_matrix,
      SmartPtr<TSymLinearSolver>& tsymlinearsolver);

    bool Compute_dTHLagd(
      const Number* d, const Number* x, bool new_x, const Number* lambda,
      bool new_lambda,  Number& dTHLagd);
  };

} // namespace Ipopt
#endif