---

NlpSlack.hh

#ifndef NLPSLACK
#define NLPSLACK

#include "Nlp.hh"
#include "NlpBounds.hh"
#include "ElementGatherSeq.hh"
#include "IotrVector.hh"
#include "FilteredMult.hh"

class NlpBounds;
typedef Handle<NlpBounds> NlpBoundsHandle;

class Functional;
typedef Handle<Functional> FunctionalHandle;

class IotrMask;
typedef Handle<IotrMask>   IotrMaskHandle;

class PrimalDualSystem;

class NlpSlack : public Nlp {
protected:
  IotrVectorCategorizeHandle mClassificationRule;

  FunctionalHandle mFunc;
  IotrVectorHandle mRawXX;
  IotrVectorHandle mYYz;

  ElementGatherHandle mXXfilter;
  IotrMaskHandle mXXmask;
  ElementGatherHandle mXXfixedI;
  IotrVectorHandle mXXfixed;

  ElementGatherHandle mXXlowI;
  ElementGatherHandle mXXuppI;
  // In the original, general constraints
  ElementGatherHandle mLinCC;
  ElementGatherHandle mPinCC;
  ElementGatherHandle mTinCC;
  ElementGatherHandle mUinCC;
  ElementGatherHandle mYYinCC;

  ElementGatherHandle mSinCC;
  ElementGatherHandle mLinS;
  ElementGatherHandle mPinS;
  ElementGatherHandle mYYinS;
  ElementGatherHandle mXXinX, mTinX, mUinX;
  ElementGatherHandle mGGinG, mTinG, UinG;
  ElementGatherHandle mSinC, mTinC, mUinC;
  ElementGatherHandle mYYinY, mTinY, mUinY;
  // Some commonly used transfers that we cache.
  ElementTransferHandle mStoC;
  ElementTransferHandle mTtoC;
  ElementTransferHandle mUtoC;
  ElementTransferHandle mTinXtoC;
  ElementTransferHandle mUinXtoC;
  ElementTransferHandle mXtoRawXX;

  NlpBoundsHandle mBounds;

  virtual void
  distributeSlacks( ElementGatherHandle & hXXinX,
                    ElementGatherHandle & hTinX, ElementGatherHandle & hUinX,
                    ElementGatherHandle & hSinC,
                    ElementGatherHandle & hTinC, ElementGatherHandle & hUinC );
public:
  NlpSlack();
  NlpSlack( IotrVectorCategorize * cat );

  void setClassificationRule( IotrVectorCategorize * cat )
  {
    mClassificationRule = IotrVectorCategorizeHandle(cat);
  }

  //IotrVector & xx() { return *mXX; }
  //IotrVector & yyz() { return *mYYz; }

  ElementGather & l_in_cc()  { return *mLinCC; }
  ElementGather & l_in_c()   { return mBounds->iclow(); }
  ElementGather & p_in_cc()  { return *mPinCC; }
  ElementGather & p_in_c()   { return mBounds->icupp(); }
  ElementGather & yy_in_cc() { return *mYYinCC; }
  ElementGather & y_in_c()   { return mBounds->iequality(); }
  ElementGather & t_in_cc()  { return *mTinCC; }
  ElementGather & u_in_cc()  { return *mUinCC; }
  ElementGather & s_in_cc()  { return *mSinCC; }

  void initialize( IotrVector & rxlow, IotrVector & rxupp,
                   IotrVector & rclow, IotrVector & rcupp,
                   IotrVector & x, IotrVector & yz,
                   double bignum, Functional * c );

  virtual NlpBounds     * getBoundsPtr();
  virtual NlpBounds & bounds();

  virtual NlpIterate  * newVariables();
  virtual NlpIterate  * initialVariables();
  virtual NlpResiduals  * newResiduals();
  virtual NlpLinsys     * newLinsys();
  virtual PrimalDualSystem *
  newPrimalDualSystem( ElementGather * iclow, ElementGather * icupp,
                       ElementGather * ieq,
                       ElementGather * ixlow, ElementGather * ixupp );
  virtual NlpValues     * newValues();
  virtual NlpGrads      * newGrads();
  virtual NlpHessian    * newHessian();
  virtual NlpLocalModel * localModelAt( NlpIterate & );
  virtual void inspect();
  virtual void writeConfiguration( std::ostream & out, char indent[] );
  virtual void applySlacks( double alpha, IotrVector & x, IotrVector & cc,
                            double beta,  IotrVector & c );
  virtual void condenseMultipliers( double alpha, IotrVector & c,
                                    double beta,  IotrVector & cc );
private:
  static void
  classifyGeneralConstraints( IotrVector & cc,
                              IotrVector & rclow, IotrVector & rcupp,
                              ElementGatherHandle & hLinCC,
                              ElementGatherHandle & hPinCC,
                              ElementGatherHandle & hYYinCC,
                              ElementGatherHandle & hTinCC,
                              ElementGatherHandle & hUinCC,
                              IotrVectorCategorize & classificationRule );
  static void
  initializeXXbounds(  IotrVector & rxxlow, IotrVector & rxxupp,
                       IotrVector & rawxx, double bignum,
                       ElementGatherHandle &hIxxlow,
                       IotrVectorHandle & hXXlow,
                       ElementGatherHandle &hIxxupp,
                       IotrVectorHandle & hXXupp,
                       IotrVectorHandle & hRawXX,
                       ElementGatherHandle &hXXfixedI,
                       IotrVectorHandle & hXXfixed,
                       ElementGatherHandle &hXXfilter );
};


