CBSolver.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_CBSOLVER_HXX
#define CONICBUNDLE_CBSOLVER_HXX

#include <assert.h>
#include <iostream>
#include <vector>

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

namespace ConicBundle {


  extern const double CB_plus_infinity;
  extern const double CB_minus_infinity;
  
  //------------------------------------------------------------
  
 
  typedef std::vector<double> DVector;

  typedef std::vector<int>    IVector;

  class PrimalData
  {

  public:

    virtual ~PrimalData();

    virtual PrimalData* clone_primal_data() const=0;  

    virtual int aggregate_primal_data(const PrimalData& it,double factor=1.)=0;
        
    virtual int scale_primal_data(double myfactor)=0;

  };

  class PrimalExtender
  {
  public:
    virtual ~PrimalExtender();

    virtual int extend(PrimalData&)=0;
  };



  extern const double CB_minorant_zero_tolerance;

  extern const double CB_minorant_sparsity_ratio;


  enum FunctionTask {
    ObjectiveFunction=0,              
    ConstantPenaltyFunction=1,
    AdaptivePenaltyFunction=2
  };


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

  class Minorant
  {    
  public:


    Minorant(double offset,const DVector& subg,PrimalData* primal=0,bool offset_at_origin=false);

    Minorant(double offset,const DVector& subg_val,const IVector& subg_ind,PrimalData* primal=0,bool offset_at_origin=false);
    
    Minorant(bool offset_at_origin=true,
             double offset=0.,
             int n_elementes=0,
             const double* coeffs=0,
             const int* indices=0,
             double scale_val=1.,
             PrimalData* primal=0
             );

    Minorant(const Minorant* mnrt,double factor=1.,bool with_primal=false);

    virtual ~Minorant();

    virtual double offset() const;
    virtual int add_offset(double value);

    virtual bool& offset_gives_value_at_origin();  
    virtual bool offset_gives_value_at_origin() const;  

    virtual double coeff(int i);

    virtual int add_coeff(int i,double value);
    
    virtual int add_coeffs(int n_elements,const double* values,double factor=1.,int start_pos=0);

    virtual int add_coeffs(int n_elements,const double* values,const int* indices,double factor=1.);

    virtual int sparsify(double tol=CB_minorant_zero_tolerance,double sparsity_ratio=CB_minorant_sparsity_ratio); 

    virtual int nonzeros(); 

    virtual int get_coeffs(int& n_elements,const double*& coeffs,const int*& indices) const;

    virtual double* get_dense_coeff_store(int n_elements);

      virtual int reassign_coeffs(int n_elements,const int* map_to_old_coeffs);

    virtual void set_primal(PrimalData*);
  
    virtual PrimalData* get_primal();
    
    virtual const PrimalData* get_primal() const;

    virtual Minorant* clone_minorant(double factor=1.,bool with_primal=true) const;

    virtual int aggregate(const Minorant& minorant,double factor=1.);

    virtual int number_aggregated() const;

    virtual int scale_minorant(double scale_val);

    virtual double norm_squared() const;

  protected:
    class MinorantData; 
    mutable MinorantData* data;

    Minorant(const Minorant&){}             
    Minorant& operator=(const Minorant&);    
  };

  class MinorantExtender
  {
  public:
    virtual ~MinorantExtender();

    virtual int extend(Minorant& minorant,int n_coords,const int* indices)=0;
  };

  class OracleModification
  {
  public:
    virtual ~OracleModification();

    virtual int get_old_vardim() const =0;
    virtual int get_new_vardim() const =0;
    virtual int get_appended_vardim() const =0;
    virtual const int* get_map_to_old_variables() const =0;

    virtual int incorporate(const OracleModification& next_modification)=0;

    virtual OracleModification* new_initial_oraclemodification(int old_var_dim) const =0;
       
    virtual int add_append_variables(int append_dim)=0;

    virtual int add_reassign_variables(int new_dim,const int* map_to_old_indices)=0; 

    virtual bool no_modification() const=0;

    virtual int set_append_to_old(bool ) =0;
 
    virtual bool append_to_old() const=0;

  };


  class PrimalDVector: public PrimalData, public DVector
  {

  public:
    PrimalDVector(){}
    PrimalDVector(int n)                   :DVector((unsigned long)(n))   {}
    PrimalDVector(int n ,double d)         :DVector((unsigned long)(n),d) {}
    PrimalDVector(const PrimalDVector& pd) :PrimalData(),DVector(pd)  {}
    PrimalDVector(const DVector& pd)       :DVector(pd)  {}
    PrimalDVector& operator=(const DVector& pd) { DVector::operator= (pd); return *this; }
    
    PrimalData* clone_primal_data() const{return new PrimalDVector(*this);}

    int assign_primal_data(const PrimalData& it,double factor=1.)
    {
      const PrimalDVector* pd=dynamic_cast<const PrimalDVector*>(&it);
      assert(pd!=0);
      DVector::operator=(*pd);
      if (factor!=1)    
        for(unsigned int i=0;i<size();i++){
          (*this)[i]*=factor;
        }
      return 0;
    }

