Path Tracer
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 
13 namespace Eigen {
14 
41 namespace symbolic {
42 
43 template<typename Tag> class Symbol;
44 template<typename Arg0> class NegateExpr;
45 template<typename Arg1,typename Arg2> class AddExpr;
46 template<typename Arg1,typename Arg2> class ProductExpr;
47 template<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...
51 template<typename IndexType=Index>
52 class ValueExpr {
53 public:
54  ValueExpr(IndexType val) : m_value(val) {}
55  template<typename T>
56  IndexType eval_impl(const T&) const { return m_value; }
57 protected:
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.
63 template<int N>
64 class ValueExpr<internal::FixedInt<N> > {
65 public:
66  ValueExpr() {}
67  template<typename T>
68  Index eval_impl(const T&) const { return N; }
69 };
70 
71 
76 template<typename Derived>
77 class BaseExpr
78 {
79 public:
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 
188 template<typename T>
189 struct 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 
198 template<typename Tag>
199 class SymbolValue
200 {
201 public:
203  SymbolValue(Index val) : m_value(val) {}
204 
206  Index value() const { return m_value; }
207 protected:
208  Index m_value;
209 };
210 
212 template<typename tag>
213 class SymbolExpr : public BaseExpr<SymbolExpr<tag> >
214 {
215 public:
217  typedef tag Tag;
218 
219  SymbolExpr() {}
220 
225  SymbolValue<Tag> operator=(Index val) const {
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 
238 template<typename Arg0>
239 class NegateExpr : public BaseExpr<NegateExpr<Arg0> >
240 {
241 public:
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); }
246 protected:
247  Arg0 m_arg0;
248 };
249 
250 template<typename Arg0, typename Arg1>
251 class AddExpr : public BaseExpr<AddExpr<Arg0,Arg1> >
252 {
253 public:
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); }
258 protected:
259  Arg0 m_arg0;
260  Arg1 m_arg1;
261 };
262 
263 template<typename Arg0, typename Arg1>
264 class ProductExpr : public BaseExpr<ProductExpr<Arg0,Arg1> >
265 {
266 public:
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); }
271 protected:
272  Arg0 m_arg0;
273  Arg1 m_arg1;
274 };
275 
276 template<typename Arg0, typename Arg1>
277 class QuotientExpr : public BaseExpr<QuotientExpr<Arg0,Arg1> >
278 {
279 public:
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); }
284 protected:
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
Eigen
Namespace containing all symbols from the Eigen library.
Definition: LDLT.h:16
Eigen::symbolic::SymbolExpr::operator=
SymbolValue< Tag > operator=(Index val) const
Definition: SymbolicIndex.h:225
Eigen::symbolic::is_symbolic
Definition: SymbolicIndex.h:189
Eigen::symbolic::NegateExpr
Definition: SymbolicIndex.h:240
Eigen::symbolic::ValueExpr
Definition: SymbolicIndex.h:52
Eigen::internal::is_convertible
Definition: Meta.h:219
Eigen::symbolic::BaseExpr
Definition: SymbolicIndex.h:78
Eigen::symbolic::SymbolValue::SymbolValue
SymbolValue(Index val)
Definition: SymbolicIndex.h:203
Eigen::symbolic::QuotientExpr
Definition: SymbolicIndex.h:278
Eigen::symbolic::SymbolValue::value
Index value() const
Definition: SymbolicIndex.h:206
Eigen::symbolic::ProductExpr
Definition: SymbolicIndex.h:265
Eigen::symbolic::AddExpr
Definition: SymbolicIndex.h:252
Eigen::symbolic::Symbol
Definition: SymbolicIndex.h:43
Eigen::symbolic::SymbolValue
Definition: SymbolicIndex.h:200
Eigen::symbolic::SymbolExpr::Tag
tag Tag
Definition: SymbolicIndex.h:217
Eigen::symbolic::BaseExpr::eval
Index eval(const T &values) const
Definition: SymbolicIndex.h:89
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:42
Eigen::symbolic::SymbolExpr
Definition: SymbolicIndex.h:214
Generated by   doxygen 1.8.19