/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpQuadraticObjective.hpp

Go to the documentation of this file.

// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef ClpQuadraticObjective_H
#define ClpQuadraticObjective_H

#include "ClpObjective.hpp"
#include "CoinPackedMatrix.hpp"

//#############################################################################

class ClpQuadraticObjective : public ClpObjective {
  
public:
  

  
  virtual double * gradient(const ClpSimplex * model,
                            const double * solution, double & offset,bool refresh,
                            int includeLinear=2);

  virtual double reducedGradient(ClpSimplex * model, double * region,
                                 bool useFeasibleCosts);
  virtual double stepLength(ClpSimplex * model,
                            const double * solution,
                            const double * change,
                            double maximumTheta,
                            double & currentObj,
                            double & predictedObj,
                            double & thetaObj);
  virtual double objectiveValue(const ClpSimplex * model, const double * solution) const ;
  virtual void resize(int newNumberColumns) ; 
  virtual void deleteSome(int numberToDelete, const int * which) ; 
  virtual void reallyScale(const double * columnScale) ;
  virtual int markNonlinear(char * which);
  
  
  


  ClpQuadraticObjective(); 
  
  ClpQuadraticObjective(const double * linearObjective, int numberColumns,
                        const CoinBigIndex * start,
                        const int * column, const double * element,
                        int numberExtendedColumns_=-1);
  
  ClpQuadraticObjective(const ClpQuadraticObjective & rhs,int type=0);
  ClpQuadraticObjective (const ClpQuadraticObjective &rhs,int numberColumns, 
                                      const int * whichColumns) ;
  
  ClpQuadraticObjective & operator=(const ClpQuadraticObjective& rhs);
  
  virtual ~ClpQuadraticObjective ();

  virtual ClpObjective * clone() const;
  virtual ClpObjective * subsetClone (int numberColumns, 
                                      const int * whichColumns) const;
 
  void loadQuadraticObjective(const int numberColumns, 
                              const CoinBigIndex * start,
                              const int * column, const double * element,
                              int numberExtendedColumns=-1);
  void loadQuadraticObjective (  const CoinPackedMatrix& matrix);
  void deleteQuadraticObjective();



   inline CoinPackedMatrix * quadraticObjective() const     { return quadraticObjective_; }
   inline double * linearObjective() const     { return objective_; }
  inline int numberExtendedColumns() const
  {return numberExtendedColumns_;}
  inline int numberColumns() const
  {return numberColumns_;}
  inline bool fullMatrix() const
  { return fullMatrix_;}

  //---------------------------------------------------------------------------
  
private:
  CoinPackedMatrix * quadraticObjective_;
  double * objective_;
  double * gradient_;
  int numberColumns_;
  int numberExtendedColumns_;
  bool fullMatrix_;
};

#endif

---