Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.0
 
Loading...
Searching...
No Matches
SymbolicIndex.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
5//
6// This Source Code Form is subject to the terms of the Mozilla
7// Public License v. 2.0. If a copy of the MPL was not distributed
8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9
10#ifndef EIGEN_SYMBOLIC_INDEX_H
11#define EIGEN_SYMBOLIC_INDEX_H
12
13namespace Eigen {
14
41namespace symbolic {
42
43template<typename Tag> class Symbol;
44template<typename Arg0> class NegateExpr;
45template<typename Arg1,typename Arg2> class AddExpr;
46template<typename Arg1,typename Arg2> class ProductExpr;
47template<typename Arg1,typename Arg2> class QuotientExpr;
48
49// A simple wrapper around an integral value to provide the eval method.
50// We could also use a free-function symbolic_eval...
51template<typename IndexType=Index>
52class ValueExpr {
53public:
54 ValueExpr(IndexType val) : m_value(val) {}
55 template<typename T>
56 IndexType eval_impl(const T&) const { return m_value; }
57protected:
58 IndexType m_value;
59};
60
61// Specialization for compile-time value,
62// It is similar to ValueExpr(N) but this version helps the compiler to generate better code.
63template<int N>
64class ValueExpr<internal::FixedInt<N> > {
65public:
66 ValueExpr() {}
67 template<typename T>
68 EIGEN_CONSTEXPR Index eval_impl(const T&) const { return N; }
69};
70
71
76template<typename Derived>
78{
79public:
80 const Derived& derived() const { return *static_cast<const Derived*>(this); }
81
88 template<typename T>
89 Index eval(const T& values) const { return derived().eval_impl(values); }
90
91#if EIGEN_HAS_CXX14
92 template<typename... Types>
93 Index eval(Types&&... values) const { return derived().eval_impl(std::make_tuple(values...)); }
94#endif
95
96 NegateExpr<Derived> operator-() const { return NegateExpr<Derived>(derived()); }
97
98 AddExpr<Derived,ValueExpr<> > operator+(Index b) const
99 { return AddExpr<Derived,ValueExpr<> >(derived(), b); }
100 AddExpr<Derived,ValueExpr<> > operator-(Index a) const
101 { return AddExpr<Derived,ValueExpr<> >(derived(), -a); }
102 ProductExpr<Derived,ValueExpr<> > operator*(Index a) const
103 { return ProductExpr<Derived,ValueExpr<> >(derived(),a); }
104 QuotientExpr<Derived,ValueExpr<> > operator/(Index a) const
105 { return QuotientExpr<Derived,ValueExpr<> >(derived(),a); }
106
107 friend AddExpr<Derived,ValueExpr<> > operator+(Index a, const BaseExpr& b)
108 { return AddExpr<Derived,ValueExpr<> >(b.derived(), a); }
109 friend AddExpr<NegateExpr<Derived>,ValueExpr<> > operator-(Index a, const BaseExpr& b)
110 { return AddExpr<NegateExpr<Derived>,ValueExpr<> >(-b.derived(), a); }
111 friend ProductExpr<ValueExpr<>,Derived> operator*(Index a, const BaseExpr& b)
112 { return ProductExpr<ValueExpr<>,Derived>(a,b.derived()); }
113 friend QuotientExpr<ValueExpr<>,Derived> operator/(Index a, const BaseExpr& b)
114 { return QuotientExpr<ValueExpr<>,Derived>(a,b.derived()); }
115
116 template<int N>
117 AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N>) const
118 { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); }
119 template<int N>
120 AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N>) const
121 { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); }
122 template<int N>
123 ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N>) const
124 { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
125 template<int N>
126 QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N>) const
127 { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
128
129 template<int N>
130 friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N>, const BaseExpr& b)
131 { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); }
132 template<int N>
133 friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N>, const BaseExpr& b)
134 { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); }
135 template<int N>
136 friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N>, const BaseExpr& b)
137 { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
138 template<int N>
139 friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N>, const BaseExpr& b)
140 { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
141
142#if (!EIGEN_HAS_CXX14)
143 template<int N>
144 AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)()) const
145 { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); }
146 template<int N>
147 AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N> (*)()) const
148 { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); }
149 template<int N>
150 ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N> (*)()) const
151 { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
152 template<int N>
153 QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N> (*)()) const
154 { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
155
156 template<int N>
157 friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)(), const BaseExpr& b)
158 { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); }
159 template<int N>
160 friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N> (*)(), const BaseExpr& b)
161 { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); }
162 template<int N>
163 friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N> (*)(), const BaseExpr& b)
164 { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
165 template<int N>
166 friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N> (*)(), const BaseExpr& b)
167 { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
168#endif
169
170
171 template<typename OtherDerived>
172 AddExpr<Derived,OtherDerived> operator+(const BaseExpr<OtherDerived> &b) const
173 { return AddExpr<Derived,OtherDerived>(derived(), b.derived()); }
174
175 template<typename OtherDerived>
176 AddExpr<Derived,NegateExpr<OtherDerived> > operator-(const BaseExpr<OtherDerived> &b) const
177 { return AddExpr<Derived,NegateExpr<OtherDerived> >(derived(), -b.derived()); }
178
179 template<typename OtherDerived>
180 ProductExpr<Derived,OtherDerived> operator*(const BaseExpr<OtherDerived> &b) const
181 { return ProductExpr<Derived,OtherDerived>(derived(), b.derived()); }
182
183 template<typename OtherDerived>
184 QuotientExpr<Derived,OtherDerived> operator/(const BaseExpr<OtherDerived> &b) const
185 { return QuotientExpr<Derived,OtherDerived>(derived(), b.derived()); }
186};
187
188template<typename T>
189struct is_symbolic {
190 // BaseExpr has no conversion ctor, so we only have to check whether T can be statically cast to its base class BaseExpr<T>.
191 enum { value = internal::is_convertible<T,BaseExpr<T> >::value };
192};
193
198template<typename Tag>
200{
201public:
203 SymbolValue(Index val) : m_value(val) {}
204
206 Index value() const { return m_value; }
207protected:
208 Index m_value;
209};
210
212template<typename tag>
213class SymbolExpr : public BaseExpr<SymbolExpr<tag> >
214{
215public:
217 typedef tag Tag;
218
219 SymbolExpr() {}
220
226 return SymbolValue<Tag>(val);
227 }
228
229 Index eval_impl(const SymbolValue<Tag> &values) const { return values.value(); }
230
231#if EIGEN_HAS_CXX14
232 // C++14 versions suitable for multiple symbols
233 template<typename... Types>
234 Index eval_impl(const std::tuple<Types...>& values) const { return std::get<SymbolValue<Tag> >(values).value(); }
235#endif
236};
237
238template<typename Arg0>
239class NegateExpr : public BaseExpr<NegateExpr<Arg0> >
240{
241public:
242 NegateExpr(const Arg0& arg0) : m_arg0(arg0) {}
243
244 template<typename T>
245 Index eval_impl(const T& values) const { return -m_arg0.eval_impl(values); }
246protected:
247 Arg0 m_arg0;
248};
249
250template<typename Arg0, typename Arg1>
251class AddExpr : public BaseExpr<AddExpr<Arg0,Arg1> >
252{
253public:
254 AddExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
255
256 template<typename T>
257 Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) + m_arg1.eval_impl(values); }
258protected:
259 Arg0 m_arg0;
260 Arg1 m_arg1;
261};
262
263template<typename Arg0, typename Arg1>
264class ProductExpr : public BaseExpr<ProductExpr<Arg0,Arg1> >
265{
266public:
267 ProductExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
268
269 template<typename T>
270 Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) * m_arg1.eval_impl(values); }
271protected:
272 Arg0 m_arg0;
273 Arg1 m_arg1;
274};
275
276template<typename Arg0, typename Arg1>
277class QuotientExpr : public BaseExpr<QuotientExpr<Arg0,Arg1> >
278{
279public:
280 QuotientExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
281
282 template<typename T>
283 Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) / m_arg1.eval_impl(values); }
284protected:
285 Arg0 m_arg0;
286 Arg1 m_arg1;
287};
288
289} // end namespace symbolic
290
291} // end namespace Eigen
292
293#endif // EIGEN_SYMBOLIC_INDEX_H
Definition: SymbolicIndex.h:78
Index eval(const T &values) const
Definition: SymbolicIndex.h:89
Definition: SymbolicIndex.h:214
SymbolValue< Tag > operator=(Index val) const
Definition: SymbolicIndex.h:225
tag Tag
Definition: SymbolicIndex.h:217
Definition: SymbolicIndex.h:200
SymbolValue(Index val)
Definition: SymbolicIndex.h:203
Index value() const
Definition: SymbolicIndex.h:206
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74