#include <SymbolicIndex.h>

Public Types
using	Derived = Derived_

Public Member Functions
constexpr const Derived &	derived () const

template<typename... Tags, typename... Types>
constexpr Index	eval (const SymbolValue< Tags, Types > &... values) const

constexpr NegateExpr< Derived >	operator- () const

constexpr AddExpr< Derived, ValueExpr<> >	operator+ (Index b) const

constexpr AddExpr< Derived, ValueExpr<> >	operator- (Index a) const

constexpr ProductExpr< Derived, ValueExpr<> >	operator* (Index a) const

constexpr QuotientExpr< Derived, ValueExpr<> >	operator/ (Index a) const

template<int N>
constexpr AddExpr< Derived, ValueExpr< internal::FixedInt< N > > >	operator+ (internal::FixedInt< N >) const

template<int N>
constexpr AddExpr< Derived, ValueExpr< internal::FixedInt<-N > > >	operator- (internal::FixedInt< N >) const

template<int N>
constexpr ProductExpr< Derived, ValueExpr< internal::FixedInt< N > > >	operator* (internal::FixedInt< N >) const

template<int N>
constexpr QuotientExpr< Derived, ValueExpr< internal::FixedInt< N > > >	operator/ (internal::FixedInt< N >) const

template<typename OtherDerived >
constexpr AddExpr< Derived, OtherDerived >	operator+ (const BaseExpr< OtherDerived > &b) const

template<typename OtherDerived >
constexpr AddExpr< Derived, NegateExpr< OtherDerived > >	operator- (const BaseExpr< OtherDerived > &b) const

template<typename OtherDerived >
constexpr ProductExpr< Derived, OtherDerived >	operator* (const BaseExpr< OtherDerived > &b) const

template<typename OtherDerived >
constexpr QuotientExpr< Derived, OtherDerived >	operator/ (const BaseExpr< OtherDerived > &b) const

Static Public Member Functions
template<typename... Tags, typename... Types>
static constexpr Index	eval_at_compile_time (const SymbolValue< Tags, Types > &...)

Friends
constexpr friend AddExpr< Derived, ValueExpr<> >	operator+ (Index a, const BaseExpr &b)

constexpr friend AddExpr< NegateExpr< Derived >, ValueExpr<> >	operator- (Index a, const BaseExpr &b)

constexpr friend ProductExpr< ValueExpr<>, Derived >	operator* (Index a, const BaseExpr &b)

constexpr friend QuotientExpr< ValueExpr<>, Derived >	operator/ (Index a, const BaseExpr &b)

template<int N>
constexpr friend AddExpr< Derived, ValueExpr< internal::FixedInt< N > > >	operator+ (internal::FixedInt< N >, const BaseExpr &b)

template<int N>
constexpr friend AddExpr< NegateExpr< Derived >, ValueExpr< internal::FixedInt< N > > >	operator- (internal::FixedInt< N >, const BaseExpr &b)

template<int N>
constexpr friend ProductExpr< ValueExpr< internal::FixedInt< N > >, Derived >	operator* (internal::FixedInt< N >, const BaseExpr &b)

template<int N>
constexpr friend QuotientExpr< ValueExpr< internal::FixedInt< N > >, Derived >	operator/ (internal::FixedInt< N >, const BaseExpr &b)

Detailed Description

template<typename Derived_>
class Eigen::symbolic::BaseExpr< Derived_ >

Common base class of any symbolic expressions

Member Typedef Documentation

◆ Derived

template<typename Derived_ >

using Eigen::symbolic::BaseExpr< Derived_ >::Derived = Derived_

Member Function Documentation

◆ derived()

template<typename Derived_ >

constexpr const Derived& Eigen::symbolic::BaseExpr< Derived_ >::derived ( ) const

inlineconstexpr

68 { return *static_cast<const Derived*>(this); }

Eigen::symbolic::BaseExpr::Derived

Derived_ Derived

Definition: SymbolicIndex.h:67

Referenced by Eigen::symbolic::BaseExpr< Derived_ >::eval(), Eigen::symbolic::BaseExpr< Derived_ >::operator*(), Eigen::symbolic::BaseExpr< Derived_ >::operator+(), Eigen::symbolic::BaseExpr< Derived_ >::operator-(), and Eigen::symbolic::BaseExpr< Derived_ >::operator/().

◆ eval()

template<typename Derived_ >

template<typename... Tags, typename... Types>

constexpr Index Eigen::symbolic::BaseExpr< Derived_ >::eval ( const SymbolValue< Tags, Types > &... values ) const

inlineconstexpr

Evaluate the expression given the values of the symbols.

Parameters

values defines the values of the symbols, as constructed by SymbolExpr::operator= operator.

                                                                         {
     return derived().eval_impl(values...);
   }

References Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ eval_at_compile_time()

template<typename Derived_ >

template<typename... Tags, typename... Types>

static constexpr Index Eigen::symbolic::BaseExpr< Derived_ >::eval_at_compile_time ( const SymbolValue< Tags, Types > & ... )

