LinearFunction.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURLINEARFUNCTION_H
#define MINOTAURLINEARFUNCTION_H
 
#include "Types.h"
 
namespace Minotaur {
  class LinearFunction;
  class QuadraticFunction;
  class Variable;
 
  typedef LinearFunction *LinearFunctionPtr;
  typedef const LinearFunction *ConstLinearFunctionPtr;
  typedef QuadraticFunction *QuadraticFunctionPtr;
  typedef const QuadraticFunction *ConstQuadraticFunctionPtr;
 
 
  class LinearFunction {
  public:
    LinearFunction();
 
    LinearFunction(const double tol);
 
    LinearFunction(double *a, VariableConstIterator vbeg,
                   VariableConstIterator vend, double tol);
 
 
    ~LinearFunction();
 
    void add(LinearFunctionPtr lf);
 
    void add(ConstLinearFunctionPtr lf);
 
    void addTerm(ConstVariablePtr var, const double a);
 
    void clearAll();
 
    LinearFunctionPtr clone() const;
 
    LinearFunctionPtr cloneWithVars(VariableConstIterator vbeg) const;
 
    LinearFunctionPtr cloneWithVarsPermute(VariableConstIterator vbeg,
                                           UIntVector variableaddress) const;
 
    void computeBounds(double *l, double *u);
 
    double eval(const std::vector<double> &x) const;
 
    double eval(const double *x) const;
 
    void evalGradient(double *grad_f) const;
 
    void fillJac(double *values, int *error);
 
    double getFixVarOffset(VariablePtr v, double val);
 
    size_t getNumTerms() const { return (terms_.size()); }
 
    void getVars(VariableSet *vars);
 
    double getWeight(ConstVariablePtr var) const;
 
    bool hasVar(ConstVariablePtr v) const;
 
    void incTerm(ConstVariablePtr var, const double a);
 
    void minus(LinearFunctionPtr lf);
 
    //void mult(LinearFunctionPtr lf);
 
 
    void multiply(double d);
 
    void prepJac(UInt s, VarSetConstIter vbeg, VarSetConstIter vend);
 
    void removeVar(VariablePtr v, double val);
 
    QuadraticFunctionPtr square();
 
    VariableGroupConstIterator termsBegin() const;
 
    VariableGroupConstIterator termsEnd() const;
 
    void write(std::ostream &out) const;
 
 
    LinearFunctionPtr copyAdd(ConstLinearFunctionPtr l1);
 
    LinearFunctionPtr copyMinus(ConstLinearFunctionPtr l1);
 
    LinearFunctionPtr copyMult(const double c);
 
    QuadraticFunctionPtr copyMult(ConstLinearFunctionPtr l1);
 
  private:
    bool hasChanged_;
 
    DoubleVector off_;
 
    VariableGroup terms_;
 
    double tol_;
 
    LinearFunction(const LinearFunction &l);
 
    LinearFunction &operator=(const LinearFunction &l);
  };
}  //namespace Minotaur
#endif