---

NlpBounds.hh

Go to the documentation of this file.

#ifndef NLPBOUNDS
#define NLPBOUNDS

#include "IotrRefCount.hh"
#include "IotrHandle.hh"
#include "ElementGather.hh"

#include "IotrVector.hh"

// Remove this
class NlpSimpleLinsys;

class NlpIterate;
class IotrVector;
class ElementGather;

typedef Handle<IotrVector>        IotrVectorHandle;
typedef Handle<ElementGather> ElementGatherHandle;

class NlpBounds : public IotrRefCount {
  // Remove this
  friend class NlpSimpleLinsys;

protected:

  IotrVectorHandle     mXlow,   mXupp;
  ElementGatherHandle  mIxlow,  mIxupp;

  IotrVectorHandle     mClow,   mCupp;
  ElementGatherHandle  mIclow,  mIcupp;

  IotrVectorHandle     mCeq;
  ElementGatherHandle  mIceq;

  ElementGatherHandle  mIcineq, mIneq2Cupp, mIneq2Clow;
public:
  NlpBounds( IotrVector * xlow,      ElementGather * ixlow,
            IotrVector * xupp,      ElementGather * ixupp,
            IotrVector * clow,      ElementGather * iclow,
            IotrVector * cupp,      ElementGather * icupp,
            IotrVector * mEquality, ElementGather * iequality);

  static NlpBounds * fromRanges( IotrVector & xlow, IotrVector & xupp,
                                 IotrVector & clow, IotrVector & cupp,
                                 double bignum );

  IotrVector    &   xlow() { return *mXlow;  }
  ElementGather &  ixlow() { return *mIxlow; }
  ElementGather * pixlow() { return HandleAsPointer( mIxlow ); };

  IotrVector    &   xupp() { return *mXupp;  }
  ElementGather &  ixupp() { return *mIxupp; }
  ElementGather * pixupp() { return HandleAsPointer( mIxupp ); };

  IotrVector    &   clow() { return *mClow;  }
  ElementGather &  iclow() { return *mIclow; }
  ElementGather * piclow() { return HandleAsPointer( mIclow ); };

  IotrVector    &   cupp() { return *mCupp;  }
  ElementGather &  icupp() { return *mIcupp; }
  ElementGather * picupp() { return HandleAsPointer( mIcupp ); };

  IotrVector    &   equality() { return *mCeq;  }
  ElementGather &  iequality() { return *mIceq; }
  ElementGather * piequality() { return HandleAsPointer( mIceq ); };

  ElementGather & iinequality() { return *mIcineq; }

  ElementGather & ineq2Clow() { return *mIneq2Clow; }
  ElementGather & ineq2Cupp() { return *mIneq2Cupp; }
  int nx() { return mIxupp->nx(); }
  int nxupp() { return mIxupp->my(); }
  int nxlow() { return mIxlow->my(); }

  int mcupp() { return mIcupp->my(); }
  int mclow() { return mIclow->my(); }
  int mequality() { return mIceq->my(); }
  int mcon() { return mIceq->nx(); }
  int my() { return mIceq->my(); }
  int mz() { return mIcineq->my(); }

  IotrVector * newDualVector()   { return mIclow->domainVector(); }
  IotrVector * newPrimalVector() { return mIxlow->domainVector(); }
  virtual void condenseMultipliers( IotrVector & y, IotrVector & lambda,
                                    IotrVector & pi, IotrVector & yz );
  virtual void inspect();
};

struct BasicCategorizeConstraints : public IotrVectorCategorize {
  double mBignum;
  BasicCategorizeConstraints( double bignum ) : mBignum(bignum) {}
  enum{ lowerBound = category1, upperBound = category2,
          equality = category3 };
  void operator()( unsigned char result[], int len, int ncat,
                   const double rxlow[], const double *rhs[], int nrhs ) const;
};

struct BoundsFindFixed : public IotrVectorCategorize {
  virtual void operator()( unsigned char cat[], int len, int ncat,
                           const double self[],
                           const double *rhs[], int nrhs ) const;
};

typedef Handle<NlpBounds> NlpBoundsHandle;

#endif

---