symbolic_index_list.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of ACADO Toolkit.
3  *
4  * ACADO Toolkit -- A Toolkit for Automatic Control and Dynamic Optimization.
5  * Copyright (C) 2008-2014 by Boris Houska, Hans Joachim Ferreau,
6  * Milan Vukov, Rien Quirynen, KU Leuven.
7  * Developed within the Optimization in Engineering Center (OPTEC)
8  * under supervision of Moritz Diehl. All rights reserved.
9  *
10  * ACADO Toolkit is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 3 of the License, or (at your option) any later version.
14  *
15  * ACADO Toolkit is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with ACADO Toolkit; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  *
24  */
25 
26 
27 
35 #include <acado/utils/acado_utils.hpp>
36 #include <acado/symbolic_operator/symbolic_operator.hpp>
37 
38 
39 
40 BEGIN_NAMESPACE_ACADO
41 
42 
43 
44 
45 SymbolicIndexList::SymbolicIndexList(){
46 
47  numberOfOperators = 0;
48  comp = 0;
49  expression = 0;
50 
51  int run1 ;
52  const int numberOfVariableTypes = 11 ;
53 
54  entryExists = new BooleanType*[numberOfVariableTypes];
55 
56  nC = 1;
57  cExist = (BooleanType*)calloc( nC, sizeof(BooleanType) );
58  cIdx = (int**)calloc( nC, sizeof(int*) );
59  cDim = (uint*)calloc( nC, sizeof(uint) );
60 
61  cExist[0] = BT_FALSE;
62  cIdx [0] = 0;
63  cDim [0] = 0;
64 
65  maxNumberOfEntries = new int[numberOfVariableTypes];
66 
67  variableCounter = 0;
68  variableIndex = new int*[numberOfVariableTypes];
69  variableScale = new double*[numberOfVariableTypes];
70 
71  for( run1 = 0; run1 < numberOfVariableTypes; run1++ ){
72 
73  maxNumberOfEntries[run1] = 0;
74  entryExists[run1] = 0;
75  variableIndex[run1] = 0;
76  variableScale[run1] = 0;
77  }
78 }
79 
80 
81 SymbolicIndexList::~SymbolicIndexList(){
82 
83  int run1;
84 
85  if( expression != NULL ){
86  for( run1 = 0; run1 < numberOfOperators; run1++ ){
87  delete expression[run1];
88  }
89  free(expression);
90  }
91  if( comp != NULL ){
92  free(comp);
93  }
94 
95  const int numberOfVariableTypes = 11 ;
96 
97  for( run1 = 0; run1 < numberOfVariableTypes; run1++ ){
98 
99  if( maxNumberOfEntries[run1] > 0 ){
100 
101  free(entryExists [run1]);
102  free(variableIndex[run1]);
103  free(variableScale[run1]);
104  }
105  }
106 
107  free(cExist);
108 
109  for( run1 = 0; run1 < nC; run1++ ){
110  if( cIdx[run1] != 0 )
111  delete[] cIdx[run1];
112  }
113  free(cIdx);
114  free(cDim);
115 
116  delete[] maxNumberOfEntries;
117  delete[] variableIndex;
118  delete[] variableScale;
119  delete[] entryExists;
120 }
121 
122 
123 
124 SymbolicIndexList::SymbolicIndexList( const SymbolicIndexList &arg ){
125 
126  int run1;
127 
128  numberOfOperators = arg.numberOfOperators;
129 
130  if( arg.expression != NULL ){
131 
132  if( numberOfOperators > 0 ){
133  expression = (Operator**)calloc(numberOfOperators,sizeof(Operator*));
134  }
135  else{
136  expression = NULL;
137  }
138  for( run1 = 0; run1 < numberOfOperators; run1++ ){
139  expression[run1] = arg.expression[run1]->clone();
140  }
141  }
142  else{
143  expression = NULL;
144  }
145 
146  if( arg.comp != NULL ){
147  if( numberOfOperators > 0 ){
148  comp = (int*)calloc(numberOfOperators,sizeof(int));
149  }
150  else{
151  comp = NULL;
152  }
153  for( run1 = 0; run1 < numberOfOperators; run1++ ){
154  comp[run1] = arg.comp[run1];
155  }
156  }
157  else{
158  comp = NULL;
159  }
160 
161  int run2 ;
162  const int numberOfVariableTypes = 11 ;
163 
164  entryExists = new BooleanType*[numberOfVariableTypes];
165  variableIndex = new int*[numberOfVariableTypes];
166  variableScale = new double*[numberOfVariableTypes];
167 
168 
169  maxNumberOfEntries = new int[numberOfVariableTypes];
170 
171  for( run1 = 0; run1 < numberOfVariableTypes; run1++ ){
172 
173  maxNumberOfEntries[run1] = arg.maxNumberOfEntries[run1];
174 
175  if( maxNumberOfEntries[run1] > 0 ){
176  entryExists [run1] = (BooleanType*)calloc(maxNumberOfEntries[run1],
177  sizeof(BooleanType));
178  variableIndex [run1] = (int*)calloc(maxNumberOfEntries[run1],
179  sizeof(int));
180  variableScale [run1] = (double*)calloc(maxNumberOfEntries[run1],
181  sizeof(double));
182  }
183  else{
184  entryExists [run1] = 0;
185  variableIndex[run1] = 0;
186  variableScale[run1] = 0;
187  }
188  for( run2 = 0; run2 < maxNumberOfEntries[run1]; run2++ ){
189  entryExists [run1][run2] = arg.entryExists [run1][run2];
190  variableIndex[run1][run2] = arg.variableIndex[run1][run2];
191  variableScale[run1][run2] = arg.variableScale[run1][run2];
192  }
193  }
194 
195  nC = arg.nC;
196  cExist = (BooleanType*)calloc( nC, sizeof(BooleanType) );
197  cIdx = (int**)calloc( nC, sizeof(int*) );
198  cDim = (uint*)calloc( nC, sizeof(uint) );
199 
200  for( run1 = 0; run1 < nC; run1++ ){
201  cExist[run1] = arg.cExist[run1];
202  cDim[run1] = arg.cDim[run1];
203  if( arg.cIdx[run1] != 0 ){
204  cIdx[run1] = new int[cDim[run1]];
205  for( run2 = 0; run2 < (int) cDim[run1]; run2++ )
206  cIdx[run1][run2] = arg.cIdx[run1][run2];
207  }
208  else{
209  cIdx[run1] = 0;
210  }
211  }
212 
213  variableCounter = arg.variableCounter;
214 }
215 
216 
217 
218 SymbolicIndexList& SymbolicIndexList::operator=( const SymbolicIndexList &arg ){
219 
220  if( this != &arg ){
221 
222  int run1;
223 
224  if( expression != NULL ){
225  for( run1 = 0; run1 < numberOfOperators; run1++ ){
226  delete expression[run1];
227  }
228  free(expression);
229  }
230 
231  if( comp != NULL ){
232  free(comp);
233  }
234 
235  int run2 ;
236  const int numberOfVariableTypes = 11 ;
237 
238  for( run1 = 0; run1 < numberOfVariableTypes; run1++ ){
239 
240  if( maxNumberOfEntries[run1] > 0 ){
241 
242  free(entryExists [run1]);
243  free(variableIndex[run1]);
244  free(variableScale[run1]);
245  }
246  }
247 
248  delete[] maxNumberOfEntries;
249  delete[] variableIndex;
250  delete[] variableScale;
251  delete[] entryExists;
252 
253  free(cExist);
254 
255  for( run1 = 0; run1 < nC; run1++ ){
256  if( cIdx[run1] != 0 )
257  delete[] cIdx[run1];
258  }
259  free(cIdx);
260  free(cDim);
261 
262  entryExists = new BooleanType*[numberOfVariableTypes];
263  variableIndex = new int*[numberOfVariableTypes];
264  variableScale = new double*[numberOfVariableTypes];
265 
266  maxNumberOfEntries = new int[numberOfVariableTypes];
267 
268  for( run1 = 0; run1 < numberOfVariableTypes; run1++ ){
269 
270  maxNumberOfEntries[run1] = arg.maxNumberOfEntries[run1];
271 
272  if( maxNumberOfEntries[run1] > 0 ){
273  entryExists [run1] = (BooleanType*)calloc(maxNumberOfEntries[run1],
274  sizeof(BooleanType));
275  variableIndex [run1] = (int*)calloc(maxNumberOfEntries[run1],
276  sizeof(int));
277  variableScale [run1] = (double*)calloc(maxNumberOfEntries[run1],
278  sizeof(double));
279  }
280  else{
281  entryExists [run1] = 0;
282  variableIndex[run1] = 0;
283  variableScale[run1] = 0;
284  }
285 
286  for( run2 = 0; run2 < maxNumberOfEntries[run1]; run2++ ){
287  entryExists [run1][run2] = arg.entryExists [run1][run2];
288  variableIndex[run1][run2] = arg.variableIndex[run1][run2];
289  variableScale[run1][run2] = arg.variableScale[run1][run2];
290  }
291  }
292 
293  nC = arg.nC;
294  cExist = (BooleanType*)calloc( nC, sizeof(BooleanType) );
295  cIdx = (int**)calloc( nC, sizeof(int*) );
296  cDim = (uint*)calloc( nC, sizeof(uint) );
297 
298  for( run1 = 0; run1 < nC; run1++ ){
299  cExist[run1] = arg.cExist[run1];
300  cDim[run1] = arg.cDim[run1];
301  if( arg.cIdx[run1] != 0 ){
302  cIdx[run1] = new int[cDim[run1]];
303  for( run2 = 0; run2 < (int) cDim[run1]; run2++ )
304  cIdx[run1][run2] = arg.cIdx[run1][run2];
305  }
306  else{
307  cIdx[run1] = 0;
308  }
309  }
310 
311  variableCounter = arg.variableCounter;
312 
313  numberOfOperators = arg.numberOfOperators;
314 
315  if( arg.expression != NULL ){
316  if( numberOfOperators > 0 ){
317  expression = (Operator**)calloc(numberOfOperators,sizeof(Operator*));
318  }
319  else{
320  expression = NULL;
321  }
322  for( run1 = 0; run1 < numberOfOperators; run1++ ){
323  expression[run1] = arg.expression[run1]->clone();
324  }
325  }
326  else{
327  expression = NULL;
328  }
329 
330  if( arg.comp != NULL ){
331  if( numberOfOperators > 0 ){
332  comp = (int*)calloc(numberOfOperators,sizeof(int));
333  }
334  else{
335  comp = NULL;
336  }
337  for( run1 = 0; run1 < numberOfOperators; run1++ ){
338  comp[run1] = arg.comp[run1];
339  }
340  }
341  else{
342  comp = NULL;
343  }
344 
345  }
346 
347  return *this;
348 }
349 
350 
351 //
352 // PUBLIC MEMBER FUNCTIONS:
353 // ------------------------
354 
355 
356 int SymbolicIndexList::addOperatorPointer( Operator* intermediateOperator,
357  int comp_ ){
358 
359  expression = (Operator**)realloc(expression,
360  (numberOfOperators+1)*sizeof(Operator*));
361  expression[numberOfOperators] = intermediateOperator->clone();
362 
363  comp = (int*)realloc(comp,(numberOfOperators+1)*sizeof(int));
364  comp[numberOfOperators] = comp_;
365 
366  numberOfOperators++;
367 
368  return numberOfOperators-1;
369 }
370 
371 
372 returnValue SymbolicIndexList::getOperators( Operator **sub, int *comp_, int *n ){
373 
374  while( n[0] < numberOfOperators ){
375 
376  sub [*n] = expression[*n]->clone();
377  comp_ [*n] = comp[*n];
378  *n = *n+1;
379  }
380 
381  return SUCCESSFUL_RETURN;
382 }
383 
384 
385 BooleanType SymbolicIndexList::addNewElement( VariableType variableType_, int index_ ){
386 
387  switch(variableType_){
388 
389  case VT_DIFFERENTIAL_STATE:
390  if( index_ >= maxNumberOfEntries[0] ){
391 
392  entryExists[0] = (BooleanType*)realloc(entryExists[0],
393  (index_+1)*sizeof(BooleanType));
394  variableIndex[0] = (int*)realloc(variableIndex[0],
395  (index_+1)*sizeof(int));
396  variableScale[0] = (double*)realloc(variableScale[0],
397  (index_+1)*sizeof(double));
398 
399  int run1;
400  for( run1 = maxNumberOfEntries[0]; run1 < index_+1; run1++ ){
401  entryExists[0] [run1] = BT_FALSE;
402  variableIndex[0][run1] = -1 ;
403  variableScale[0][run1] = 1.0 ;
404  }
405  maxNumberOfEntries[0] = index_+1;
406  }
407  if( entryExists[0][index_] == BT_TRUE ){
408  return BT_FALSE;
409  }
410  entryExists[0][index_] = BT_TRUE;
411  return BT_TRUE;
412 
413 
414  case VT_ALGEBRAIC_STATE:
415  if( index_ >= maxNumberOfEntries[1] ){
416 
417  entryExists[1] = (BooleanType*)realloc(entryExists[1],
418  (index_+1)*sizeof(BooleanType));
419  variableIndex[1] = (int*)realloc(variableIndex[1],
420  (index_+1)*sizeof(int));
421  variableScale[1] = (double*)realloc(variableScale[1],
422  (index_+1)*sizeof(double));
423 
424  int run1;
425  for( run1 = maxNumberOfEntries[1]; run1 < index_+1; run1++ ){
426  entryExists[1] [run1] = BT_FALSE;
427  variableIndex[1][run1] = -1 ;
428  variableScale[1][run1] = 1.0 ;
429  }
430  maxNumberOfEntries[1] = index_+1;
431  }
432  if( entryExists[1][index_] == BT_TRUE ){
433  return BT_FALSE;
434  }
435  entryExists[1][index_] = BT_TRUE;
436  return BT_TRUE;
437 
438 
439  case VT_CONTROL:
440  if( index_ >= maxNumberOfEntries[2] ){
441 
442  entryExists[2] = (BooleanType*)realloc(entryExists[2],
443  (index_+1)*sizeof(BooleanType));
444  variableIndex[2] = (int*)realloc(variableIndex[2],
445  (index_+1)*sizeof(int));
446  variableScale[2] = (double*)realloc(variableScale[2],
447  (index_+1)*sizeof(double));
448 
449  int run1;
450  for( run1 = maxNumberOfEntries[2]; run1 < index_+1; run1++ ){
451  entryExists[2] [run1] = BT_FALSE;
452  variableIndex[2][run1] = -1 ;
453  variableScale[2][run1] = 1.0 ;
454  }
455  maxNumberOfEntries[2] = index_+1;
456  }
457  if( entryExists[2][index_] == BT_TRUE ){
458  return BT_FALSE;
459  }
460  entryExists[2][index_] = BT_TRUE;
461  return BT_TRUE;
462 
463 
464  case VT_INTEGER_CONTROL:
465  if( index_ >= maxNumberOfEntries[3] ){
466 
467  entryExists[3] = (BooleanType*)realloc(entryExists[3],
468  (index_+1)*sizeof(BooleanType));
469  variableIndex[3] = (int*)realloc(variableIndex[3],
470  (index_+1)*sizeof(int));
471  variableScale[3] = (double*)realloc(variableScale[3],
472  (index_+1)*sizeof(double));
473 
474  int run1;
475  for( run1 = maxNumberOfEntries[3]; run1 < index_+1; run1++ ){
476  entryExists[3] [run1] = BT_FALSE;
477  variableIndex[3][run1] = -1 ;
478  variableScale[3][run1] = 1.0 ;
479  }
480  maxNumberOfEntries[3] = index_+1;
481  }
482  if( entryExists[3][index_] == BT_TRUE ){
483  return BT_FALSE;
484  }
485  entryExists[3][index_] = BT_TRUE;
486  return BT_TRUE;
487 
488 
489  case VT_PARAMETER:
490  if( index_ >= maxNumberOfEntries[4] ){
491 
492  entryExists[4] = (BooleanType*)realloc(entryExists[4],
493  (index_+1)*sizeof(BooleanType));
494  variableIndex[4] = (int*)realloc(variableIndex[4],
495  (index_+1)*sizeof(int));
496  variableScale[4] = (double*)realloc(variableScale[4],
497  (index_+1)*sizeof(double));
498 
499  int run1;
500  for( run1 = maxNumberOfEntries[4]; run1 < index_+1; run1++ ){
501  entryExists[4] [run1] = BT_FALSE;
502  variableIndex[4][run1] = -1 ;
503  variableScale[4][run1] = 1.0 ;
504  }
505  maxNumberOfEntries[4] = index_+1;
506  }
507  if( entryExists[4][index_] == BT_TRUE ){
508  return BT_FALSE;
509  }
510  entryExists[4][index_] = BT_TRUE;
511  return BT_TRUE;
512 
513 
514  case VT_INTEGER_PARAMETER:
515  if( index_ >= maxNumberOfEntries[5] ){
516 
517  entryExists[5] = (BooleanType*)realloc(entryExists[5],
518  (index_+1)*sizeof(BooleanType));
519  variableIndex[5] = (int*)realloc(variableIndex[5],
520  (index_+1)*sizeof(int));
521  variableScale[5] = (double*)realloc(variableScale[5],
522  (index_+1)*sizeof(double));
523 
524  int run1;
525  for( run1 = maxNumberOfEntries[5]; run1 < index_+1; run1++ ){
526  entryExists[5] [run1] = BT_FALSE;
527  variableIndex[5][run1] = -1 ;
528  }
529  maxNumberOfEntries[5] = index_+1;
530  }
531  if( entryExists[5][index_] == BT_TRUE ){
532  return BT_FALSE;
533  }
534  entryExists[5][index_] = BT_TRUE;
535  return BT_TRUE;
536 
537 
538  case VT_DISTURBANCE:
539  if( index_ >= maxNumberOfEntries[6] ){
540 
541  entryExists[6] = (BooleanType*)realloc(entryExists[6],
542  (index_+1)*sizeof(BooleanType));
543  variableIndex[6] = (int*)realloc(variableIndex[6],
544  (index_+1)*sizeof(int));
545  variableScale[6] = (double*)realloc(variableScale[6],
546  (index_+1)*sizeof(double));
547 
548  int run1;
549  for( run1 = maxNumberOfEntries[6]; run1 < index_+1; run1++ ){
550  entryExists[6] [run1] = BT_FALSE;
551  variableIndex[6][run1] = -1 ;
552  variableScale[6][run1] = 1.0 ;
553  }
554  maxNumberOfEntries[6] = index_+1;
555  }
556  if( entryExists[6][index_] == BT_TRUE ){
557  return BT_FALSE;
558  }
559  entryExists[6][index_] = BT_TRUE;
560  return BT_TRUE;
561 
562 
563  case VT_TIME:
564  if( index_ >= maxNumberOfEntries[7] ){
565 
566  entryExists[7] = (BooleanType*)realloc(entryExists[7],
567  (index_+1)*sizeof(BooleanType));
568  variableIndex[7] = (int*)realloc(variableIndex[7],
569  (index_+1)*sizeof(int));
570  variableScale[7] = (double*)realloc(variableScale[7],
571  (index_+1)*sizeof(double));
572 
573  int run1;
574  for( run1 = maxNumberOfEntries[7]; run1 < index_+1; run1++ ){
575  entryExists[7] [run1] = BT_FALSE;
576  variableIndex[7][run1] = -1 ;
577  variableScale[7][run1] = 1.0 ;
578  }
579  maxNumberOfEntries[7] = index_+1;
580  }
581  if( entryExists[7][index_] == BT_TRUE ){
582  return BT_FALSE;
583  }
584  entryExists[7][index_] = BT_TRUE;
585  return BT_TRUE;
586 
587 
588  case VT_INTERMEDIATE_STATE:
589  if( index_ >= maxNumberOfEntries[8] ){
590 
591  entryExists[8] = (BooleanType*)realloc(entryExists[8],
592  (index_+1)*sizeof(BooleanType));
593  variableIndex[8] = (int*)realloc(variableIndex[8],
594  (index_+1)*sizeof(int));
595  variableScale[8] = (double*)realloc(variableScale[8],
596  (index_+1)*sizeof(double));
597 
598  int run1;
599  for( run1 = maxNumberOfEntries[8]; run1 < index_+1; run1++ ){
600  entryExists[8] [run1] = BT_FALSE;
601  variableIndex[8][run1] = -1 ;
602  variableScale[8][run1] = 1.0 ;
603  }
604  maxNumberOfEntries[8] = index_+1;
605  }
606  if( entryExists[8][index_] == BT_TRUE ){
607  return BT_FALSE;
608  }
609 
610  entryExists[8][index_] = BT_TRUE;
611  return BT_TRUE;
612 
613 
614  case VT_DDIFFERENTIAL_STATE:
615  if( index_ >= maxNumberOfEntries[9] ){
616 
617  entryExists[9] = (BooleanType*)realloc(entryExists[9],
618  (index_+1)*sizeof(BooleanType));
619  variableIndex[9] = (int*)realloc(variableIndex[9],
620  (index_+1)*sizeof(int));
621  variableScale[9] = (double*)realloc(variableScale[9],
622  (index_+1)*sizeof(double));
623 
624  int run1;
625  for( run1 = maxNumberOfEntries[9]; run1 < index_+1; run1++ ){
626  entryExists[9] [run1] = BT_FALSE;
627  variableIndex[9][run1] = -1 ;
628  variableScale[9][run1] = 1.0 ;
629  }
630  maxNumberOfEntries[9] = index_+1;
631  }
632  if( entryExists[9][index_] == BT_TRUE ){
633  return BT_FALSE;
634  }
635  entryExists[9][index_] = BT_TRUE;
636  return BT_TRUE;
637 
638  case VT_ONLINE_DATA:
639  if( index_ >= maxNumberOfEntries[10] ){
640 
641  entryExists[10] = (BooleanType*)realloc(entryExists[10],
642  (index_+1)*sizeof(BooleanType));
643  variableIndex[10] = (int*)realloc(variableIndex[10],
644  (index_+1)*sizeof(int));
645  variableScale[10] = (double*)realloc(variableScale[10],
646  (index_+1)*sizeof(double));
647 
648  int run1;
649  for( run1 = maxNumberOfEntries[10]; run1 < index_+1; run1++ ){
650  entryExists[10] [run1] = BT_FALSE;
651  variableIndex[10][run1] = -1 ;
652  variableScale[10][run1] = 1.0 ;
653  }
654  maxNumberOfEntries[10] = index_+1;
655  }
656  if( entryExists[10][index_] == BT_TRUE ){
657  return BT_FALSE;
658  }
659  entryExists[10][index_] = BT_TRUE;
660  return BT_TRUE;
661 
662  default: return BT_FALSE;
663 
664  }
665 
666  return BT_FALSE;
667 }
668 
669 BooleanType SymbolicIndexList::determineCExpressionIndices( uint dimension,
670  uint ID ,
671  int *idx ){
672 
673  uint run1;
674 
675  if( nC <= (int) ID ){
676  uint nnn = nC;
677  nC = ID+1;
678  cExist = (BooleanType*)realloc(cExist,(ID+1)*sizeof(BooleanType));
679  cIdx = (int**)realloc(cIdx,(ID+1)*sizeof(int*));
680  cDim = (uint*)realloc(cDim,(ID+1)*sizeof(uint));
681 
682  for( run1 = nnn; run1 < ID+1; run1++ ){
683  cExist[run1] = BT_FALSE;
684  cIdx[run1] = 0;
685  cDim [run1] = 0;
686  }
687  }
688 
689  if( cExist[ID] == BT_FALSE ){
690  cDim[ID] = dimension;
691  cIdx[ID] = new int[dimension];
692  for( run1 = 0; run1 < dimension; run1++ ){
693  cIdx[ID][run1] = variableCounter;
694  idx[run1] = variableCounter;
695  variableCounter++;
696  }
697  cExist[ID] = BT_TRUE;
698  return BT_TRUE;
699  }
700  else{
701  for( run1 = 0; run1 < cDim[ID]; run1++ )
702  idx[run1] = cIdx[ID][run1];
703  return BT_FALSE;
704  }
705 }
706 
707 
708 int SymbolicIndexList::determineVariableIndex( VariableType variableType_, int index_, double scale_ ){
709 
710  switch(variableType_){
711 
712  case VT_DIFFERENTIAL_STATE:
713  if( index_ >= maxNumberOfEntries[0] ){
714 
715  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
716  return -1;
717  }
718  if( variableIndex[0][index_] == -1 ){
719  variableIndex[0][index_] = variableCounter;
720  variableScale[0][index_] = scale_;
721  variableCounter++;
722  return variableIndex[0][index_];
723  }
724  return variableIndex[0][index_];
725 
726  case VT_ALGEBRAIC_STATE:
727  if( index_ >= maxNumberOfEntries[1] ){
728 
729  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
730  return -1;
731  }
732  if( variableIndex[1][index_] == -1 ){
733  variableIndex[1][index_] = variableCounter;
734  variableScale[1][index_] = scale_;
735  variableCounter++;
736  return variableIndex[1][index_];
737  }
738  return variableIndex[1][index_];
739 
740 
741  case VT_CONTROL:
742  if( index_ >= maxNumberOfEntries[2] ){
743 
744  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
745  return -1;
746  }
747  if( variableIndex[2][index_] == -1 ){
748  variableIndex[2][index_] = variableCounter;
749  variableScale[2][index_] = scale_;
750  variableCounter++;
751  return variableIndex[2][index_];
752  }
753  return variableIndex[2][index_];
754 
755 
756  case VT_INTEGER_CONTROL:
757  if( index_ >= maxNumberOfEntries[3] ){
758 
759  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
760  return -1;
761  }
762  if( variableIndex[3][index_] == -1 ){
763  variableIndex[3][index_] = variableCounter;
764  variableScale[3][index_] = scale_;
765  variableCounter++;
766  return variableIndex[3][index_];
767  }
768  return variableIndex[3][index_];
769 
770 
771  case VT_PARAMETER:
772  if( index_ >= maxNumberOfEntries[4] ){
773 
774  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
775  return -1;
776  }
777  if( variableIndex[4][index_] == -1 ){
778  variableIndex[4][index_] = variableCounter;
779  variableScale[4][index_] = scale_;
780  variableCounter++;
781  return variableIndex[4][index_];
782  }
783  return variableIndex[4][index_];
784 
785 
786  case VT_INTEGER_PARAMETER:
787  if( index_ >= maxNumberOfEntries[5] ){
788 
789  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
790  return -1;
791  }
792  if( variableIndex[5][index_] == -1 ){
793  variableIndex[5][index_] = variableCounter;
794  variableScale[5][index_] = scale_;
795  variableCounter++;
796  return variableIndex[5][index_];
797  }
798  return variableIndex[5][index_];
799 
800 
801  case VT_DISTURBANCE:
802  if( index_ >= maxNumberOfEntries[6] ){
803 
804  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
805  return -1;
806  }
807  if( variableIndex[6][index_] == -1 ){
808  variableIndex[6][index_] = variableCounter;
809  variableScale[6][index_] = scale_;
810  variableCounter++;
811  return variableIndex[6][index_];
812  }
813  return variableIndex[6][index_];
814 
815 
816  case VT_TIME:
817  if( index_ >= maxNumberOfEntries[7] ){
818 
819  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
820  return -1;
821  }
822  if( variableIndex[7][index_] == -1 ){
823  variableIndex[7][index_] = variableCounter;
824  variableScale[7][index_] = scale_;
825  variableCounter++;
826  return variableIndex[7][index_];
827  }
828  return variableIndex[7][index_];
829 
830 
831  case VT_INTERMEDIATE_STATE:
832  if( index_ >= maxNumberOfEntries[8] ){
833 
834  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
835  return -1;
836  }
837  if( variableIndex[8][index_] == -1 ){
838  variableIndex[8][index_] = variableCounter;
839  variableScale[8][index_] = scale_;
840  variableCounter++;
841  return variableIndex[8][index_];
842  }
843  return variableIndex[8][index_];
844 
845 
846  case VT_DDIFFERENTIAL_STATE:
847  if( index_ >= maxNumberOfEntries[9] ){
848 
849  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
850  return -1;
851  }
852  if( variableIndex[9][index_] == -1 ){
853  variableIndex[9][index_] = variableCounter;
854  variableScale[9][index_] = scale_;
855  variableCounter++;
856  return variableIndex[9][index_];
857  }
858  return variableIndex[9][index_];
859 
860  case VT_ONLINE_DATA:
861  if( index_ >= maxNumberOfEntries[10] ){
862 
863  ACADOERROR(RET_INDEX_OUT_OF_RANGE);
864  return -1;
865  }
866  if( variableIndex[10][index_] == -1 ){
867  variableIndex[10][index_] = variableCounter;
868  variableScale[10][index_] = scale_;
869  variableCounter++;
870  return variableIndex[10][index_];
871  }
872  return variableIndex[10][index_];
873 
874 
875  default: return -1;
876  }
877 
878  return -1;
879 }
880 
881 
882 returnValue SymbolicIndexList::clearVariableIndexList(){
883 
884  int run1, run2 ;
885  const int numberOfVariableTypes = 11;
886 
887  variableCounter = 0;
888 
889  for( run1 = 0; run1 < numberOfVariableTypes; run1++ ){
890  for( run2 = 0; run2 < maxNumberOfEntries[run1]; run2++ ){
891  variableIndex [run1][run2] = -1;
892  }
893  }
894 
895  return SUCCESSFUL_RETURN;
896 }
897 
898 
899 
900 CLOSE_NAMESPACE_ACADO
901 
902 // end of file.
VT_PARAMETER
Definition: acado_types.hpp:101
VT_ONLINE_DATA
Definition: acado_types.hpp:109
VT_DDIFFERENTIAL_STATE
Definition: acado_types.hpp:106
Operator
Abstract base class for all scalar-valued symbolic operators.
Definition: operator.hpp:60
SUCCESSFUL_RETURN
Definition: acado_types.hpp:836
acado_utils.hpp
VT_INTEGER_PARAMETER
Definition: acado_types.hpp:102
SymbolicIndexList::entryExists
BooleanType ** entryExists
Definition: symbolic_index_list.hpp:254
SymbolicIndexList::operator=
SymbolicIndexList & operator=(const SymbolicIndexList &arg)
Definition: symbolic_index_list.cpp:218
returnValue
Allows to pass back messages to the calling function.
Definition: acado_types.hpp:1139
Operator::clone
virtual Operator * clone() const =0
VT_ALGEBRAIC_STATE
Definition: acado_types.hpp:98
VT_INTERMEDIATE_STATE
Definition: acado_types.hpp:105
uint
BEGIN_NAMESPACE_ACADO typedef unsigned int uint
Definition: acado_types.hpp:42
SymbolicIndexList::determineCExpressionIndices
BooleanType determineCExpressionIndices(uint dimension, uint ID, int *idx)
Definition: symbolic_index_list.cpp:669
VT_DIFFERENTIAL_STATE
Definition: acado_types.hpp:97
CLOSE_NAMESPACE_ACADO
#define CLOSE_NAMESPACE_ACADO
Definition: acado_namespace_macros.hpp:58
SymbolicIndexList
Manages the indices of SymbolicVariables.
Definition: symbolic_index_list.hpp:60
VariableType
VariableType
Definition: acado_types.hpp:95
BooleanType
BooleanType
Definition: examples/code_generation/mpc_mhe/getting_started_export/qpoases/INCLUDE/Types.hpp:44
VT_TIME
Definition: acado_types.hpp:104
symbolic_operator.hpp
SymbolicIndexList::determineVariableIndex
int determineVariableIndex(VariableType variableType_, int index_, double scale)
Definition: symbolic_index_list.cpp:708
BT_TRUE
#define BT_TRUE
Definition: acado_types.hpp:47
VT_CONTROL
Definition: acado_types.hpp:99
BEGIN_NAMESPACE_ACADO
#define BEGIN_NAMESPACE_ACADO
Definition: acado_namespace_macros.hpp:57
VT_INTEGER_CONTROL
Definition: acado_types.hpp:100
BT_FALSE
#define BT_FALSE
Definition: acado_types.hpp:49
SymbolicIndexList::clearVariableIndexList
returnValue clearVariableIndexList()
Definition: symbolic_index_list.cpp:882
SymbolicIndexList::addNewElement
BooleanType addNewElement(VariableType variableType_, int index_)
Definition: symbolic_index_list.cpp:385
SymbolicIndexList::getOperators
returnValue getOperators(Operator **sub, int *comp_, int *n)
Definition: symbolic_index_list.cpp:372
RET_INDEX_OUT_OF_RANGE
Definition: acado_types.hpp:985
VT_DISTURBANCE
Definition: acado_types.hpp:103
ACADOERROR
#define ACADOERROR(retval)
Definition: acado_message_handling.hpp:106
SymbolicIndexList::addOperatorPointer
int addOperatorPointer(Operator *intermediateOperator, int comp_)
Definition: symbolic_index_list.cpp:356

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