ClpQuadraticObjective.hpp

Go to the documentation of this file.

/* $Id: ClpQuadraticObjective.hpp 1665 2011-01-04 17:55:54Z lou $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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