inlinestaticconstexpr

Evaluate the expression at compile time given the values of the symbols.

If a value is not known at compile-time, returns Eigen::Undefined.

                                                                                   {
     return Derived::eval_at_compile_time_impl(SymbolValue<Tags, Types>{}...);
   }

◆ operator*() [1/3]

template<typename Derived_ >

template<typename OtherDerived >

constexpr ProductExpr<Derived, OtherDerived> Eigen::symbolic::BaseExpr< Derived_ >::operator* ( const BaseExpr< OtherDerived > & b ) const

inlineconstexpr

                                                                                                 {
     return ProductExpr<Derived, OtherDerived>(derived(), b.derived());
   }

References b, and Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator*() [2/3]

template<typename Derived_ >

constexpr ProductExpr<Derived, ValueExpr<> > Eigen::symbolic::BaseExpr< Derived_ >::operator* ( Index a ) const

inlineconstexpr

                                                                        {
     return ProductExpr<Derived, ValueExpr<>>(derived(), a);
   }

References a, and Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator*() [3/3]

template<typename Derived_ >

template<int N>

constexpr ProductExpr<Derived, ValueExpr<internal::FixedInt<N> > > Eigen::symbolic::BaseExpr< Derived_ >::operator* ( internal::FixedInt< N > ) const

inlineconstexpr

                                                                                                       {
     return ProductExpr<Derived, ValueExpr<internal::FixedInt<N>>>(derived(), ValueExpr<internal::FixedInt<N>>());
   }

References Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator+() [1/3]

template<typename Derived_ >

template<typename OtherDerived >

constexpr AddExpr<Derived, OtherDerived> Eigen::symbolic::BaseExpr< Derived_ >::operator+ ( const BaseExpr< OtherDerived > & b ) const

inlineconstexpr

                                                                                             {
     return AddExpr<Derived, OtherDerived>(derived(), b.derived());
   }

References b, and Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator+() [2/3]

template<typename Derived_ >

constexpr AddExpr<Derived, ValueExpr<> > Eigen::symbolic::BaseExpr< Derived_ >::operator+ ( Index b ) const

inlineconstexpr

                                                                    {
     return AddExpr<Derived, ValueExpr<>>(derived(), b);
   }

References b, and Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator+() [3/3]

template<typename Derived_ >

template<int N>

constexpr AddExpr<Derived, ValueExpr<internal::FixedInt<N> > > Eigen::symbolic::BaseExpr< Derived_ >::operator+ ( internal::FixedInt< N > ) const

inlineconstexpr

                                                                                                   {
     return AddExpr<Derived, ValueExpr<internal::FixedInt<N>>>(derived(), ValueExpr<internal::FixedInt<N>>());
   }

References Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator-() [1/4]

template<typename Derived_ >

constexpr NegateExpr<Derived> Eigen::symbolic::BaseExpr< Derived_ >::operator- ( void ) const

inlineconstexpr

90 { return NegateExpr<Derived>(derived()); }

References Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator-() [2/4]

template<typename Derived_ >

template<typename OtherDerived >

constexpr AddExpr<Derived, NegateExpr<OtherDerived> > Eigen::symbolic::BaseExpr< Derived_ >::operator- ( const BaseExpr< OtherDerived > & b ) const

inlineconstexpr

                                                                                                         {
     return AddExpr<Derived, NegateExpr<OtherDerived>>(derived(), -b.derived());
   }

References b, and Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator-() [3/4]

template<typename Derived_ >

constexpr AddExpr<Derived, ValueExpr<> > Eigen::symbolic::BaseExpr< Derived_ >::operator- ( Index a ) const

inlineconstexpr

                                                                    {
     return AddExpr<Derived, ValueExpr<>>(derived(), -a);
   }

References a, and Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator-() [4/4]

template<typename Derived_ >

template<int N>

constexpr AddExpr<Derived, ValueExpr<internal::FixedInt<-N> > > Eigen::symbolic::BaseExpr< Derived_ >::operator- ( internal::FixedInt< N > ) const

inlineconstexpr

                                                                                                    {
     return AddExpr<Derived, ValueExpr<internal::FixedInt<-N>>>(derived(), ValueExpr<internal::FixedInt<-N>>());
   }

References Eigen::symbolic::BaseExpr< Derived_ >::derived(), and N.

◆ operator/() [1/3]

template<typename Derived_ >

template<typename OtherDerived >

constexpr QuotientExpr<Derived, OtherDerived> Eigen::symbolic::BaseExpr< Derived_ >::operator/ ( const BaseExpr< OtherDerived > & b ) const

inlineconstexpr

                                                                                                  {
     return QuotientExpr<Derived, OtherDerived>(derived(), b.derived());
   }

References b, and Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator/() [2/3]

template<typename Derived_ >

constexpr QuotientExpr<Derived, ValueExpr<> > Eigen::symbolic::BaseExpr< Derived_ >::operator/ ( Index a ) const

inlineconstexpr

                                                                         {
     return QuotientExpr<Derived, ValueExpr<>>(derived(), a);
   }

