generic_expression.hpp
1 /*
2  * This file is part of CasADi.
3  *
4  * CasADi -- A symbolic framework for dynamic optimization.
5  * Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
6  * KU Leuven. All rights reserved.
7  * Copyright (C) 2011-2014 Greg Horn
8  *
9  * CasADi is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 3 of the License, or (at your option) any later version.
13  *
14  * CasADi is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with CasADi; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  */
24 
25 
26 #ifndef CASADI_GENERIC_EXPRESSION_HPP
27 #define CASADI_GENERIC_EXPRESSION_HPP
28 
29 #include "calculus.hpp"
30 
31 namespace casadi {
32 
38  struct CASADI_EXPORT GenericExpressionCommon {};
39 
40 #ifndef SWIG
50 template<typename ExType>
51 class GenericExpression : public GenericExpressionCommon {
52  protected:
53  // Helper functions
54  inline const ExType& self() const { return static_cast<const ExType&>(*this); }
55  inline ExType& self() { return static_cast<ExType&>(*this); }
56  public:
57 
64 
67  static ExType plus(const ExType &x, const ExType &y) {
68  return ExType::binary(OP_ADD, x, y);
69  }
70  friend inline ExType plus(const ExType &x, const ExType &y) {
71  return ExType::plus(x, y);
72  }
73  friend inline ExType operator+(const ExType &x, const ExType &y) {
74  return plus(x, y);
75  }
76  inline ExType& operator+=(const ExType &y) { return self() = self() + y; }
78 
80 
83  static ExType minus(const ExType &x, const ExType &y) {
84  return ExType::binary(OP_SUB, x, y);
85  }
86  friend inline ExType minus(const ExType &x, const ExType &y) {
87  return ExType::minus(x, y);
88  }
89  friend inline ExType operator-(const ExType &x, const ExType &y) {
90  return minus(x, y);
91  }
92  inline ExType& operator-=(const ExType &y) { return self() = self() - y; }
94 
96 
99  static ExType times(const ExType &x, const ExType &y) {
100  return ExType::binary(OP_MUL, x, y);
101  }
102  friend inline ExType times(const ExType &x, const ExType &y) {
103  return ExType::times(x, y);
104  }
105  friend inline ExType operator*(const ExType &x, const ExType &y) {
106  return times(x, y);
107  }
108  inline ExType& operator*=(const ExType &y) {return self() = self() * y;}
110 
112 
115  static ExType rdivide(const ExType &x, const ExType &y) {
116  return ExType::binary(OP_DIV, x, y);
117  }
118  friend inline ExType rdivide(const ExType &x, const ExType &y) {
119  return ExType::rdivide(x, y);
120  }
121  friend inline ExType operator/(const ExType &x, const ExType &y) {
122  return rdivide(x, y);
123  }
124  inline ExType& operator/=(const ExType &y) {return self() = self() / y;}
126 
128 
131  static ExType lt(const ExType &x, const ExType &y) {
132  return ExType::binary(OP_LT, x, y);
133  }
134  friend inline ExType lt(const ExType &x, const ExType &y) {
135  return ExType::lt(x, y);
136  }
137  friend inline ExType operator<(const ExType &x, const ExType &y) {
138  return lt(x, y);
139  }
141 
143 
146  static ExType le(const ExType &x, const ExType &y) {
147  return ExType::binary(OP_LE, x, y);
148  }
149  friend inline ExType le(const ExType &x, const ExType &y) {
150  return ExType::le(x, y);
151  }
152  friend inline ExType operator<=(const ExType &x, const ExType &y) {
153  return le(x, y);
154  }
156 
158 
161  static ExType gt(const ExType &x, const ExType &y) {
162  return ExType::lt(y, x);
163  }
164  friend inline ExType gt(const ExType &x, const ExType &y) {
165  return ExType::gt(x, y);
166  }
167  friend inline ExType operator>(const ExType &x, const ExType &y) {
168  return gt(x, y);
169  }
171 
173 
176  static ExType ge(const ExType &x, const ExType &y) {
177  return ExType::le(y, x);
178  }
179  friend inline ExType ge(const ExType &x, const ExType &y) {
180  return ExType::ge(x, y);
181  }
182  friend inline ExType operator>=(const ExType &x, const ExType &y) {
183  return ge(x, y);
184  }
186 
188 
191  static ExType eq(const ExType &x, const ExType &y) {
192  return ExType::binary(OP_EQ, x, y);
193  }
194  friend inline ExType eq(const ExType &x, const ExType &y) {
195  return ExType::eq(x, y);
196  }
197  friend inline ExType operator==(const ExType &x, const ExType &y) {
198  return eq(x, y);
199  }
201 
203 
206  static ExType ne(const ExType &x, const ExType &y) {
207  return ExType::binary(OP_NE, x, y);
208  }
209  friend inline ExType ne(const ExType &x, const ExType &y) {
210  return ExType::ne(x, y);
211  }
212  friend inline ExType operator!=(const ExType &x, const ExType &y) {
213  return ne(x, y);
214  }
216 
218 
224  static ExType logic_and(const ExType &x, const ExType &y) {
225  return ExType::binary(OP_AND, x, y);
226  }
227  friend inline ExType logic_and(const ExType &x, const ExType &y) {
228  return ExType::logic_and(x, y);
229  }
230  friend inline ExType operator&&(const ExType &x, const ExType &y) {
231  return logic_and(x, y);
232  }
234 
236 
242  static ExType logic_or(const ExType &x, const ExType &y) {
243  return ExType::binary(OP_OR, x, y);
244  }
245  friend inline ExType logic_or(const ExType &x, const ExType &y) {
246  return ExType::logic_or(x, y);
247  }
248  friend inline ExType operator||(const ExType &x, const ExType &y) {
249  return logic_or(x, y);
250  }
252 
254 
260  static ExType logic_not(const ExType& x) {
261  return ExType::unary(OP_NOT, x);
262  }
263  friend inline ExType logic_not(const ExType& x) {
264  return ExType::logic_not(x);
265  }
266  inline ExType operator!() const {
267  return logic_not(self());
268  }
270 
272 
275  static ExType abs(const ExType& x) {
276  return ExType::unary(OP_FABS, x);
277  }
278  friend inline ExType abs(const ExType& x) {
279  return ExType::abs(x);
280  }
281  friend inline ExType fabs(const ExType& x) {
282  return abs(x);
283  }
285 
287 
290  static ExType sqrt(const ExType& x) {
291  return ExType::unary(OP_SQRT, x);
292  }
293  friend inline ExType sqrt(const ExType& x) {
294  return ExType::sqrt(x);
295  }
297 
299 
302  static ExType sq(const ExType& x) {
303  return ExType::unary(OP_SQ, x);
304  }
305  friend inline ExType sq(const ExType& x) {
306  return ExType::sq(x);
307  }
309 
311 
314  static ExType sin(const ExType& x) {
315  return ExType::unary(OP_SIN, x);
316  }
317  friend inline ExType sin(const ExType& x) {
318  return ExType::sin(x);
319  }
321 
323 
326  static ExType cos(const ExType& x) {
327  return ExType::unary(OP_COS, x);
328  }
329  friend inline ExType cos(const ExType& x) {
330  return ExType::cos(x);
331  }
333 
335 
338  static ExType tan(const ExType& x) {
339  return ExType::unary(OP_TAN, x);
340  }
341  friend inline ExType tan(const ExType& x) {
342  return ExType::tan(x);
343  }
345 
347 
350  static ExType atan(const ExType& x) {
351  return ExType::unary(OP_ATAN, x);
352  }
353  friend inline ExType atan(const ExType& x) {
354  return ExType::atan(x);
355  }
357 
359 
362  static ExType asin(const ExType& x) {
363  return ExType::unary(OP_ASIN, x);
364  }
365  friend inline ExType asin(const ExType& x) {
366  return ExType::asin(x);
367  }
369 
371 
374  static ExType acos(const ExType& x) {
375  return ExType::unary(OP_ACOS, x);
376  }
377  friend inline ExType acos(const ExType& x) {
378  return ExType::acos(x);
379  }
381 
383 
386  static ExType tanh(const ExType& x) {
387  return ExType::unary(OP_TANH, x);
388  }
389  friend inline ExType tanh(const ExType& x) {
390  return ExType::tanh(x);
391  }
393 
395 
398  static ExType sinh(const ExType& x) {
399  return ExType::unary(OP_SINH, x);
400  }
401  friend inline ExType sinh(const ExType& x) {
402  return ExType::sinh(x);
403  }
405 
407 
410  static ExType cosh(const ExType& x) {
411  return ExType::unary(OP_COSH, x);
412  }
413  friend inline ExType cosh(const ExType& x) {
414  return ExType::cosh(x);
415  }
417 
419 
422  static ExType atanh(const ExType& x) {
423  return ExType::unary(OP_ATANH, x);
424  }
425  friend inline ExType atanh(const ExType& x) {
426  return ExType::atanh(x);
427  }
429 
431 
434  static ExType asinh(const ExType& x) {
435  return ExType::unary(OP_ASINH, x);
436  }
437  friend inline ExType asinh(const ExType& x) {
438  return ExType::asinh(x);
439  }
441 
443 
446  static ExType acosh(const ExType& x) {
447  return ExType::unary(OP_ACOSH, x);
448  }
449  friend inline ExType acosh(const ExType& x) {
450  return ExType::acosh(x);
451  }
453 
455 
458  static ExType exp(const ExType& x) {
459  return ExType::unary(OP_EXP, x);
460  }
461  friend inline ExType exp(const ExType& x) {
462  return ExType::exp(x);
463  }
465 
467 
470  static ExType log(const ExType& x) {
471  return ExType::unary(OP_LOG, x);
472  }
473  friend inline ExType log(const ExType& x) {
474  return ExType::log(x);
475  }
477 
479 
482  static ExType log10(const ExType& x) {
483  return log(x)*(1/std::log(10.));
484  }
485  friend inline ExType log10(const ExType& x) {
486  return ExType::log10(x);
487  }
489 
491 
494  static ExType log1p(const ExType& x) {
495  return ExType::unary(OP_LOG1P, x);
496  }
497  friend inline ExType log1p(const ExType& x) {
498  return ExType::log1p(x);
499  }
501 
503 
506  static ExType expm1(const ExType& x) {
507  return ExType::unary(OP_EXPM1, x);
508  }
509  friend inline ExType expm1(const ExType& x) {
510  return ExType::expm1(x);
511  }
513 
515 
518  static ExType floor(const ExType& x) {
519  return ExType::unary(OP_FLOOR, x);
520  }
521  friend inline ExType floor(const ExType& x) {
522  return ExType::floor(x);
523  }
525 
527 
530  static ExType ceil(const ExType& x) {
531  return ExType::unary(OP_CEIL, x);
532  }
533  friend inline ExType ceil(const ExType& x) {
534  return ExType::ceil(x);
535  }
537 
539 
542  static ExType erf(const ExType& x) {
543  return ExType::unary(OP_ERF, x);
544  }
545  friend inline ExType erf(const ExType& x) {
546  return ExType::erf(x);
547  }
549 
551 
554  static ExType erfinv(const ExType& x) {
555  return ExType::unary(OP_ERFINV, x);
556  }
557  friend inline ExType erfinv(const ExType& x) {
558  return ExType::erfinv(x);
559  }
561 
563 
571  static ExType sign(const ExType& x) {
572  return ExType::unary(OP_SIGN, x);
573  }
574  friend inline ExType sign(const ExType& x) {
575  return ExType::sign(x);
576  }
578 
580 
583  static ExType pow(const ExType& x, const ExType& y) {
584  return ExType::binary(OP_POW, x, y);
585  }
586  friend inline ExType pow(const ExType& x, const ExType& y) {
587  return ExType::pow(x, y);
588  }
590 
592 
607  static ExType mod(const ExType& x, const ExType& y) {
608  return ExType::binary(OP_FMOD, x, y);
609  }
610  friend inline ExType mod(const ExType& x, const ExType& y) {
611  return ExType::mod(x, y);
612  }
613  friend inline ExType fmod(const ExType& x, const ExType& y) {
614  return mod(x, y);
615  }
617 
619 
634  static ExType remainder(const ExType& x, const ExType& y) {
635  return ExType::binary(OP_REMAINDER, x, y);
636  }
637  friend inline ExType remainder(const ExType& x, const ExType& y) {
638  return ExType::remainder(x, y);
639  }
641 
643 
648  static ExType atan2(const ExType& y, const ExType& x) {
649  return ExType::binary(OP_ATAN2, y, x);
650  }
651  friend inline ExType atan2(const ExType& y, const ExType& x) {
652  return ExType::atan2(y, x);
653  }
655 
657 
660  static ExType if_else_zero(const ExType& x, const ExType& y) {
661  return ExType::binary(OP_IF_ELSE_ZERO, x, y);
662  }
663  friend inline ExType if_else_zero(const ExType& x, const ExType& y) {
664  return ExType::if_else_zero(x, y);
665  }
667 
669 
672  static ExType fmin(const ExType& x, const ExType& y) {
673  return ExType::binary(OP_FMIN, x, y);
674  }
675  friend inline ExType fmin(const ExType& x, const ExType& y) {
676  return ExType::fmin(x, y);
677  }
679 
681 
684  static ExType fmax(const ExType& x, const ExType& y) {
685  return ExType::binary(OP_FMAX, x, y);
686  }
687  friend inline ExType fmax(const ExType& x, const ExType& y) {
688  return ExType::fmax(x, y);
689  }
691 
693 
703  friend inline bool is_equal(const ExType& x, const ExType& y, casadi_int depth=0) {
704  return ExType::is_equal(x, y, depth);
705  }
707 
710  static ExType copysign(const ExType& x, const ExType& y) {
711  return ExType::binary(OP_COPYSIGN, x, y);
712  }
713  friend inline ExType copysign(const ExType& x, const ExType& y) {
714  return ExType::copysign(x, y);
715  }
717 
720  static ExType constpow(const ExType& x, const ExType& y) {
721  return ExType::binary(OP_CONSTPOW, x, y);
722  }
723  friend inline ExType constpow(const ExType& x, const ExType& y) {
724  return ExType::constpow(x, y);
725  }
727 
730  static ExType printme(const ExType& x, const ExType& y) {
731  return ExType::binary(OP_PRINTME, x, y);
732  }
733  friend inline ExType printme(const ExType& x, const ExType& y) {
734  return ExType::binary(OP_PRINTME, x, y);
735  }
737 
739 
742  static ExType hypot(const ExType& x, const ExType& y) {
743  return ExType::binary(OP_HYPOT, x, y);
744  }
745  friend inline ExType hypot(const ExType& x, const ExType& y) {
746  return ExType::hypot(x, y);
747  }
749 
750 
755 };
756 #endif // SWIG
757 
758 } // namespace casadi
759 
760 #endif // CASADI_GENERIC_EXPRESSION_HPP
casadi
The casadi namespace.
Definition: binary_mx_impl.hpp:36