typedef Handle<NlpSlack> NlpSlackHandle;


struct DefaultCategorizeGenConstraints : public IotrVectorCategorize {
  double mRelativeTol, mAbsoluteTol, mBignum;
   DefaultCategorizeGenConstraints( double rtol, double atol, double bignum )
    : mRelativeTol(rtol), mAbsoluteTol(atol), mBignum(bignum) {}
  enum{ lowerBound = category1, upperBound = category2,
          equality = category3, violatedLower = category4,
          violatedUpper = category5 };

 virtual void operator()( unsigned char result[], int len, int ncat,
                           const double rclow[],
                           const double *rhs[], int nrhs ) const;
};



class EvaluationContext;
typedef Handle<EvaluationContext> EvaluationContextHandle;

class SymMatrix;
typedef Handle<SymMatrix> SymMatrixHandle;


class NlpSlackLocalModel : public NlpLocalModel {
protected:
  EvaluationContextHandle mEvaluationContext;
  FunctionalHandle mFunc;
  IotrVectorHandle mX;
  NlpSlackHandle mNlp;
public:
  NlpSlackLocalModel( Functional * func,
                      EvaluationContext * ec,
                      NlpSlack * pNlp,
                      NlpIterate & vars );
  virtual void updateValues( NlpValues & values );
  virtual void updateGrads( NlpGrads & grads );
  virtual void updateHessian( NlpHessian & hessian );
};


class NlpSlackValues : public NlpValues {
  friend class NlpSlackLocalModel;
protected:
  IotrVectorHandle mC, mCC;
  double mObj;
public:
  NlpSlackValues( IotrVector * aC, IotrVector * aCC );

  virtual const IotrVector & c() const;
  virtual double obj();

  virtual void inspect();
  virtual void inspectAsMatlab();
};


class NlpSlackGrads : public NlpGrads {
  friend class NlpSlackLocalModel;
protected:
  NlpSlackHandle mNlp;
  ElementGatherHandle mXXfilter;
  ElementGatherHandle mXXinX;
  ElementTransferHandle mSStoC, mTTtoC, mUUtoC;
  ElementTransferHandle mTinXtoC, mUinXtoC, mRawXXtoX;

  IotrVectorHandle mRawGG, mXX, mYY;
  GenMatrixHandle mJJ;
  FunctionalHandle mFunc;
  NlpBoundsHandle mBounds;
public:
  NlpSlackGrads( Functional * func,
                 NlpSlack * pNlp,
                 ElementGather * pXXinX,
                 ElementTransfer * pTinXtoC,
                 ElementTransfer * pUinXtoC,
                 ElementGather * aXXfilter,
                 NlpBounds * bounds );
  
  LinearOperator * condensedJacobianOperator() { 
    return new FilteredMult( mJJ, mXXfilter );
  }
  GenMatrix & rawJacobian() { return *mJJ; }

  virtual void getObjectiveGradient( IotrVector & g );
  virtual void jacobianTransposeMult( double alpha, IotrVector & x,
                                      double beta,  IotrVector & y );
  virtual void jacobianTransposeMult( double alpha, IotrVector & y,
                                      IotrVector & lambda, IotrVector & pi,
                                      IotrVector & gamma,  IotrVector & phi,
                                      double beta,  IotrVector & y );

  virtual void jacobianMult( double alpha, IotrVector & x,
                             double beta,  IotrVector & y );

  virtual void condensedJacobianMult( double alpha, IotrVector & x,
                             double beta,  IotrVector & y );


  virtual void inspect();
  virtual void inspectAsMatlab();
};


class NlpSlackHessian : public NlpHessian {
  friend class NlpSlackLocalModel;
protected:
  IotrMaskHandle mXXmask;
  SymMatrixHandle mH;
  FunctionalHandle mFunc;
  ElementGatherHandle mXXinX;
public:
  NlpSlackHessian( Functional * func, ElementGather * pXXinX,
                   IotrMask * aXXfilter );
  SymMatrix & rawHessian() { return *mH; }

  virtual double lowerBoundEigenvalue();
  virtual void mult(double alpha, IotrVector & x,
                    double beta,  IotrVector & y );
  virtual void inspect();
  virtual void inspectAsMatlab();
};


#endif

---