AffineFunctionTransformation.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_AFFINEFUNCTIONTRANSFORMATION_HXX
#define CONICBUNDLE_AFFINEFUNCTIONTRANSFORMATION_HXX

#include "CBout.hxx"
#include "CBSolver.hxx"
#include "MinorantPointer.hxx"
#include "AFTModification.hxx"
#include "GroundsetModification.hxx"


namespace ConicBundle {



//-----------------------------------------------------------------------------
//                                AffineFunctionTransformation
//-----------------------------------------------------------------------------

  class AffineFunctionTransformation: public CBout, public FunctionObject
  {
  private: 
    CH_Matrix_Classes::Real fun_coeff; 
    CH_Matrix_Classes::Real fun_offset;  
    CH_Matrix_Classes::Matrix* linear_cost;   
    CH_Matrix_Classes::Matrix* arg_offset;    
    CH_Matrix_Classes::Sparsemat* arg_trafo;  

    MinorantPointer constant_minorant; 
    
    mutable GroundsetModification local_gsmdf; 

    bool model_calls_delete; 

  public:
    virtual int init(CH_Matrix_Classes::Real fun_coeff=1.,
                     CH_Matrix_Classes::Real fun_offset=0.,
                     CH_Matrix_Classes::Matrix* linear_cost=0,
                     CH_Matrix_Classes::Matrix* arg_offset=0,
                     CH_Matrix_Classes::Sparsemat* arg_trafo=0,
                     bool model_calls_delete=true);

    AffineFunctionTransformation(CH_Matrix_Classes::Real in_fun_coeff=1.,
                                 CH_Matrix_Classes::Real in_fun_offset=0.,
                                 CH_Matrix_Classes::Matrix* in_linear_cost=0,
                                 CH_Matrix_Classes::Matrix* in_arg_offset=0,
                                 CH_Matrix_Classes::Sparsemat* in_arg_trafo=0,
                                 bool in_model_calls_delete=true,
                                 CBout* cbo=0,int incr=-1):
      CBout(cbo,incr),linear_cost(0),arg_offset(0),arg_trafo(0)
    {init(in_fun_coeff,in_fun_offset,in_linear_cost,in_arg_offset,in_arg_trafo,in_model_calls_delete);}

    virtual ~AffineFunctionTransformation();

    bool get_model_calls_delete(){return model_calls_delete;}
    
    void set_model_calls_delete(bool mcd){model_calls_delete=mcd;}
    
    bool argument_changes() const
    {if ((arg_offset!=0)||(arg_trafo!=0)) return true; return false;}

    bool sparse_argument_changes() const
    { return ((arg_trafo!=0)&&(3*arg_trafo->get_rowinfo().rowdim()<=arg_trafo->rowdim()));}

    bool scaled_index_subset(const CH_Matrix_Classes::Indexmatrix* col_ind,
                             const CH_Matrix_Classes::Indexmatrix* row_ind) const;

    bool scaled_index(CH_Matrix_Classes::Integer& mapped_index,
                      CH_Matrix_Classes::Real& coeff,
                      CH_Matrix_Classes::Integer index) const;

    CH_Matrix_Classes::Real get_fun_coeff() const 
    {return fun_coeff;}

    CH_Matrix_Classes::Real& set_fun_coeff() 
    {return fun_coeff;}
    
    CH_Matrix_Classes::Real get_fun_offset() const 
    {return fun_offset;}

    CH_Matrix_Classes::Real& set_fun_offset()
    {return fun_offset;}
    
    const CH_Matrix_Classes::Matrix* get_linear_cost() const
    {return linear_cost;}

    const CH_Matrix_Classes::Matrix* get_arg_offset() const 
    {return arg_offset;}
    
    const CH_Matrix_Classes::Sparsemat* get_arg_trafo() const 
    {return arg_trafo;}
    
    CH_Matrix_Classes::Real get_linear_cost(CH_Matrix_Classes::Integer i) const
    {
      if (i<0) return fun_offset;
      if (linear_cost) return (*linear_cost)(i); 
      return 0.;
    }

    const MinorantPointer& get_constant_minorant() const{
      return constant_minorant;
    }

    CH_Matrix_Classes::Integer from_dim() const
    {
      if (arg_trafo) 
        return arg_trafo->coldim();
      if (linear_cost) 
        return linear_cost->rowdim(); 
      if (arg_offset) //arg_trafo==NULL is the identity, so this is ok
        return arg_offset->rowdim();
      return -1; //no information on the dimension
    } 

    CH_Matrix_Classes::Integer to_dim() const
    {
      if (arg_trafo) 
        return arg_trafo->rowdim();
      if (arg_offset) 
        return arg_offset->rowdim();
      if (linear_cost) //arg_trafo==NULL is the identity, so this is ok 
        return linear_cost->rowdim(); 
      return -1; //no information on the dimension
    } 

    int copy_traforows(CH_Matrix_Classes::Matrix& copy_to,
                       const CH_Matrix_Classes::Matrix& copy_from) const;

    const CH_Matrix_Classes::Matrix&
    transform_argument(CH_Matrix_Classes::Matrix& transformed_y, 
                       CH_Matrix_Classes::Real& transformed_offset,
                       const CH_Matrix_Classes::Matrix& input_y) const; 
    

    const CH_Matrix_Classes::Matrix&
    modified_transform_argument(CH_Matrix_Classes::Matrix& transformed_y, 
                                const CH_Matrix_Classes::Matrix& input_y,
                                const AFTModification* aftmdf,
                                const GroundsetModification& gsmdf) const; 
    

    CH_Matrix_Classes::Real objective_value(CH_Matrix_Classes::Real offset, 
                                                 CH_Matrix_Classes::Real function_value) const
    {return offset+fun_coeff*function_value;}

    int transform_minorant(MinorantPointer& out_minorant, 
                           const MinorantPointer& in_minorant, 
                           CH_Matrix_Classes::Real alpha=1.,
                           bool add_trafo_minorant=false,
                           const CH_Matrix_Classes::Indexmatrix* provided_row_indices=0,
                           const CH_Matrix_Classes::Indexmatrix* needed_column_indices=0) const;
    
    int transform_minorants(MinorantBundle& out_minorants, 
                     const MinorantBundle& in_minorants,  
                     CH_Matrix_Classes::Real alpha=1.) const;
    


    int qp_cost_indices(CH_Matrix_Classes::Indexmatrix& provide_row_indices,
                        const CH_Matrix_Classes::Indexmatrix* needed_col_indices) const;
 
    int scaling_indices(CH_Matrix_Classes::Indexmatrix& row_indices,
                        const CH_Matrix_Classes::Indexmatrix& col_indices) const;

    int add_diagonal_scaling(CH_Matrix_Classes::Matrix& diagscale,
                             const CH_Matrix_Classes::Indexmatrix* indices,
                             CH_Matrix_Classes::Real alpha,
                             const CH_Matrix_Classes::Matrix& in_diagscale) const;
    
    const GroundsetModification* 
    analyze_modification(bool& minorant_trafo_differs,
                         const AFTModification* aftmdf,
                         const GroundsetModification& gsmdf) const;

    int 
    apply_modification(const AFTModification* aftmdf,
                       const GroundsetModification& gsmdf);

      
    virtual std::ostream& output_aft_data(std::ostream& out) const;


  };




}

#endif