References a, and Eigen::symbolic::BaseExpr< Derived_ >::derived().

◆ operator/() [3/3]

template<typename Derived_ >

template<int N>

constexpr QuotientExpr<Derived, ValueExpr<internal::FixedInt<N> > > Eigen::symbolic::BaseExpr< Derived_ >::operator/ ( internal::FixedInt< N > ) const

inlineconstexpr

                                                                                                        {
     return QuotientExpr<Derived, ValueExpr<internal::FixedInt<N>>>(derived(), ValueExpr<internal::FixedInt<N>>());
   }

References Eigen::symbolic::BaseExpr< Derived_ >::derived().

Friends And Related Function Documentation

◆ operator* [1/2]

template<typename Derived_ >

constexpr friend ProductExpr<ValueExpr<>, Derived> operator*	(	Index	a,
		const BaseExpr< Derived_ > &	b
	)

friend

                                                                                            {
     return ProductExpr<ValueExpr<>, Derived>(a, b.derived());
   }

◆ operator* [2/2]

template<typename Derived_ >

template<int N>

constexpr friend ProductExpr<ValueExpr<internal::FixedInt<N> >, Derived> operator*	(	internal::FixedInt< N >	,
		const BaseExpr< Derived_ > &	b
	)

friend

                                                                                                        {
     return ProductExpr<ValueExpr<internal::FixedInt<N>>, Derived>(ValueExpr<internal::FixedInt<N>>(), b.derived());
   }

◆ operator+ [1/2]

template<typename Derived_ >

constexpr friend AddExpr<Derived, ValueExpr<> > operator+	(	Index	a,
		const BaseExpr< Derived_ > &	b
	)

friend

                                                                                        {
     return AddExpr<Derived, ValueExpr<>>(b.derived(), a);
   }

◆ operator+ [2/2]

template<typename Derived_ >

template<int N>

constexpr friend AddExpr<Derived, ValueExpr<internal::FixedInt<N> > > operator+	(	internal::FixedInt< N >	,
		const BaseExpr< Derived_ > &	b
	)

friend

                                                                                                    {
     return AddExpr<Derived, ValueExpr<internal::FixedInt<N>>>(b.derived(), ValueExpr<internal::FixedInt<N>>());
   }

◆ operator- [1/2]

template<typename Derived_ >

constexpr friend AddExpr<NegateExpr<Derived>, ValueExpr<> > operator-	(	Index	a,
		const BaseExpr< Derived_ > &	b
	)

friend

                                                                                                    {
     return AddExpr<NegateExpr<Derived>, ValueExpr<>>(-b.derived(), a);
   }

◆ operator- [2/2]

template<typename Derived_ >

template<int N>

constexpr friend AddExpr<NegateExpr<Derived>, ValueExpr<internal::FixedInt<N> > > operator-	(	internal::FixedInt< N >	,
		const BaseExpr< Derived_ > &	b
	)

friend

                                                                                                                {
     return AddExpr<NegateExpr<Derived>, ValueExpr<internal::FixedInt<N>>>(-b.derived(),
                                                                           ValueExpr<internal::FixedInt<N>>());
   }

◆ operator/ [1/2]

template<typename Derived_ >

constexpr friend QuotientExpr<ValueExpr<>, Derived> operator/	(	Index	a,
		const BaseExpr< Derived_ > &	b
	)

friend

                                                                                             {
     return QuotientExpr<ValueExpr<>, Derived>(a, b.derived());
   }

◆ operator/ [2/2]

template<typename Derived_ >

template<int N>

constexpr friend QuotientExpr<ValueExpr<internal::FixedInt<N> >, Derived> operator/	(	internal::FixedInt< N >	,
		const BaseExpr< Derived_ > &	b
	)

friend

                                                                                                         {
     return QuotientExpr<ValueExpr<internal::FixedInt<N>>, Derived>(ValueExpr<internal::FixedInt<N>>(), b.derived());
   }

The documentation for this class was generated from the following file:

SymbolicIndex.h

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

template<typename Derived_> class Eigen::symbolic::BaseExpr< Derived_ >

Member Typedef Documentation

◆ Derived

Member Function Documentation

◆ derived()

◆ eval()

◆ eval_at_compile_time()

◆ operator*() [1/3]

◆ operator*() [2/3]

◆ operator*() [3/3]

◆ operator+() [1/3]

◆ operator+() [2/3]

◆ operator+() [3/3]

◆ operator-() [1/4]

◆ operator-() [2/4]

◆ operator-() [3/4]

◆ operator-() [4/4]

◆ operator/() [1/3]

◆ operator/() [2/3]

◆ operator/() [3/3]

Friends And Related Function Documentation

◆ operator* [1/2]

◆ operator* [2/2]

◆ operator+ [1/2]

◆ operator+ [2/2]

◆ operator- [1/2]

◆ operator- [2/2]

◆ operator/ [1/2]

◆ operator/ [2/2]

template<typename Derived_>
class Eigen::symbolic::BaseExpr< Derived_ >