external_packages/qpOASES-3.2.0/src/SolutionAnalysis.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of qpOASES.
3  *
4  * qpOASES -- An Implementation of the Online Active Set Strategy.
5  * Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
6  * Christian Kirches et al. All rights reserved.
7  *
8  * qpOASES is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * qpOASES is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16  * See the GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with qpOASES; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  */
23 
24 
37 #include <qpOASES/extras/SolutionAnalysis.hpp>
38 
39 
41 
42 
43 /*****************************************************************************
44  * P U B L I C *
45  *****************************************************************************/
46 
47 
48 /*
49  * S o l u t i o n A n a l y s i s
50  */
52 {
53 
54 }
55 
56 
57 /*
58  * S o l u t i o n A n a l y s i s
59  */
61 {
62 
63 }
64 
65 
66 /*
67  * ~ S o l u t i o n A n a l y s i s
68  */
70 {
71 
72 }
73 
74 
75 /*
76  * o p e r a t o r =
77  */
79 {
80  if ( this != &rhs )
81  {
82 
83  }
84 
85  return *this;
86 }
87 
88 
89 
90 /*
91  * g e t K k t V i o l a t i o n
92  */
94  real_t* const maxStat, real_t* const maxFeas, real_t* const maxCmpl
95  ) const
96 {
97  int_t i;
98  int_t nV = qp->getNV();
99 
100  if ( qp == 0 )
101  return INFTY;
102 
103  /* setup Hessian matrix array (or pass NULL pointer) */
104  real_t* H_ptr = 0;
105  BooleanType hasIdentityHessian = BT_FALSE;
106 
107  switch( qp->getHessianType() )
108  {
109  case HST_ZERO:
110  break;
111 
112  case HST_IDENTITY:
113  hasIdentityHessian = BT_TRUE;
114  break;
115 
116  default:
117  H_ptr = qp->H->full();
118  if ( qp->usingRegularisation() == BT_TRUE )
119  for( i=0; i<nV; ++i )
120  H_ptr[i*nV+i] -= qp->regVal;
121  }
122 
123  real_t* workingSetB = new real_t[nV];
124  qp->getWorkingSetBounds( workingSetB );
125 
126  /* determine maximum KKT violation */
127  real_t maxKktViolation=0.0, stat=0.0, feas=0.0, cmpl=0.0;
128 
130  H_ptr,qp->g,
131  qp->lb,qp->ub,
132  qp->x,qp->y,
133  stat,feas,cmpl,
134  workingSetB,hasIdentityHessian
135  );
136  if ( workingSetB != 0 )
137  delete[] workingSetB;
138 
139  if ( H_ptr != 0 )
140  delete[] H_ptr;
141 
142  if ( returnvalue != SUCCESSFUL_RETURN )
143  THROWERROR( returnvalue );
144 
145  /* assign return values */
146  if ( maxStat != 0 )
147  *maxStat = stat;
148 
149  if ( maxFeas != 0 )
150  *maxFeas = feas;
151 
152  if ( maxCmpl != 0 )
153  *maxCmpl = cmpl;
154 
155  maxKktViolation = getMax( maxKktViolation,stat );
156  maxKktViolation = getMax( maxKktViolation,feas );
157  maxKktViolation = getMax( maxKktViolation,cmpl );
158 
159  return maxKktViolation;
160 }
161 
162 
163 /*
164  * g e t K k t V i o l a t i o n
165  */
167  real_t* const maxStat, real_t* const maxFeas, real_t* const maxCmpl
168  ) const
169 {
170  int_t i;
171  int_t nV = qp->getNV();
172  int_t nC = qp->getNC();
173 
174  if ( qp == 0 )
175  return INFTY;
176 
177  /* setup Hessian matrix array (or pass NULL pointer) */
178  real_t* H_ptr = 0;
179  BooleanType hasIdentityHessian = BT_FALSE;
180 
181  switch( qp->getHessianType() )
182  {
183  case HST_ZERO:
184  break;
185 
186  case HST_IDENTITY:
187  hasIdentityHessian = BT_TRUE;
188  break;
189 
190  default:
191  H_ptr = qp->H->full();
192  if ( qp->usingRegularisation() == BT_TRUE )
193  for( i=0; i<nV; ++i )
194  H_ptr[i*nV+i] -= qp->regVal;
195  }
196 
197  /* setup constraint matrix array */
198  real_t* A_ptr = qp->A->full();
199 
200  real_t* workingSetB = new real_t[nV];
201  qp->getWorkingSetBounds( workingSetB );
202 
203  real_t* workingSetC = new real_t[nC];
204  qp->getWorkingSetConstraints( workingSetC );
205 
206  /* determine maximum KKT violation */
207  real_t maxKktViolation=0.0, stat=0.0, feas=0.0, cmpl=0.0;
208 
210  H_ptr,qp->g,A_ptr,
211  qp->lb,qp->ub,qp->lbA,qp->ubA,
212  qp->x,qp->y,
213  stat,feas,cmpl,
214  workingSetB,workingSetC,hasIdentityHessian
215  );
216 
217  if ( workingSetC != 0 )
218  delete[] workingSetC;
219 
220  if ( workingSetB != 0 )
221  delete[] workingSetB;
222 
223  if ( A_ptr != 0 )
224  delete[] A_ptr;
225 
226  if ( H_ptr != 0 )
227  delete[] H_ptr;
228 
229  if ( returnvalue != SUCCESSFUL_RETURN )
230  THROWERROR( returnvalue );
231 
232  /* assign return values */
233  if ( maxStat != 0 )
234  *maxStat = stat;
235 
236  if ( maxFeas != 0 )
237  *maxFeas = feas;
238 
239  if ( maxCmpl != 0 )
240  *maxCmpl = cmpl;
241 
242  maxKktViolation = getMax( maxKktViolation,stat );
243  maxKktViolation = getMax( maxKktViolation,feas );
244  maxKktViolation = getMax( maxKktViolation,cmpl );
245 
246  return maxKktViolation;
247 }
248 
249 
250 /*
251  * g e t K k t V i o l a t i o n
252  */
254  real_t* const maxStat, real_t* const maxFeas, real_t* const maxCmpl
255  ) const
256 {
257  return getKktViolation( (QProblem*)qp, maxStat,maxFeas,maxCmpl );
258 }
259 
260 
261 
262 /*
263  * g e t V a r i a n c e C o v a r i a n c e
264  */
266  const real_t* const g_b_bA_VAR, real_t* const Primal_Dual_VAR
267  ) const
268 {
270 }
271 
272 
273 /*
274  * g e t V a r i a n c e C o v a r i a n c e
275  */
277  const real_t* const g_b_bA_VAR, real_t* const Primal_Dual_VAR
278  ) const
279 {
280 
281  /* DEFINITION OF THE DIMENSIONS nV AND nC:
282  * --------------------------------------- */
283  int_t nV = qp->getNV( ); /* dimension of x / the bounds */
284  int_t nC = qp->getNC( ); /* dimension of the constraints */
285  int_t dim = 2*nV+nC; /* dimension of input and output */
286  /* variance-covariance matrix */
287  int_t run1, run2, run3; /* simple run variables (for loops). */
288 
289 
290  /* ALLOCATION OF MEMORY:
291  * --------------------- */
292  real_t* delta_g_cov = new real_t[nV]; /* a covariance-vector of g */
293  real_t* delta_lb_cov = new real_t[nV]; /* a covariance-vector of lb */
294  real_t* delta_ub_cov = new real_t[nV]; /* a covariance-vector of ub */
295  real_t* delta_lbA_cov = new real_t[nC]; /* a covariance-vector of lbA */
296  real_t* delta_ubA_cov = new real_t[nC]; /* a covariance-vector of ubA */
297 
298  returnValue returnvalue; /* the return value */
299  BooleanType Delta_bC_isZero = BT_FALSE; /* (just use FALSE here) */
300  BooleanType Delta_bB_isZero = BT_FALSE; /* (just use FALSE here) */
301 
302 
303 
304  /* ASK FOR THE NUMBER OF FREE AND FIXED VARIABLES:
305  * (ASSUMES THAT ACTIVE SET IS CONSTANT FOR THE
306  * VARIANCE-COVARIANCE EVALUATION)
307  * ----------------------------------------------- */
308  int_t nFR, nFX, nAC;
309 
310  nFR = qp->getNFR( );
311  nFX = qp->getNFX( );
312  nAC = qp->getNAC( );
313 
314 
315  /* ASK FOR THE CORRESPONDING INDEX ARRAYS:
316  * --------------------------------------- */
317  int_t *FR_idx, *FX_idx, *AC_idx;
318 
319  if ( qp->bounds.getFree( )->getNumberArray( &FR_idx ) != SUCCESSFUL_RETURN )
321 
322  if ( qp->bounds.getFixed( )->getNumberArray( &FX_idx ) != SUCCESSFUL_RETURN )
324 
325  if ( qp->constraints.getActive( )->getNumberArray( &AC_idx ) != SUCCESSFUL_RETURN )
327 
328 
329 
330  /* INTRODUCE VARIABLES TO MEASURE THE REACTION OF THE QP-SOLUTION TO
331  * THE VARIANCE-COVARIANCE DISTURBANCE:
332  * ----------------------------------------------------------------- */
333  real_t *delta_xFR = new real_t[nFR];
334  real_t *delta_xFX = new real_t[nFX];
335  real_t *delta_yAC = new real_t[nAC];
336  real_t *delta_yFX = new real_t[nFX];
337 
338  real_t* K = new real_t[dim*dim]; /* matrix to store */
339  /* an intermediate */
340  /* result. */
341 
342  /* SOME INITIALIZATIONS:
343  * --------------------- */
344  for( run1 = 0; run1 < dim*dim; run1++ ){
345  K [run1] = 0.0;
346  Primal_Dual_VAR[run1] = 0.0;
347  }
348 
349 
350  /* ================================================================= */
351 
352  /* FIRST MATRIX MULTIPLICATION (OBTAINS THE INTERMEDIATE RESULT
353  * K := [ ("ACTIVE" KKT-MATRIX OF THE QP)^(-1) * g_b_bA_VAR ]^T )
354  * THE EVALUATION OF THE INVERSE OF THE KKT-MATRIX OF THE QP
355  * WITH RESPECT TO THE CURRENT ACTIVE SET
356  * USES THE EXISTING CHOLESKY AND TQ-DECOMPOSITIONS. FOR DETAILS
357  * cf. THE (protected) FUNCTION determineStepDirection. */
358 
359  for( run3 = 0; run3 < dim; run3++ ){
360 
361 
362  for( run1 = 0; run1 < nV; run1++ ){
363  delta_g_cov [run1] = g_b_bA_VAR[run3*dim+run1];
364  delta_lb_cov [run1] = g_b_bA_VAR[run3*dim+nV+run1]; /* LINE-WISE LOADING OF THE INPUT */
365  delta_ub_cov [run1] = g_b_bA_VAR[run3*dim+nV+run1]; /* VARIANCE-COVARIANCE */
366  }
367  for( run1 = 0; run1 < nC; run1++ ){
368  delta_lbA_cov [run1] = g_b_bA_VAR[run3*dim+2*nV+run1];
369  delta_ubA_cov [run1] = g_b_bA_VAR[run3*dim+2*nV+run1];
370  }
371 
372 
373  /* EVALUATION OF THE STEP:
374  * ------------------------------------------------------------------------------ */
375 
376  returnvalue = qp->determineStepDirection( delta_g_cov, delta_lbA_cov, delta_ubA_cov, delta_lb_cov, delta_ub_cov,
377  Delta_bC_isZero, Delta_bB_isZero, delta_xFX,delta_xFR,
378  delta_yAC,delta_yFX );
379 
380  /* ------------------------------------------------------------------------------ */
381 
382 
383  /* STOP THE ALGORITHM IN THE CASE OF NO SUCCESFUL RETURN:
384  * ------------------------------------------------------ */
385  if ( returnvalue != SUCCESSFUL_RETURN ){
386 
387  delete[] delta_g_cov;
388  delete[] delta_lb_cov;
389  delete[] delta_ub_cov;
390  delete[] delta_lbA_cov;
391  delete[] delta_ubA_cov;
392  delete[] delta_xFR;
393  delete[] delta_xFX;
394  delete[] delta_yAC;
395  delete[] delta_yFX;
396  delete[] K;
397 
399  return returnvalue;
400  }
401 
402 
403 
404  for( run1=0; run1<nFR; run1++ ){
405  run2 = FR_idx[run1];
406  K[run3*dim+run2] = delta_xFR[run1];
407  } /* LINE WISE */
408  for( run1=0; run1<nFX; run1++ ){ /* STORAGE OF THE QP-REACTION */
409  run2 = FX_idx[run1]; /* (uses the index list) */
410  K[run3*dim+run2] = delta_xFX[run1];
411  K[run3*dim+nV+run2] = delta_yFX[run1];
412  }
413  for( run1=0; run1<nAC; run1++ ){
414  run2 = AC_idx[run1];
415  K[run3*dim+2*nV+run2] = delta_yAC[run1];
416  }
417 
418  }
419 
420 
421  /* ================================================================= */
422 
423  /* SECOND MATRIX MULTIPLICATION (OBTAINS THE FINAL RESULT
424  * Primal_Dual_VAR := ("ACTIVE" KKT-MATRIX OF THE QP)^(-1) * K )
425  * THE APPLICATION OF THE KKT-INVERSE IS AGAIN REALIZED
426  * BY USING THE PROTECTED FUNCTION
427  * determineStepDirection */
428 
429  for( run3 = 0; run3 < dim; run3++ ){
430 
431  for( run1 = 0; run1 < nV; run1++ ){
432  delta_g_cov [run1] = K[run3+ run1*dim];
433  delta_lb_cov [run1] = K[run3+(nV+run1)*dim]; /* ROW WISE LOADING OF THE */
434  delta_ub_cov [run1] = K[run3+(nV+run1)*dim]; /* INTERMEDIATE RESULT K */
435  }
436  for( run1 = 0; run1 < nC; run1++ ){
437  delta_lbA_cov [run1] = K[run3+(2*nV+run1)*dim];
438  delta_ubA_cov [run1] = K[run3+(2*nV+run1)*dim];
439  }
440 
441 
442  /* EVALUATION OF THE STEP:
443  * ------------------------------------------------------------------------------ */
444 
445  returnvalue = qp->determineStepDirection( delta_g_cov, delta_lbA_cov, delta_ubA_cov, delta_lb_cov, delta_ub_cov,
446  Delta_bC_isZero, Delta_bB_isZero, delta_xFX,delta_xFR,
447  delta_yAC,delta_yFX);
448 
449 
450  /* ------------------------------------------------------------------------------ */
451 
452 
453  /* STOP THE ALGORITHM IN THE CASE OF NO SUCCESFUL RETURN:
454  * ------------------------------------------------------ */
455  if ( returnvalue != SUCCESSFUL_RETURN ){
456 
457  delete[] delta_g_cov;
458  delete[] delta_lb_cov;
459  delete[] delta_ub_cov;
460  delete[] delta_lbA_cov;
461  delete[] delta_ubA_cov;
462  delete[] delta_xFR;
463  delete[] delta_xFX;
464  delete[] delta_yAC;
465  delete[] delta_yFX;
466  delete[] K;
467 
469  return returnvalue;
470  }
471 
472 
473 
474  for( run1=0; run1<nFR; run1++ ){
475  run2 = FR_idx[run1];
476  Primal_Dual_VAR[run3+run2*dim] = delta_xFR[run1];
477  }
478  for( run1=0; run1<nFX; run1++ ){ /* ROW-WISE STORAGE */
479  run2 = FX_idx[run1]; /* OF THE RESULT. */
480  Primal_Dual_VAR[run3+run2*dim ] = delta_xFX[run1];
481  Primal_Dual_VAR[run3+(nV+run2)*dim] = delta_yFX[run1];
482  }
483  for( run1=0; run1<nAC; run1++ ){
484  run2 = AC_idx[run1];
485  Primal_Dual_VAR[run3+(2*nV+run2)*dim] = delta_yAC[run1];
486  }
487 
488  }
489 
490 
491  /* DEALOCATE MEMORY:
492  * ----------------- */
493 
494  delete[] delta_g_cov;
495  delete[] delta_lb_cov;
496  delete[] delta_ub_cov;
497  delete[] delta_lbA_cov;
498  delete[] delta_ubA_cov;
499  delete[] delta_xFR;
500  delete[] delta_xFX;
501  delete[] delta_yAC;
502  delete[] delta_yFX;
503  delete[] K;
504 
505  return SUCCESSFUL_RETURN;
506 }
507 
508 
509 /*
510  * g e t V a r i a n c e C o v a r i a n c e
511  */
513  const real_t* const g_b_bA_VAR, real_t* const Primal_Dual_VAR
514  ) const
515 {
516  /* Call QProblem variant. */
517  return getVarianceCovariance( (QProblem*)qp,g_b_bA_VAR,Primal_Dual_VAR );
518 }
519 
520 
521 /*
522  * c h e c k C u r v a t u r e O n S e t S
523  */
525 {
526  printf("checkCurvatureOnStronglyActiveConstraints( SQProblem* qp ) not yet implemented for standard qpOASES!\n");
528 }
529 
530 
531 /*
532  * c h e c k C u r v a t u r e O n S t r o n g l y A c t i v e C o n s t r a i n t s
533  */
535 {
536  real_t eps = 1.0e-16;
537  returnValue ret;
538  Bounds saveBounds;
539  QProblemStatus saveStatus;
540  int_t k, neig, nAC, nFX, *FX_idx;
541 
542  nFX = qp->getNFX( );
543  nAC = qp->getNAC( );
544 
545  // If no bounds are active reduced Hessian is positive definite (otherwise qpOASES wouldnt have finished)
546  if( nFX == 0 )
547  return SUCCESSFUL_RETURN;
548 
549  // Get active bounds (deep copy)
550  qp->getBounds( saveBounds );
551  saveBounds.getFixed( )->getNumberArray( &FX_idx );
552 
553  // We have to change the status to modify the active set
554  saveStatus = qp->getStatus();
556 
557  // If a variable is active now but has not been in the previous major iteration remove it
558  for( k=0; k<nFX; k++ )
559  if( getAbs(qp->x[FX_idx[k]]) > eps )
560  if ( qp->bounds.moveFixedToFree( FX_idx[k] ) != SUCCESSFUL_RETURN )
562 
563  // Do a new factorization and check the inertia
564  ret = qp->resetSchurComplement( BT_FALSE );
565  neig = qp->sparseSolver->getNegativeEigenvalues( );
566  if( ret == SUCCESSFUL_RETURN && neig != nAC )
568 
569  // Add all bounds that have been removed
570  for( k=0; k<nFX; k++ )
571  if( qp->bounds.getStatus( FX_idx[k] ) == ST_INACTIVE )
572  qp->bounds.moveFreeToFixed( FX_idx[k], saveBounds.getStatus( FX_idx[k] ) );
573 
574  qp->status = saveStatus;
575  return ret;
576 }
577 
578 
579 //int_t SolutionAnalysis::checkCurvatureOnStronglyActiveConstraints( SQProblemSchur* qp )
580 //{
581  //real_t eps = 1.0e-16;
582  //real_t oldDet, newDet;
583  //int_t oldNS;
584  //returnValue ret;
585  //Bounds saveBounds;
586  //QProblemStatus saveStatus;
587  //int_t nFX, *FX_idx;
588  //int_t k, fail, neig, rmCnt, nAC;
589 
591  //nFX = qp->getNFX( );
592  //nAC = qp->getNAC( );
593  //qp->getBounds( saveBounds );
594  //saveBounds.getFixed( )->getNumberArray( &FX_idx );
595 
597  //if( nFX == 0 )
598  //return 0;
599 
601  //saveStatus = qp->getStatus();
602  //qp->status = QPS_PERFORMINGHOMOTOPY;
603 
606  //rmCnt = 0;
607  //fail = 0;
608  //for( k=0; k<nFX; k++ )
609  //if( getAbs(qp->x[FX_idx[k]]) > eps )
610  //{
611  //oldDet = qp->detS;
612  //oldNS = qp->nS;
613 
614  //ret = qp->removeBound( FX_idx[k], BT_TRUE, BT_FALSE, BT_FALSE );
615  //if( ret != SUCCESSFUL_RETURN )
616  //{
617  //fail = 1;
618  //break;
619  //}
620 
621  //newDet = qp->detS;
622  //rmCnt++;
623 
625  //if( qp->nS == oldNS + 1 )
626  //{
629  //if ( ( oldDet <= 0.0 && newDet <= 0.0 ) || ( oldDet >= 0.0 && newDet >= 0.0 ) )
630  //{
631  //fail = 1;
632  //break;
633  //}
634  //}
636  //else if( qp->nS == oldNS - 1 )
637  //{
640  //if ( ( oldDet <= 0.0 && newDet > 0.0 ) || ( oldDet >= 0.0 && newDet < 0.0 ) )
641  //{
642  //fail = 1;
643  //break;
644  //}
645  //}
647  //else if( qp->nS == 0 )
648  //{
650  //neig = qp->sparseSolver->getNegativeEigenvalues( );
651  //if( neig > nAC )
652  //{
653  //fail = 1;
654  //break;
655  //}
656  //}
657  //else
658  //printf("ERROR!\n");
659  //}
660 
663  //if( fail == 0 )
664  //for( k=0; k<nFX; k++ )
665  //{
666  //ret = qp->addBound( FX_idx[k], saveBounds.getStatus( FX_idx[k] ), BT_TRUE, BT_FALSE );
667  //if( ret != SUCCESSFUL_RETURN && ret != RET_BOUND_ALREADY_ACTIVE )
668  //printf( "addBound() in checkCurvatureOnStronglyActiveConstraints(): %s\n", getGlobalMessageHandler()->getErrorCodeMessage( ret ) );
669  //}
670 
671  //qp->status = saveStatus;
672  //return fail;
673 //}
674 
675 
677 
678 
679 /*
680  * end of file
681  */
int getMax(int x, int y)
real_t g[NVMAX]
Definition: QProblem.h:68
HessianType getHessianType() const
QProblemStatus status
Definition: QProblem.h:82
Indexlist * getFree()
real_t getAbs(real_t x)
virtual returnValue getWorkingSetBounds(real_t *workingSetB)
Implements the online active set strategy for box-constrained QPs.
const double INFTY
virtual real_t * full() const
int getNFX()
Implements the online active set strategy for QPs with varying matrices.
Allows to pass back messages to the calling function.
returnValue getBounds(Bounds *const _bounds) const
returnValue resetSchurComplement(BooleanType allowInertiaCorrection)
int getNV() const
SparseSolver * sparseSolver
#define HST_IDENTITY
virtual returnValue getWorkingSetConstraints(real_t *workingSetC)
#define ST_INACTIVE
int getNAC()
BooleanType usingRegularisation() const
virtual int_t getNegativeEigenvalues()
real_t regVal
Definition: QProblem.h:88
SubjectToStatus getStatus(int i) const
Bounds bounds
Definition: QProblem.h:72
real_t x[NVMAX]
Definition: QProblem.h:77
int getNFR()
returnValue determineStepDirection(const real_t *const delta_g, const real_t *const delta_lbA, const real_t *const delta_ubA, const real_t *const delta_lb, const real_t *const delta_ub, BooleanType Delta_bC_isZero, BooleanType Delta_bB_isZero, real_t *const delta_xFX, real_t *const delta_xFR, real_t *const delta_yAC, real_t *const delta_yFX)
void rhs(const real_t *x, real_t *f)
int getNC() const
real_t getKktViolation(QProblemB *const qp, real_t *const maxStat=0, real_t *const maxFeas=0, real_t *const maxCmpl=0) const
virtual returnValue getWorkingSetBounds(real_t *workingSetB)
real_t y[NVMAX+NCMAX]
Definition: QProblem.h:78
QProblemStatus getStatus() const
#define BT_TRUE
Definition: acado_types.hpp:47
returnValue checkCurvatureOnStronglyActiveConstraints(SQProblemSchur *qp)
returnValue getVarianceCovariance(QProblemB *qp, real_t *g_b_bA_VAR, real_t *Primal_Dual_VAR) const
#define HST_ZERO
Indexlist * getActive()
DenseMatrix * H
Definition: QProblem.h:65
real_t ub[NVMAX]
Definition: QProblem.h:70
real_t lb[NVMAX]
Definition: QProblem.h:69
#define BT_FALSE
Definition: acado_types.hpp:49
Manages working sets of bounds (= box constraints).
Implements the online active set strategy for QPs with varying, sparse matrices.
double real_t
Definition: AD_test.c:10
Implements the online active set strategy for QPs with general constraints.
Indexlist * getFixed()
returnValue moveFreeToFixed(int _number, SubjectToStatus _status)


acado
Author(s): Milan Vukov, Rien Quirynen
autogenerated on Mon Jun 10 2019 12:35:06