CGraph.h

Go to the documentation of this file.

//
//    Minotaur -- It's only 1/2 bull
//
//    (C)opyright 2008 - 2025 The Minotaur Team.
//
 
 
#ifndef MINOTAURCGRAPH_H
#define MINOTAURCGRAPH_H
 
#include <stack>
 
#include "Types.h"
#include "NonlinearFunction.h"
#include "OpCode.h"
 
namespace Minotaur {
 
  class CGraph;
  class CNode;
  typedef CGraph *CGraphPtr;
  typedef std::deque<CNode *> CNodeQ;
  typedef std::vector<CNode *> CNodeVector;
  typedef std::map<ConstVariablePtr, CNode *, CompareVariablePtr> VarNodeMap;
 
  class CGraph : public NonlinearFunction {
  public:
    CGraph();
 
    ~CGraph();
 
    void addConst(const double eps, int &err);
 
    NonlinearFunctionPtr clone(int *err) const;
 
    NonlinearFunctionPtr cloneWithVars(VariableConstIterator, int *) const;
 
    // base class method.
    NonlinearFunctionPtr getPersp(VariablePtr z, double eps, int *err) const;
 
    NonlinearFunctionPtr getPersp(VariablePtr z, double eps, int *err,
                                  QuadraticFunctionPtr qf, UInt maxId,
                                  VariableGroup nNonzeroVar, double intTol);
 
    // base class method.
    void computeBounds(double *lb, double *ub, int *error);
 
    // Evaluate at a given array.
    double eval(const double *x, int *err);
 
    // Evaluate gradient at a given array.
    void evalGradient(const double *x, double *grad_f, int *error);
 
    // Evaluate hessian of at a given vector.
    void evalHessian(double mult, const double *x, const LTHessStor *stor,
                     double *values, int *error);
 
    // Fill hessian sparsity.
    void fillHessStor(LTHessStor *stor);
 
    // Finalize hessian offsets, if needed.
    void finalHessStor(const LTHessStor *stor);
 
    // Add gradient values to sparse Jacobian
    void fillJac(const double *x, double *values, int *error);
 
    void finalize();
 
    // base class method.
    double getFixVarOffset(VariablePtr v, double val);
 
    // get node corresponding to variable v
    CNode *getVarNode(VariablePtr v);
 
    CNode *getPerspZNode() { return zNode_; };
 
    // get type of function
    FunctionType getType() const;
 
    // base method
    std::string getNlString(int *err);
 
    size_t getNumNodes();
 
    size_t getHessNz();
 
    bool ifLinear(LinearFunctionPtr lf, UInt pv, double *consVal);
 
    //reset node index every time a node is added or deleted
    void resetNodeIndex();
 
    const CNode *getOut() const;
 
    VariablePtr getVar(const CNode *cnode) const;
 
    // Get variables that exist in this function.
    void getVars(VariableSet *vars);
 
    bool isIdenticalTo(CGraphPtr cg);
 
    // base class method
    bool isSumOfSquares() const;
 
    // multiply by a constant.
    void multiply(double c);
 
    CNode *newNode(OpCode op, CNode *lchild, CNode *rchild);
 
    CNode *newNode(OpCode op, CNode **child, size_t n);
 
    CNode *newNode(double d);
 
    CNode *newNode(int i);
 
    CNode *newNode(VariablePtr v);
 
    // base class method.
    void prepJac(VarSetConstIter vbeg, VarSetConstIter vend);
 
    // base class method.
    void removeVar(VariablePtr v, double val);
 
    void setOut(CNode *node);
 
    // base class method.
    void sqrRoot(int &err);
 
    // base class method.
    void subst(VariablePtr out, VariablePtr in, double rat);
 
    // base class method.
    void varBoundMods(double lb, double ub, VarBoundModVector &mods,
                      SolveStatus *status);
 
    // method to return all the dependent nodes of the cgraph.
    CNodeQ dNodes() { return dq_; };
 
    // display.
    void write(std::ostream &out) const;
 
  private:
    CNodeVector aNodes_;
 
    bool changed_;
 
    CNodeQ dq_;
 
    UIntVector hInds_;
    UInt hNnz_;
    UIntVector hOffs_;
    UIntVector hStarts_;
    UIntVector gOffs_;
 
 
    CNode *oNode_;
 
    CNode *zNode_;
 
    VarNodeMap varNode_;
 
    CNodeQ vq_;
 
    CGraphPtr clone_(int *err) const;
 
    void fwdGrad_(CNode *node);
    void fwdGrad2_(std::stack<CNode *> *st2, CNode *node);
 
    void fillHessInds_(CNode *node, UIntQ *inds);
    void fillHessInds2_(CNode *node, UIntQ *inds);
 
    bool isSOSRec_(CNode *node) const;
 
    void revHess_(int *error);
    void revHess2_(std::stack<CNode *> *st2, double mult, UInt vind,
                   double *values, UInt *nz, int *error);
 
    void grad_(int *error);
 
    void setupHess_(VariablePtr v, CNode *node,
                    std::set<ConstVariablePair, CompareVariablePair> &vps);
 
    void simplifyDq_();
  };
}  //namespace Minotaur
#endif