    int aggregate_primal_data(const PrimalData& it,double factor=1.)
    {
      const PrimalDVector* pd=dynamic_cast<const PrimalDVector*>(&it);
      assert(pd!=0);
      if (size()!=pd->size()) return 1;
      for(unsigned int i=0;i<size();i++){
        (*this)[i]+=(*pd)[i]*factor;
      }
      return 0;
    }

    virtual int scale_primal_data(double myfactor)
    { 
      if (myfactor!=1.){
        for(unsigned int i=0;i<size();i++){
          (*this)[i]*=myfactor;
        }
      }
      return 0;
      
    }

  };


  class FunctionOracle: public FunctionObject 
  {
  public:
        
    virtual
    int
    evaluate
    (
     const double* current_point,
     double relprec,
     double& objective_value,
     std::vector<Minorant*>&  minorants,
     PrimalExtender*& primal_extender 
     )= 0;


    virtual 
    int 
    apply_modification
    (
     const OracleModification& oracle_modification ,
     const double* new_center,
     const double* old_center,
     bool& discard_objective_in_center,
     bool& discard_model, 
     bool& discard_aggregates,
     MinorantExtender*& minorant_extender
     );
    /*{return 1;}*/
  
 
    virtual
    bool
    check_correctness() const
    {return true;}
      
       
  };
  

  class BundleParameters
  {
  protected:
    int max_model_size;       
    int max_bundle_size;      
    int update_rule;      

  public:
    virtual int init(const BundleParameters& bp)
    {
      max_model_size=bp.max_model_size;
      max_bundle_size=bp.max_bundle_size;
      update_rule=bp.update_rule;
      return 0;
    }

    virtual int get_max_model_size() const 
    { return max_model_size; }
    virtual int get_max_bundle_size() const 
    { return max_bundle_size; }
    virtual int get_update_rule() const 
    { return update_rule; }

    virtual int set_max_model_size(int mms)
    { max_model_size=mms; return 0; }
    virtual int set_max_bundle_size(int mbs)
    { max_bundle_size=mbs; return 0; }
    virtual int set_update_rule(int ur)
    { update_rule=ur; return 0; }

    BundleParameters(const BundleParameters& bp)
    {BundleParameters::init(bp);}

    BundleParameters(int modelsize=-1,int bundlesize=-1,int updaterule=-1)
    {
      max_model_size=modelsize;
      max_bundle_size=bundlesize;
      update_rule=updaterule;
    }

    virtual ~BundleParameters(); 

    virtual BundleParameters* clone_BundleParameters() const
    { return new BundleParameters(*this); }

  };


  class MatrixCBSolver;
  
  class CBSolver
  {
   private:
    MatrixCBSolver* solver;                     

    CBSolver ( const CBSolver& );               
    CBSolver& operator= ( const CBSolver& );    
  public:    
    
    CBSolver(std::ostream* out=0,int print_level=0);
    virtual ~CBSolver();
    
    //------------------------------------------------------------
       
    void clear();

    void set_defaults();

    int init_problem(int dim, 
                     const DVector* lbounds=0,
                     const DVector* ubounds=0);
    
    int
    add_function
    ( FunctionObject& function );
    
    int set_lower_bound(int i, double lb);

    int set_upper_bound(int i, double ub); 


    int append_variables(int n_append, 
                         const DVector* lbounds=0,
                         const DVector* ubounds=0);

    int delete_variables(const IVector& delete_indices,IVector& map_to_old);

    int reassign_variables(const IVector& assign_new_from_old);


    //------------------------------------------------------------
    
    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
    ( DVector& center )
      const;
    
    
    double 
    get_sgnorm()
      const; 

    int 
    get_subgradient
    ( DVector& subgradient )
      const;
 
    virtual double 
    get_candidate_value()
      const;
    
    virtual int 
    get_candidate
    ( DVector& candidate )
      const;
    
    
    
    //------------------------------------------------------------

    int 
    set_term_relprec
    ( const double term_relprec );
    
    int
    set_new_center_point
    ( const DVector& center_point );

    
    int 
    get_function_status
    ( const FunctionObject& function )
      const;

    int 
    get_approximate_slacks
    ( DVector& center )
      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_max_modelsize
    (  const FunctionObject& function, int max_modelsize );

    int 
    set_max_bundlesize
    (  const FunctionObject& function, int max_bundlesize );

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

    const BundleParameters* 
    get_bundle_parameters
    ( const FunctionObject& function )
      const;


    int reinit_function_model
    ( const FunctionObject& function );
    
    int call_primal_extender
    (const FunctionObject& function,
     PrimalExtender& primal_extender);

    double 
    get_last_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 );
    
    
    virtual int
    set_variable_metric
    ( int do_scaling );

    virtual void
    set_active_bounds_fixing
    ( bool allow_fixing );

    virtual void 
    clear_fail_counts
    (void);
    
    virtual void 
    set_eval_limit
    (int eval_limit);

    virtual void 
    set_inner_update_limit
    (int update_limit);
 
    
    //------------------------------------------------------------

    int get_dim();

    int get_n_functions();

    int get_fixed_active_bounds(IVector& fixed_active_bounds) const;


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

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

    
  };

}



#endif