---

NlpResiduals.hh

Go to the documentation of this file.

#ifndef NLPRESIDUALS
#define NLPRESIDUALS

#include "IotrRefCount.hh"
#include "IotrHandle.hh"
#include "NlpIterate.hh"
#include "Nlp.hh"
#include "NlpBounds.hh"
#include "NlpLinsysSol.hh"

#include <iostream>


class IotrVector;
typedef Handle<IotrVector> IotrVectorHandle;

class NlpValues;
class NlpGrads;
class NlpHessian;
class NlpIterate;
class NlpResidualShift;

class NlpResiduals : public IotrRefCount {
protected:
  //@
  IotrVectorHandle mAx_d;

  IotrVectorHandle mV;
  IotrVectorHandle mW;

  IotrVectorHandle mT;
  IotrVectorHandle mU;

  IotrVectorHandle mGammaRes;
  IotrVectorHandle mPhiRes;

  IotrVectorHandle mLambdaRes;
  IotrVectorHandle mPiRes;
public:
  NlpResiduals( IotrVector * y,
                IotrVector * lambda, IotrVector * pi,
                IotrVector * gamma, IotrVector * phi );

  virtual void calcSimpleBounds( NlpIterate &, NlpBounds & );

  virtual void calcResids( NlpValues &, NlpIterate &, NlpBounds & );
  virtual void updateComplementarity( NlpIterate & vars );
  double primalFeasibility() { return mAx_d->infnorm(); }
  //  double dualFeasibility() { return mXr->infnorm(); }
  virtual double complementarity();
  virtual void asMfile( std::ostream& out );
  virtual double simpleStepbound( NlpLinsysSol & step,
                                  NlpBounds & bounds, double maxstep  );
  virtual double getMu( NlpIterate &vars );

  int genConstraintsFeasible();
  int simpleBoundsFeasible();

  IotrVector & Ax_d() { return *mAx_d; } 

  IotrVector & v() { return *mV; }
  IotrVector & w() { return *mW; }

  IotrVector & t() { return *mT; }
  IotrVector & u() { return *mU; }

  IotrVector & gammaRes() { return *mGammaRes; }
  IotrVector & phiRes() { return *mPhiRes; }

  IotrVector & lambdaRes() { return *mLambdaRes; }
  IotrVector & piRes() { return *mPiRes; }

  virtual void complementarityMeasures( double & compMin, double & center,
                                        double & compMax ) const;

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

typedef Handle<NlpResiduals> NlpResidualsHandle;


class NlpResidualShift : public IotrRefCount {
protected:
  double mShiftEquality, mShiftComplementarity;
public:
  NlpResidualShift( double shiftEquality, double shiftComplementarity ) :
    mShiftEquality( shiftEquality ),
    mShiftComplementarity( shiftComplementarity ) {}
  NlpResidualShift & operator=( const NlpResidualShift & s )
  {
    mShiftEquality = s.mShiftEquality;
    mShiftComplementarity = s.mShiftComplementarity;

    return *this;
  }
  double shiftEquality() const { return mShiftEquality; }
  double shiftComplementarity() const { return mShiftComplementarity; }

};

typedef Handle<NlpResidualShift> NlpResidualShiftHandle;


#endif

---