/home/coin/SVN-release/CoinAll-1.1.0/Ipopt/src/Apps/CompositeInterface/CompositeNLP.hpp

Go to the documentation of this file.

// Copyright (C) 2004, International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: CompositeNLP.hpp 598 2005-12-01 17:56:15Z claird $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPCOMPOSITENLP_HPP__
#define __IPCOMPOSITENLP_HPP__

#include "IpNLP.hpp"

namespace Ipopt
{

  /* forward declaration */
  class SymLinearSolver;

  class CompositeNLP : public NLP
  {
  public:
    CompositeNLP(std::vector<SmartPtr<NLP> > nlps, SmartPtr<VectorSpace> q_space,
                 std::vector<SmartPtr<VectorSpace> > linking_eqn_c_spaces,
                 std::vector<SmartPtr<Matrix> > Jx_linking_eqns,
                 std::vector<SmartPtr<Matrix> > Jq_linking_eqns);

    virtual ~CompositeNLP();

    DECLARE_STD_EXCEPTION(INVALID_JACOBIAN_DIMENSION_FOR_LINKING_EQUATIONS);

    virtual bool ProcessOptions(const OptionsList& options,
                                const std::string& prefix);

    virtual bool GetSpaces(SmartPtr<const VectorSpace>& x_space,
                           SmartPtr<const VectorSpace>& c_space,
                           SmartPtr<const VectorSpace>& d_space,
                           SmartPtr<const VectorSpace>& x_l_space,
                           SmartPtr<const MatrixSpace>& px_l_space,
                           SmartPtr<const VectorSpace>& x_u_space,
                           SmartPtr<const MatrixSpace>& px_u_space,
                           SmartPtr<const VectorSpace>& d_l_space,
                           SmartPtr<const MatrixSpace>& pd_l_space,
                           SmartPtr<const VectorSpace>& d_u_space,
                           SmartPtr<const MatrixSpace>& pd_u_space,
                           SmartPtr<const MatrixSpace>& Jac_c_space,
                           SmartPtr<const MatrixSpace>& Jac_d_space,
                           SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space);

    virtual bool GetBoundsInformation(const Matrix& Px_L,
                                      Vector& x_L,
                                      const Matrix& Px_U,
                                      Vector& x_U,
                                      const Matrix& Pd_L,
                                      Vector& d_L,
                                      const Matrix& Pd_U,
                                      Vector& d_U);

    virtual bool GetStartingPoint(
      SmartPtr<Vector> x,
      bool need_x,
      SmartPtr<Vector> y_c,
      bool need_y_c,
      SmartPtr<Vector> y_d,
      bool need_y_d,
      SmartPtr<Vector> z_L,
      bool need_z_L,
      SmartPtr<Vector> z_U,
      bool need_z_U
    );

    virtual bool Eval_f(const Vector& x, Number& f);

    virtual bool Eval_grad_f(const Vector& x, Vector& g_f);

    virtual bool Eval_c(const Vector& x, Vector& c);

    virtual bool Eval_jac_c(const Vector& x, Matrix& jac_c);

    virtual bool Eval_d(const Vector& x, Vector& d);

    virtual bool Eval_jac_d(const Vector& x, Matrix& jac_d);

    virtual bool Eval_h(const Vector& x,
                        Number obj_factor,
                        const Vector& yc,
                        const Vector& yd,
                        SymMatrix& h);

    SmartPtr<SymLinearSolver> CreateLinearSolver();
  private:
    CompositeNLP();

    CompositeNLP(const CompositeNLP&);

    void operator=(const CompositeNLP&);

    SmartPtr<const Journalist> jnlst_;

    std::vector<SmartPtr<NLP> > nlps_;

    SmartPtr<VectorSpace> q_space_;

    std::vector<SmartPtr<VectorSpace> > linking_eqn_c_spaces_;

    std::vector<SmartPtr<Matrix> > Jx_linking_eqns_;

    std::vector<SmartPtr<Matrix> > Jq_linking_eqns_;
  };

} // namespace Ipopt

#endif

---