operator.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 #include <acado/symbolic_expression/symbolic_expression.hpp>
38 #include <acado/symbolic_expression/constraint_component.hpp>
39 
40 
41 BEGIN_NAMESPACE_ACADO
42 
43 
44 //TreeProjection emptyTreeProjection;
45 
46 
47 Operator::Operator(){
48 
49  nCount = 0;
50  initialized = BT_FALSE;
51 }
52 
53 Operator::~Operator(){ }
54 
55 
56 Operator& Operator::operator=( const double &arg ){
57 
58  ACADOERROR( RET_UNKNOWN_BUG );
59  ASSERT( 1 == 0 );
60  return emptyTreeProjection;
61 }
62 
63 Operator& Operator::operator=( const DVector &arg ){
64 
65  ACADOERROR( RET_UNKNOWN_BUG );
66  ASSERT( 1 == 0 );
67  return emptyTreeProjection;
68 }
69 
70 Operator& Operator::operator=( const DMatrix &arg ){
71 
72  ACADOERROR( RET_UNKNOWN_BUG );
73  ASSERT( 1 == 0 );
74  return emptyTreeProjection;
75 }
76 
77 Operator& Operator::operator=( const Expression &arg ){
78 
79  ACADOERROR( RET_UNKNOWN_BUG );
80  ASSERT( 1 == 0 );
81  return emptyTreeProjection;
82 }
83 
84 Operator& Operator::operator=( const Operator &arg ){
85 
86  ACADOERROR( RET_UNKNOWN_BUG );
87  ASSERT( 1 == 0 );
88  return emptyTreeProjection;
89 }
90 
91 
92 TreeProjection* Operator::cloneTreeProjection() const{
93 
94  // if this routine is ever called something went
95  // really wrong ....
96 
97  ACADOERROR( RET_UNKNOWN_BUG );
98  ASSERT( 1 == 0 );
99  return new TreeProjection();
100 }
101 
102 
103 int Operator::getGlobalIndex( ) const{
104 
105  ACADOERROR( RET_UNKNOWN_BUG );
106  return -1;
107 }
108 
109 
110 
111 Operator& Operator::operator+=( const double & arg ){ return operator=( this->operator+(arg) ); }
112 Operator& Operator::operator+=( const DVector & arg ){ return operator=( this->operator+(arg) ); }
113 Operator& Operator::operator+=( const DMatrix & arg ){ return operator=( this->operator+(arg) ); }
114 Operator& Operator::operator+=( const Expression& arg ){ return operator=( this->operator+(arg) ); }
115 
116 Operator& Operator::operator-=( const double & arg ){ return operator=( this->operator-(arg) ); }
117 Operator& Operator::operator-=( const DVector & arg ){ return operator=( this->operator-(arg) ); }
118 Operator& Operator::operator-=( const DMatrix & arg ){ return operator=( this->operator-(arg) ); }
119 Operator& Operator::operator-=( const Expression & arg ){ return operator=( this->operator-(arg) ); }
120 
121 Operator& Operator::operator*=( const double & arg ){ return operator=( this->operator*(arg) ); }
122 Operator& Operator::operator*=( const DVector & arg ){ return operator=( this->operator*(arg) ); }
123 Operator& Operator::operator*=( const DMatrix & arg ){ return operator=( this->operator*(arg) ); }
124 Operator& Operator::operator*=( const Expression & arg ){ return operator=( this->operator*(arg) ); }
125 
126 Operator& Operator::operator/=( const double & arg ){ return operator=( this->operator/(arg) ); }
127 Operator& Operator::operator/=( const Expression & arg ){ return operator=( this->operator/(arg) ); }
128 
129 
130 
131 
132 Expression Operator::operator+( const double & arg ) const{ return Expression(*this)+arg; }
133 Expression Operator::operator+( const DVector & arg ) const{ return Expression(*this)+arg; }
134 Expression Operator::operator+( const DMatrix & arg ) const{ return Expression(*this)+arg; }
135 Expression Operator::operator+( const Operator& arg ) const{ return Expression(*this)+arg; }
136 Expression Operator::operator+( const Expression & arg ) const{ return Expression(*this)+arg; }
137 
138 Expression operator+( const double & arg1, const Operator& arg2 ){ return arg1 + Expression(arg2); }
139 Expression operator+( const DVector & arg1, const Operator& arg2 ){ return arg1 + Expression(arg2); }
140 Expression operator+( const DMatrix & arg1, const Operator& arg2 ){ return arg1 + Expression(arg2); }
141 
142 Expression Operator::operator-( const double & arg ) const{ return Expression(*this)-arg; }
143 Expression Operator::operator-( const DVector & arg ) const{ return Expression(*this)-arg; }
144 Expression Operator::operator-( const DMatrix & arg ) const{ return Expression(*this)-arg; }
145 Expression Operator::operator-( const Operator& arg ) const{ return Expression(*this)-arg; }
146 Expression Operator::operator-( const Expression & arg ) const{ return Expression(*this)-arg; }
147 
148 Expression Operator::operator-( ) const{ return -Expression(*this); }
149 
150 Expression operator-( const double & arg1, const Operator& arg2 ){ return arg1 - Expression(arg2); }
151 Expression operator-( const DVector & arg1, const Operator& arg2 ){ return arg1 - Expression(arg2); }
152 Expression operator-( const DMatrix & arg1, const Operator& arg2 ){ return arg1 - Expression(arg2); }
153 
154 Expression Operator::operator*( const double & arg ) const{ return Expression(*this)*arg; }
155 Expression Operator::operator*( const DVector & arg ) const{ return Expression(*this)*arg; }
156 Expression Operator::operator*( const DMatrix & arg ) const{ return Expression(*this)*arg; }
157 
158 
159 Expression Operator::operator*( const Operator& arg ) const{
160 
161  Expression tmp2(arg);
162 
163 
164  Expression tmp1(*this);
165 
166 
167  return tmp1*tmp2;
168 }
169 
170 
171 Expression Operator::operator*( const Expression & arg ) const{ return Expression(*this)*arg; }
172 
173 Expression operator*( const double & arg1, const Operator& arg2 ){ return arg1 * Expression(arg2); }
174 Expression operator*( const DVector & arg1, const Operator& arg2 ){ return arg1 * Expression(arg2); }
175 Expression operator*( const DMatrix & arg1, const Operator& arg2 ){ return arg1 * Expression(arg2); }
176 
177 Expression Operator::operator/( const double & arg ) const{ return Expression(*this)/arg; }
178 Expression Operator::operator/( const Operator& arg ) const{ return Expression(*this)/arg; }
179 Expression Operator::operator/( const Expression & arg ) const{ return Expression(*this)/arg; }
180 
181 Expression operator/( const double & arg1, const Operator& arg2 ){ return arg1 / Expression(arg2); }
182 Expression operator/( const DVector & arg1, const Operator& arg2 ){ return arg1 / Expression(arg2); }
183 Expression operator/( const DMatrix & arg1, const Operator& arg2 ){ return arg1 / Expression(arg2); }
184 
185 ConstraintComponent Operator::operator<=( const double& ub ) const{ return Expression(*this) <= ub; }
186 ConstraintComponent Operator::operator>=( const double& lb ) const{ return Expression(*this) >= lb; }
187 ConstraintComponent Operator::operator==( const double& b ) const{ return Expression(*this) == b; }
188 
189 ConstraintComponent Operator::operator<=( const DVector& ub ) const{ return Expression(*this) <= ub; }
190 ConstraintComponent Operator::operator>=( const DVector& lb ) const{ return Expression(*this) >= lb; }
191 ConstraintComponent Operator::operator==( const DVector& b ) const{ return Expression(*this) == b; }
192 
193 ConstraintComponent Operator::operator<=( const VariablesGrid& ub ) const{ return Expression(*this) <= ub; }
194 ConstraintComponent Operator::operator>=( const VariablesGrid& lb ) const{ return Expression(*this) >= lb; }
195 ConstraintComponent Operator::operator==( const VariablesGrid& b ) const{ return Expression(*this) == b; }
196 
197 ConstraintComponent operator<=( double lb, const Operator &arg ){ return lb <= Expression(arg); }
198 ConstraintComponent operator==( double b, const Operator &arg ){ return b == Expression(arg); }
199 ConstraintComponent operator>=( double ub, const Operator &arg ){ return ub >= Expression(arg); }
200 
201 ConstraintComponent operator<=( DVector lb, const Operator &arg ){ return lb <= Expression(arg); }
202 ConstraintComponent operator==( DVector b, const Operator &arg ){ return b == Expression(arg); }
203 ConstraintComponent operator>=( DVector ub, const Operator &arg ){ return ub >= Expression(arg); }
204 
205 ConstraintComponent operator<=( VariablesGrid lb, const Operator &arg ){ return lb <= Expression(arg); }
206 ConstraintComponent operator==( VariablesGrid b, const Operator &arg ){ return b == Expression(arg); }
207 ConstraintComponent operator>=( VariablesGrid ub, const Operator &arg ){ return ub >= Expression(arg); }
208 
209 
210 
211 double Operator::getValue() const{ return INFTY; }
212 
213 std::ostream& operator<<(std::ostream &stream, const Operator &arg)
214 {
215  return arg.print( stream );
216 }
217 
218 Operator* Operator::passArgument() const{
219 
220  return 0;
221 }
222 
223 returnValue Operator::setVariableExportName( const VariableType &_type,
224  const std::vector< std::string >& _name
225  )
226 {
227  return SUCCESSFUL_RETURN;
228 }
229 
230 
231 
232 Operator* Operator::myProd(Operator* a,Operator* b){
233 
234  if( a->isOneOrZero() == NE_ZERO ) return new DoubleConstant( 0.0 , NE_ZERO );
235  if( b->isOneOrZero() == NE_ZERO ) return new DoubleConstant( 0.0 , NE_ZERO );
236 
237  if( a->isOneOrZero() == NE_ONE ) return b->clone();
238  if( b->isOneOrZero() == NE_ONE ) return a->clone();
239 
240  if( a == b ) return new Power_Int( a->clone(), 2 );
241 
242  return new Product(a->clone(),b->clone());
243 }
244 
245 
246 Operator* Operator::myAdd (Operator* a,Operator* b){
247 
248  if( a->isOneOrZero() == NE_ZERO && b->isOneOrZero() == NE_ZERO )
249  return new DoubleConstant( 0.0 , NE_ZERO );
250 
251  if( a->isOneOrZero() == NE_ZERO ) return b->clone();
252  if( b->isOneOrZero() == NE_ZERO ) return a->clone();
253 
254  if( a->isOneOrZero() == NE_ONE && b->isOneOrZero() == NE_ONE )
255  return new DoubleConstant( 2.0 , NE_NEITHER_ONE_NOR_ZERO );
256 
257  if( a == b ) return new Product( a->clone(), new DoubleConstant( 2.0 , NE_NEITHER_ONE_NOR_ZERO ) );
258 
259  return new Addition(a->clone(),b->clone());
260 }
261 
262 
263 Operator* Operator::mySubtract (Operator* a,Operator* b){
264 
265  if( a->isOneOrZero() == NE_ZERO && b->isOneOrZero() == NE_ZERO )
266  return new DoubleConstant( 0.0 , NE_ZERO );
267 
268  if( a->isOneOrZero() == NE_ZERO ) return new Subtraction(new DoubleConstant( 0.0 , NE_ZERO ), b->clone());
269  if( b->isOneOrZero() == NE_ZERO ) return a->clone();
270 
271  if( a->isOneOrZero() == NE_ONE && b->isOneOrZero() == NE_ONE )
272  return new DoubleConstant( 0.0 , NE_ZERO );
273 
274  if( a == b ) return new DoubleConstant( 0.0 , NE_ZERO );
275 
276  return new Subtraction(a->clone(),b->clone());
277 }
278 
279 
280 Operator* Operator::myPower (Operator* a,Operator* b){
281 
282  if( a->isOneOrZero() == NE_ZERO && b->isOneOrZero() == NE_ONE ) return new DoubleConstant( 0.0 , NE_ZERO );
283 
284  if( b->isOneOrZero() == NE_ZERO ) return new DoubleConstant( 1.0 , NE_ONE );
285  if( a->isOneOrZero() == NE_ONE ) return new DoubleConstant( 1.0 , NE_ONE );
286 
287  if( b->isOneOrZero() == NE_ONE ) return a->clone();
288 
289  return new Power(a->clone(),b->clone());
290 }
291 
292 
293 Operator* Operator::myPowerInt (Operator* a, int b){
294 
295  if( a->isOneOrZero() == NE_ZERO && b>0 ) return new DoubleConstant( 0.0 , NE_ZERO );
296  if( b == 0 ) return new DoubleConstant( 1.0 , NE_ONE );
297  if( a->isOneOrZero() == NE_ONE ) return new DoubleConstant( 1.0 , NE_ONE );
298  if( b == 1 ) return a->clone();
299 
300  return new Power_Int(a->clone(),b);
301 }
302 
303 
304 Operator* Operator::myLogarithm (Operator* a){
305 
306  if( a->isOneOrZero() == NE_ONE ) return new DoubleConstant( 0.0 , NE_ZERO );
307 
308  return new Logarithm(a->clone());
309 }
310 
311 
312 TreeProjection* Operator::convert2TreeProjection( Operator* a ) const{
313 
314  TreeProjection b;
315  b = *a;
316  delete a;
317  return b.clone();
318 }
319 
320 
321 returnValue Operator::ADsymCommon( Operator *a ,
322  TreeProjection &da ,
323  TreeProjection &dda,
324  int dim ,
325  VariableType *varType ,
326  int *component ,
327  Operator *l ,
328  Operator **S ,
329  int dimS ,
330  Operator **dfS ,
331  Operator **ldf ,
332  Operator **H ,
333  int &nNewLIS ,
334  TreeProjection ***newLIS ,
335  int &nNewSIS ,
336  TreeProjection ***newSIS ,
337  int &nNewHIS ,
338  TreeProjection ***newHIS ){
339 
340  // FIRST ORDER BACKWARD SWEEP:
341  // ---------------------------
342 
343  a->AD_symmetric( dim, varType, component,
344  convert2TreeProjection(myProd(l,&da)),
345  S, dimS, dfS, ldf, H, nNewLIS, newLIS, nNewSIS, newSIS, nNewHIS, newHIS
346  );
347 
348 
349  // SECOND ORDER FORWARD SWEEP:
350  // -------------------------------------
351  Operator *tmp3 = convert2TreeProjection(myProd(&dda,l));
352 
353  int run1, run2;
354  for( run1 = 0; run1 < dimS; run1++ ){
355  for( run2 = 0; run2 <= run1; run2++ ){
356  Operator *tmp1 = H[run1*dimS+run2]->clone();
357  delete H[run1*dimS+run2];
358  Operator *tmp2 = myProd( dfS[run1], dfS[run2] );
359  Operator *tmp4 = myProd( tmp2 , tmp3 );
360  H[run1*dimS+run2] = myAdd( tmp1, tmp4 );
361  delete tmp1;
362  delete tmp2;
363  delete tmp4;
364  }
365  }
366  delete tmp3;
367 
368 
369  // FIRST ORDER FORWARD SWEEP:
370  // -------------------------------------
371 
372  for( run1 = 0; run1 < dimS; run1++ ){
373  Operator *tmp1 = dfS[run1]->clone();
374  delete dfS[run1];
375  dfS[run1] = convert2TreeProjection( myProd( tmp1, &da ) );
376  delete tmp1;
377  }
378 
379  // CLEAR MEMORY FROM BACKWARD SWEEP:
380  // -------------------------------------
381 
382  delete l;
383  return SUCCESSFUL_RETURN;
384 }
385 
386 
387 returnValue Operator::ADsymCommon2( Operator *a ,
388  Operator *b ,
389  TreeProjection &dx ,
390  TreeProjection &dy ,
391  TreeProjection &dxx,
392  TreeProjection &dxy,
393  TreeProjection &dyy,
394  int dim ,
395  VariableType *varType ,
396  int *component ,
397  Operator *l ,
398  Operator **S ,
399  int dimS ,
400  Operator **dfS ,
401  Operator **ldf ,
402  Operator **H ,
403  int &nNewLIS ,
404  TreeProjection ***newLIS ,
405  int &nNewSIS ,
406  TreeProjection ***newSIS ,
407  int &nNewHIS ,
408  TreeProjection ***newHIS ){
409 
410  int run1, run2;
411 
412  // FIRST ORDER BACKWARD SWEEP:
413  // ---------------------------
414  Operator **S1 = new Operator*[dimS];
415  Operator **S2 = new Operator*[dimS];
416  Operator **H1 = new Operator*[dimS*dimS];
417  Operator **H2 = new Operator*[dimS*dimS];
418 
419  for( run2 = 0; run2 < dimS; run2++ ){
420  S1[run2] = new DoubleConstant(0.0,NE_ZERO);
421  S2[run2] = new DoubleConstant(0.0,NE_ZERO);
422  }
423 
424  for( run2 = 0; run2 < dimS*dimS; run2++ ){
425  H1[run2] = new DoubleConstant(0.0,NE_ZERO);
426  H2[run2] = new DoubleConstant(0.0,NE_ZERO);
427  }
428 
429  a->AD_symmetric( dim, varType, component, convert2TreeProjection(myProd(l,&dx)),
430  S, dimS, S1, ldf, H1, nNewLIS, newLIS, nNewSIS, newSIS, nNewHIS, newHIS );
431 
432 
433  b->AD_symmetric( dim, varType, component, convert2TreeProjection(myProd(l,&dy)),
434  S, dimS, S2, ldf, H2, nNewLIS, newLIS, nNewSIS, newSIS, nNewHIS, newHIS );
435 
436 
437 
438  // SECOND ORDER FORWARD SWEEP:
439  // -------------------------------------
440 
441  Operator *tmpXX = convert2TreeProjection(myProd( l,&dxx ));
442  Operator *tmpXY = convert2TreeProjection(myProd( l,&dxy ));
443  Operator *tmpYY = convert2TreeProjection(myProd( l,&dyy ));
444 
445  for( run1 = 0; run1 < dimS; run1++ ){
446  for( run2 = 0; run2 <= run1; run2++ ){
447  delete H[run1*dimS+run2];
448  Operator *tmp1 = myProd( S1[run1], S1[run2] );
449  Operator *tmp2 = myProd( S1[run1], S2[run2] );
450  Operator *tmp3 = myProd( S2[run1], S1[run2] );
451  Operator *tmp4 = myProd( S2[run1], S2[run2] );
452  Operator *tmp5;
453  if( run1 == run2 ) tmp5 = myAdd(tmp2,tmp2);
454  else tmp5 = myAdd(tmp2,tmp3);
455  Operator *tmp6 = myProd( tmp1, tmpXX );
456  Operator *tmp7 = myProd( tmp5, tmpXY );
457  Operator *tmp8 = myProd( tmp4, tmpYY );
458  Operator *tmp9 = myAdd ( tmp6, tmp7 );
459  Operator *tmp10 = myAdd ( tmp8, tmp9 );
460  Operator *tmp12 = myAdd ( tmp10 , H1[run1*dimS+run2] );
461  H[run1*dimS+run2] = myAdd ( tmp12 , H2[run1*dimS+run2] );
462  delete tmp1;
463  delete tmp2;
464  delete tmp3;
465  delete tmp4;
466  delete tmp5;
467  delete tmp6;
468  delete tmp7;
469  delete tmp8;
470  delete tmp9;
471  delete tmp10;
472  delete tmp12;
473  }
474  }
475 
476  delete tmpXX;
477  delete tmpXY;
478  delete tmpYY;
479 
480 
481  // FIRST ORDER FORWARD SWEEP:
482  // -------------------------------------
483 
484  for( run1 = 0; run1 < dimS; run1++ ){
485  delete dfS[run1];
486  Operator *tmp1 = convert2TreeProjection( myProd( S1[run1], &dx ) );
487  Operator *tmp2 = convert2TreeProjection( myProd( S2[run1], &dy ) );
488  dfS[run1] = myAdd(tmp1,tmp2);
489  delete tmp1;
490  delete tmp2;
491  }
492 
493  // CLEAR MEMORY FROM SWEEPS:
494  // -------------------------------------
495 
496  for( run2 = 0; run2 < dimS; run2++ ){
497  delete S1[run2];
498  delete S2[run2];
499  }
500  for( run2 = 0; run2 < dimS*dimS; run2++ ){
501  delete H1[run2];
502  delete H2[run2];
503  }
504  delete[] S1;
505  delete[] S2;
506  delete[] H1;
507  delete[] H2;
508 
509  delete l;
510  return SUCCESSFUL_RETURN;
511 }
512 
513 
514 BooleanType Operator::isTrivial() const {
515  return BT_FALSE;
516 }
517 
518 
519 returnValue Operator::initDerivative() {
520 
521  initialized = BT_TRUE;
522  return SUCCESSFUL_RETURN;
523 }
524 
525 
526 
527 CLOSE_NAMESPACE_ACADO
528 
529 
530 // end of file.
Operator::getGlobalIndex
virtual int getGlobalIndex() const
Definition: operator.cpp:103
NE_NEITHER_ONE_NOR_ZERO
Definition: acado_types.hpp:68
Operator::operator==
ConstraintComponent operator==(const double &b) const
Definition: operator.cpp:187
RET_UNKNOWN_BUG
Definition: acado_types.hpp:845
Operator
Abstract base class for all scalar-valued symbolic operators.
Definition: operator.hpp:60
Operator::operator>=
ConstraintComponent operator>=(const double &lb) const
Definition: operator.cpp:186
SUCCESSFUL_RETURN
Definition: acado_types.hpp:836
acado_utils.hpp
INFTY
const double INFTY
Definition: acado_constants.hpp:65
Operator::isOneOrZero
virtual NeutralElement isOneOrZero() const =0
Operator::Operator
Operator()
Definition: operator.cpp:47
Operator::operator*
Expression operator*(const double &arg) const
Definition: operator.cpp:154
Operator::myPowerInt
virtual Operator * myPowerInt(Operator *a, int b)
Definition: operator.cpp:293
VariablesGrid
Provides a time grid consisting of vector-valued optimization variables at each grid point...
Definition: variables_grid.hpp:56
returnValue
Allows to pass back messages to the calling function.
Definition: acado_types.hpp:1139
Operator::operator+
Expression operator+(const double &arg) const
Definition: operator.cpp:132
Power
Implements the scalar power operator within the symbolic operators family.
Definition: power.hpp:56
Operator::clone
virtual Operator * clone() const =0
H2
const double H2
Definition: examples/code_generation/mpc_mhe/cstr.cpp:41
Operator::setVariableExportName
virtual returnValue setVariableExportName(const VariableType &_type, const std::vector< std::string > &_name)
Definition: operator.cpp:223
Operator::getValue
virtual double getValue() const
Definition: operator.cpp:211
H1
const double H1
Definition: examples/code_generation/mpc_mhe/cstr.cpp:40
CLOSE_NAMESPACE_ACADO
#define CLOSE_NAMESPACE_ACADO
Definition: acado_namespace_macros.hpp:58
ConstraintComponent
Data class for symbolically formulating constraints within optimal control problems.
Definition: constraint_component.hpp:56
VariableType
VariableType
Definition: acado_types.hpp:95
Operator::initialized
BooleanType initialized
Definition: operator.hpp:642
Operator::mySubtract
virtual Operator * mySubtract(Operator *a, Operator *b)
Definition: operator.cpp:263
NE_ZERO
Definition: acado_types.hpp:66
Operator::operator/
Expression operator/(const double &arg) const
Definition: operator.cpp:177
Operator::nCount
int nCount
Definition: operator.hpp:556
Operator::operator+=
Operator & operator+=(const double &arg)
Definition: operator.cpp:111
Expression
Base class for all variables within the symbolic expressions family.
Definition: expression.hpp:56
Operator::ADsymCommon2
returnValue ADsymCommon2(Operator *a, Operator *b, TreeProjection &dx, TreeProjection &dy, TreeProjection &dxx, TreeProjection &dxy, TreeProjection &dyy, int dim, VariableType *varType, int *component, Operator *l, Operator **S, int dimS, Operator **dfS, Operator **ldf, Operator **H, int &nNewLIS, TreeProjection ***newLIS, int &nNewSIS, TreeProjection ***newSIS, int &nNewHIS, TreeProjection ***newHIS)
Definition: operator.cpp:387
Operator::operator*=
Operator & operator*=(const double &arg)
Definition: operator.cpp:121
BooleanType
BooleanType
Definition: examples/code_generation/mpc_mhe/getting_started_export/qpoases/INCLUDE/Types.hpp:44
constraint_component.hpp
Operator::operator=
virtual Operator & operator=(const double &arg)
Definition: operator.cpp:56
Power_Int
Implements the scalar power operator with integer exponent within the symbolic operators family...
Definition: powerint.hpp:55
symbolic_operator.hpp
Operator::myProd
virtual Operator * myProd(Operator *a, Operator *b)
Definition: operator.cpp:232
Operator::cloneTreeProjection
virtual TreeProjection * cloneTreeProjection() const
Definition: operator.cpp:92
Operator::initDerivative
virtual returnValue initDerivative()
Definition: operator.cpp:519
Addition
Implements the scalar addition operator within the symbolic expressions family.
Definition: addition.hpp:54
Subtraction
Implements the scalar subtraction operator within the symbolic operators family.
Definition: subtraction.hpp:54
Operator::myAdd
virtual Operator * myAdd(Operator *a, Operator *b)
Definition: operator.cpp:246
emptyTreeProjection
static TreeProjection emptyTreeProjection
Definition: tree_projection.hpp:287
Operator::ADsymCommon
returnValue ADsymCommon(Operator *a, TreeProjection &da, TreeProjection &dda, int dim, VariableType *varType, int *component, Operator *l, Operator **S, int dimS, Operator **dfS, Operator **ldf, Operator **H, int &nNewLIS, TreeProjection ***newLIS, int &nNewSIS, TreeProjection ***newSIS, int &nNewHIS, TreeProjection ***newHIS)
Definition: operator.cpp:321
Operator::print
virtual std::ostream & print(std::ostream &stream) const =0
Operator::operator<=
ConstraintComponent operator<=(const double &ub) const
Definition: operator.cpp:185
ASSERT
#define ASSERT(x)
Definition: acado_debugging.hpp:51
BT_TRUE
#define BT_TRUE
Definition: acado_types.hpp:47
Operator::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Operator &arg)
Definition: operator.cpp:213
NE_ONE
Definition: acado_types.hpp:67
Operator::operator-
Expression operator-() const
Definition: operator.cpp:148
Operator::myLogarithm
virtual Operator * myLogarithm(Operator *a)
Definition: operator.cpp:304
Operator::passArgument
virtual Operator * passArgument() const
Definition: operator.cpp:218
TreeProjection
Implements the tree-projection operator within the family of SymbolicOperators.
Definition: tree_projection.hpp:58
Operator::convert2TreeProjection
virtual TreeProjection * convert2TreeProjection(Operator *a) const
Definition: operator.cpp:312
BEGIN_NAMESPACE_ACADO
#define BEGIN_NAMESPACE_ACADO
Definition: acado_namespace_macros.hpp:57
Logarithm
Implements the scalar logarithm operator within the symbolic operators family.
Definition: logarithm.hpp:55
BT_FALSE
#define BT_FALSE
Definition: acado_types.hpp:49
TreeProjection::clone
virtual TreeProjection * clone() const
Definition: tree_projection.cpp:202
Operator::isTrivial
virtual BooleanType isTrivial() const
Definition: operator.cpp:514
Operator::~Operator
virtual ~Operator()
Definition: operator.cpp:53
Operator::operator-=
Operator & operator-=(const double &arg)
Definition: operator.cpp:116
Operator::myPower
virtual Operator * myPower(Operator *a, Operator *b)
Definition: operator.cpp:280
Operator::operator/=
Operator & operator/=(const double &arg)
Definition: operator.cpp:126
S
#define S
Definition: rocket_with_templates_ocp.hpp:41
Operator::AD_symmetric
virtual returnValue AD_symmetric(int dim, VariableType *varType, int *component, Operator *l, Operator **S, int dimS, Operator **dfS, Operator **ldf, Operator **H, int &nNewLIS, TreeProjection ***newLIS, int &nNewSIS, TreeProjection ***newSIS, int &nNewHIS, TreeProjection ***newHIS)=0
DoubleConstant
Implements a scalar constant within the symbolic operators family.
Definition: doubleconstant.hpp:55
ACADOERROR
#define ACADOERROR(retval)
Definition: acado_message_handling.hpp:106
symbolic_expression.hpp
Product
Implements the scalar product operator within the symbolic operators family.
Definition: product.hpp:55

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