MatrixCBSolver.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_MATRIXCBSOLVER_HXX
#define CONICBUNDLE_MATRIXCBSOLVER_HXX

#include "CBSolver.hxx"
#include "matrix.hxx"
#include "UQPSolver.hxx"
#include "BundleProxObject.hxx"
#include "BundleData.hxx"
#include "BundleWeight.hxx"
#include "FunctionObjectModification.hxx"
#include "AffineFunctionTransformation.hxx"
#include "SumBundleParametersObject.hxx"

//------------------------------------------------------------


namespace ConicBundle {


  class PrimalMatrix:public PrimalData, public CH_Matrix_Classes::Matrix
  {

  public:
    PrimalMatrix(){}
    PrimalMatrix(CH_Matrix_Classes::Integer nr,CH_Matrix_Classes::Integer nc):Matrix(nr,nc)   {}
    PrimalMatrix(CH_Matrix_Classes::Integer r,CH_Matrix_Classes::Integer c,CH_Matrix_Classes::Real d)    :Matrix(r,c,d) {}
    PrimalMatrix(const PrimalMatrix& pm):PrimalData(),Matrix(pm)    {}  
    PrimalMatrix(const CH_Matrix_Classes::Matrix& pm):Matrix(pm)    {} 
    PrimalMatrix& operator=(const CH_Matrix_Classes::Matrix& pd)  
    { Matrix::operator=(pd); return *this; }
    
    PrimalData* clone_primal_data() const{return new PrimalMatrix(*this);}

    int aggregate_primal_data(const PrimalData& it,double itsfactor)
    {
      const PrimalMatrix* pd=dynamic_cast<const PrimalMatrix*>(&it);
      if (pd!=0) {
        xpeya(*pd,itsfactor);
        return 0;
      }
      return 1;
    }

    int scale_primal_data(double myfactor){ *this *= myfactor; return 0;}

  };

  class MatrixMinorant: public Minorant
  {
  public:

    MatrixMinorant(CH_Matrix_Classes::Real offset, 
                   const CH_Matrix_Classes::Matrix& subg,
                   PrimalData* primal=0,
                   bool offset_at_origin=false):
      Minorant(offset_at_origin,double(offset),int(subg.rowdim()),(const double*)subg.get_store(),0,1.,primal)
    {assert(subg.coldim()==1);}

    MatrixMinorant(CH_Matrix_Classes::Real offset,
                   const CH_Matrix_Classes::Sparsemat& subg,
                   PrimalData* primal=0,
                   bool offset_at_origin=false):
      Minorant(offset_at_origin,double(offset),int(subg.nonzeros()),(const double*)(subg.get_colval().get_store()),(const int*)(subg.get_colindex().get_store()),1.,primal)
    {assert(subg.coldim()==1);}
    
    MatrixMinorant(const Minorant* mnrt,
                   CH_Matrix_Classes::Real factor=1.,
                   bool with_primal=true)
      :Minorant(mnrt,double(factor),with_primal)
    {}

    ~MatrixMinorant(){}

    Minorant* clone_minorant(double factor=1.,bool with_primal=true) const
    { return new MatrixMinorant(this,CH_Matrix_Classes::Real(factor),with_primal); }

  };

  class ModifiableOracleObject: public FunctionObject 
  {
  public:
    virtual ~ModifiableOracleObject();

    virtual 
    int 
    apply_modification
    (
     const OracleModification& oracle_modification,
     const CH_Matrix_Classes::Matrix* new_center,
     const CH_Matrix_Classes::Matrix* old_center,
     bool& discard_objective_in_center,
     bool& discard_model, 
     bool& discard_aggregates,
     MinorantExtender*& minorant_extender
     );

    virtual
    bool
    check_correctness() const
    {return false;}

  };
    

  class MatrixFunctionOracle: public ModifiableOracleObject 
  {
  public:
        
