SumBundle.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_SUMBUNDLE_HXX
#define CONICBUNDLE_SUMBUNDLE_HXX


#include <map>
#include "VariableMetric.hxx"
#include "AffineFunctionTransformation.hxx"

namespace ConicBundle {





class SumBundle : public CBout
{
public:
  enum Mode {
    root, 
    child, 
    inactive, 
    unavailable 
  };

  SumBundle();
  SumBundle(const SumBundle& sb);
  ~SumBundle();

  void init(const SumBundle& sb);

  void synchronize_ids(CH_Matrix_Classes::Integer new_modification_id,
                       CH_Matrix_Classes::Integer new_center_id,
                       CH_Matrix_Classes::Integer old_center_id,
                       CH_Matrix_Classes::Integer new_cand_id,
                       CH_Matrix_Classes::Integer old_cand_id,
                       CH_Matrix_Classes::Integer new_prex_id=0);

  bool has_bundle_for(FunctionTask ft) const;

  bool has_bundle_data() const;

  int bundle_size(FunctionTask ft) const;

  bool has_roots() const;

  bool has_working_roots() const;

  bool active() const;

  bool has_contributions() const;


  // gets the corresponding valid flag (call only if a has_bundle_for(ft)==true)
  //bool get_valid(FunctionTask ft) const;

  Mode get_mode(FunctionTask ft) const;

  CH_Matrix_Classes::Real get_function_factor(FunctionTask ft) const;

  CH_Matrix_Classes::Integer get_n_contributors(FunctionTask ft) const;

  const MinorantBundle& get_bundle(FunctionTask ft) const;

  const CH_Matrix_Classes::Matrix& get_coeff(FunctionTask ft) const;

  const MinorantPointer& get_aggregate(FunctionTask ft) const;

  const MinorantPointer& get_cand_minorant(FunctionTask ft) const;

  int eval_model(CH_Matrix_Classes::Real& lb,
                 CH_Matrix_Classes::Integer yid,
                 const CH_Matrix_Classes::Matrix& y,
                 CH_Matrix_Classes::Real nullstep_bound,
                 CH_Matrix_Classes::Real relprec) const;

  CH_Matrix_Classes::Real lb_model(CH_Matrix_Classes::Integer yid,
                                   const CH_Matrix_Classes::Matrix& y) const;

  int get_local_model_aggregate(MinorantPointer& aggregate,
                                CH_Matrix_Classes::Real factor=1.,
                                const AffineFunctionTransformation* aft=0) const;

  int get_contributed_model_aggregate(MinorantPointer& aggregate,
                                      CH_Matrix_Classes::Real factor=1.,
                                      const AffineFunctionTransformation* aft=0) const;
  
  int call_primal_extender(PrimalExtender& prex,
                           CH_Matrix_Classes::Integer prex_id,
                           FunctionTask ft);

  int apply_modification(const GroundsetModification& gsmdf,
                         CH_Matrix_Classes::Integer mod_id,
                         MinorantExtender* mex,
                         FunctionTask ft);

private:
  friend class SumBundleHandler;

  class BData: public CBout
  {
  public:
    Mode mode;
    
    CH_Matrix_Classes::Integer n_contributors;

    CH_Matrix_Classes::Real function_factor;

    CH_Matrix_Classes::Matrix coeff;

    MinorantBundle bundle;

    MinorantPointer aggregate;

    MinorantPointer cand_minorant;

    BData();
    BData(const BData& bd);
    ~BData();
    void clear(CH_Matrix_Classes::Real fun_factor=1.);
    void init(const BData& bd);
    void synchronize_ids(CH_Matrix_Classes::Integer new_modification_id,
                         CH_Matrix_Classes::Integer new_center_id,
                         CH_Matrix_Classes::Integer old_center_id,
                         CH_Matrix_Classes::Integer new_cand_id,
                         CH_Matrix_Classes::Integer old_cand_id,
                         CH_Matrix_Classes::Integer new_prex_id=0);
    BData& operator=(const BData& bd);

    int eval_model(CH_Matrix_Classes::Real& lb,CH_Matrix_Classes::Integer yid,const CH_Matrix_Classes::Matrix& y) const;

    CH_Matrix_Classes::Real lb_model(CH_Matrix_Classes::Integer yid,const CH_Matrix_Classes::Matrix& y) const;

    int get_model_aggregate(MinorantPointer& aggregate,
                            CH_Matrix_Classes::Real factor=1.,
                            const AffineFunctionTransformation* aft=0) const;

    int call_primal_extender(PrimalExtender& prex,
                             CH_Matrix_Classes::Integer prex_id);

  int apply_modification(const GroundsetModification& gsmdf,
                         CH_Matrix_Classes::Integer mod_id,
                         MinorantExtender* mex);
  };

  typedef std::vector<BData> BDataVector;
  
  BDataVector bdata;
  
  void clear();

  void clear(FunctionTask ft);

  SumBundle& operator=(const SumBundle& sb);

  void init(FunctionTask ft,CH_Matrix_Classes::Real fun_factor=1.);

  void take_control(Mode mode);

  // allows to set the corresponding valid flag (call only if a has_bundle_for(ft)==true)
  //bool& set_valid(FunctionTask ft);

  Mode& set_mode(FunctionTask ft);

  CH_Matrix_Classes::Real& set_function_factor(FunctionTask ft);

  CH_Matrix_Classes::Integer& set_n_contributors(FunctionTask ft);

  MinorantBundle& set_bundle(FunctionTask ft);

  CH_Matrix_Classes::Matrix& set_coeff(FunctionTask ft);

  MinorantPointer& set_aggregate(FunctionTask ft);

  MinorantPointer& set_cand_minorant(FunctionTask ft);

  const PrimalData* get_approximate_primal(FunctionTask ft) const;


};



}

#endif