    virtual
    int
    evaluate
    (
     const  CH_Matrix_Classes::Matrix&          current_point,
     CH_Matrix_Classes::Real relprec,
     CH_Matrix_Classes::Real&                 objective_value,
     std::vector<Minorant*>&    minorants,
     PrimalExtender*& primal_extender
     )
      = 0;

      
    virtual
    bool
    check_correctness() const
    {return true;}
  };

  
  class MatrixCBSolverData;

  class MatrixCBSolver: public CBout
  {
  private:              
    MatrixCBSolverData* data_;                       
    MatrixCBSolver ( const MatrixCBSolver& );           
    MatrixCBSolver& operator= ( const MatrixCBSolver& );
  public:    
    
    MatrixCBSolver(std::ostream* out=0,int print_level=0);
    MatrixCBSolver(const CBout* cb,int incr=0);
    ~MatrixCBSolver();
    
    //------------------------------------------------------------
       
    void clear();

    void set_defaults();

    int init_problem(int dim, 
                     const CH_Matrix_Classes::Matrix* lbounds=0,
                     const CH_Matrix_Classes::Matrix* ubounds=0,
                     const CH_Matrix_Classes::Matrix* startval=0,
                     const CH_Matrix_Classes::Matrix* costs=0,
                     CH_Matrix_Classes::Real offset=0.);
    

    
    int
    add_function
    ( FunctionObject& function,
      CH_Matrix_Classes::Real fun_factor=1.,
      FunctionTask fun_task=ObjectiveFunction, 
      AffineFunctionTransformation* aft=0,
      bool argument_list_may_change_dynamically=false);
    
    int set_lower_bound(int i, double lb);

    int set_upper_bound(int i, double ub); 


    int append_variables(int n_append,                   
                         const CH_Matrix_Classes::Matrix* lbounds=0,
                         const CH_Matrix_Classes::Matrix* ubounds=0,
                         const CH_Matrix_Classes::Sparsemat* constraint_columns=0,
                         const CH_Matrix_Classes::Matrix* startval=0,
                         const CH_Matrix_Classes::Matrix* costs=0,
                         const FunObjModMap* affected_functions_with_modifications=0);

    int delete_variables(const CH_Matrix_Classes::Indexmatrix& delete_indices,
                         CH_Matrix_Classes::Indexmatrix& map_to_old,
                         const FunObjModMap* affected_functions_with_modifications=0);

    int reassign_variables(const CH_Matrix_Classes::Indexmatrix& assign_new_from_old,
                           const FunObjModMap* affected_functions_with_modifications=0);

  int append_constraints(CH_Matrix_Classes::Integer append_n_rows,
                         const CH_Matrix_Classes::Sparsemat* append_rows=0,
                         const CH_Matrix_Classes::Matrix* append_rhslb=0,
                         const CH_Matrix_Classes::Matrix* append_rhsub=0);


    //------------------------------------------------------------
    
    int 
    solve(int maxsteps=0,bool stop_at_descent_steps=false);
    
    
    int
    termination_code() const; 
    
    std::ostream&
    print_termination_code(std::ostream& out); 
    
    double 
    get_objval() const;
    
    int 
    get_center
    ( CH_Matrix_Classes::Matrix& center ) const;
    
    
    double 
    get_sgnorm() const; 

    int 
    get_subgradient
    ( CH_Matrix_Classes::Matrix& subgradient) const;

    double 
    get_cutval() const;
    
    double 
    get_candidate_value() const;
    
    int 
    get_candidate
    ( CH_Matrix_Classes::Matrix& center ) const;
    
    
    
    //------------------------------------------------------------

    int 
    set_term_relprec
    ( const double term_relprec );
    
    int
    set_new_center_point
    ( const CH_Matrix_Classes::Matrix& center_point );

    
     int 
    get_function_status
    ( const FunctionObject& function ) const;

    int 
    get_approximate_slacks(CH_Matrix_Classes::Matrix &) const;
    
    const PrimalData*
    get_approximate_primal
    ( const FunctionObject& function)
      const; 
    
    const PrimalData*
    get_center_primal
    ( const FunctionObject& function)
      const; 


    const PrimalData*
    get_candidate_primal
    (const FunctionObject& function)
      const; 


    int
    set_sumbundle
    (bool use_sumbundle,
     int n_local_models=-1,
     const BundleParameters* bundle_parameters=0,
     int strategy=1);

    int 
    set_max_modelsize
    (int max_modelsize,  const FunctionObject* function=0);

    int 
    set_max_bundlesize
    (int max_bundlesize, const FunctionObject* function=0);

    int 
    set_bundle_parameters
    (const BundleParameters& params,  const FunctionObject* function=0);

    const BundleParameters*
    get_bundle_parameters
    ( const FunctionObject* function=0) const;


    int 
    set_sumbundle_parameters
    (const SumBundleParametersObject& params,  const FunctionObject* function=0);

    const BundleData*
    get_bundle_data
    ( const FunctionObject* function=0) const;

    int reinit_function_model
    ( const FunctionObject* function=0);
    
    int clear_aggregates
    ( const FunctionObject* function=0);
    
    int call_primal_extender
    (const FunctionObject& function,
     PrimalExtender& primal_extender);

    double 
    get_last_weight() const; 

    double 
    get_next_weight() const; 

    int 
    set_next_weight
    ( const double weight );
    
    int 
    set_min_weight
    ( const double min_weight ); 

    int 
    set_max_weight
    ( const double max_weight );
    
    int 
    set_weight_update
    ( BundleWeight* bw );
    
    int 
    adjust_multiplier
    ( void );
    

    int
    set_variable_metric
    ( int do_variable_metric );


    int
    set_prox
    (BundleProxObject* proxp);

    void
    set_active_bounds_fixing
    ( bool allow_fixing );

    void 
    clear_fail_counts
    (void);
    
    void 
    set_eval_limit
    (CH_Matrix_Classes::Integer eval_limit);

    void 
    set_inner_update_limit
    (CH_Matrix_Classes::Integer update_limit);
    
    void 
    set_time_limit
    (CH_Matrix_Classes::Integer time_limit);
    
    /* * @brief Set parameters for the internal QP solver, possibly after first exchanging the solver with a new one
 
      The objects passed need to be heap objects; their ownership is transferred
      to the bundle code and they will be deleted there. The pointers may be null,
      in which case nothing is done for this object

      @param[in] qpparams (QPSolverParametersObject*)

      @param[in] newqpsolver (QPSolverObject*)
      
      @return 
        - 0 on success
        - != 0 otherwise
    */

    int set_qp_solver(QPSolverParametersObject* qpparams,
                      QPSolverObject* newqpsolver=0);
    
    
    //------------------------------------------------------------
    int get_dim() const;

    int get_n_functions() const;

    int get_n_oracle_calls() const;

    int get_n_descent_steps() const;

    int get_n_inner_iterations() const;

    int get_n_inner_updates() const;

    bool get_descent_step() const;

    bool get_null_step() const;

    int get_costs(CH_Matrix_Classes::Matrix& costs) const;
    
    const CH_Matrix_Classes::Matrix* get_lbounds() const;

    const CH_Matrix_Classes::Matrix* get_ubounds() const;
    
    const CH_Matrix_Classes::Indexmatrix* get_fixed_active_bounds() const;

    BundleProxObject* get_prox() const;

  bool 
  pending_oracle_modification(const FunctionObject& function,
                              CH_Matrix_Classes::Integer& old_dim,
                              CH_Matrix_Classes::Integer& new_dim,
                              CH_Matrix_Classes::Integer& append_dim,
                              const CH_Matrix_Classes::Indexmatrix*& map_to_old,
                              const CH_Matrix_Classes::Indexmatrix*& deleted_indices,
                              const CH_Matrix_Classes::Indexmatrix*& new_indices,
                              const OracleModification*& oracle_modification
                              ) const;


    //------------------------------------------------------------

    void 
    set_out
    (std::ostream* out=0,int print_level=1);

    std::ostream& print_line_summary(std::ostream& out) const;

    std::ostream& print_statistics(std::ostream& out) const;

    
  };

}

#endif