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
IndexedViewHelper.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
11#ifndef EIGEN_INDEXED_VIEW_HELPER_H
12#define EIGEN_INDEXED_VIEW_HELPER_H
13
14namespace Eigen {
15
16namespace internal {
17struct symbolic_last_tag {};
18}
19
38static const symbolic::SymbolExpr<internal::symbolic_last_tag> last; // PLEASE use Eigen::last instead of Eigen::placeholders::last
39
52#ifdef EIGEN_PARSED_BY_DOXYGEN
53static const auto lastp1 = last+fix<1>;
54#else
55// Using a FixedExpr<1> expression is important here to make sure the compiler
56// can fully optimize the computation starting indices with zero overhead.
57static const symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,symbolic::ValueExpr<Eigen::internal::FixedInt<1> > > lastp1(last+fix<1>());
58#endif
59
60namespace internal {
61
62 // Replace symbolic last/end "keywords" by their true runtime value
63inline Index eval_expr_given_size(Index x, Index /* size */) { return x; }
64
65template<int N>
66FixedInt<N> eval_expr_given_size(FixedInt<N> x, Index /*size*/) { return x; }
67
68template<typename Derived>
69Index eval_expr_given_size(const symbolic::BaseExpr<Derived> &x, Index size)
70{
71 return x.derived().eval(last=size-1);
72}
73
74// Extract increment/step at compile time
75template<typename T, typename EnableIf = void> struct get_compile_time_incr {
76 enum { value = UndefinedIncr };
77};
78
79// Analogue of std::get<0>(x), but tailored for our needs.
80template<typename T>
81EIGEN_CONSTEXPR Index first(const T& x) EIGEN_NOEXCEPT { return x.first(); }
82
83// IndexedViewCompatibleType/makeIndexedViewCompatible turn an arbitrary object of type T into something usable by MatrixSlice
84// The generic implementation is a no-op
85template<typename T,int XprSize,typename EnableIf=void>
86struct IndexedViewCompatibleType {
87 typedef T type;
88};
89
90template<typename T,typename Q>
91const T& makeIndexedViewCompatible(const T& x, Index /*size*/, Q) { return x; }
92
93//--------------------------------------------------------------------------------
94// Handling of a single Index
95//--------------------------------------------------------------------------------
96
97struct SingleRange {
98 enum {
99 SizeAtCompileTime = 1
100 };
101 SingleRange(Index val) : m_value(val) {}
102 Index operator[](Index) const { return m_value; }
103 static EIGEN_CONSTEXPR Index size() EIGEN_NOEXCEPT { return 1; }
104 Index first() const EIGEN_NOEXCEPT { return m_value; }
105 Index m_value;
106};
107
108template<> struct get_compile_time_incr<SingleRange> {
109 enum { value = 1 }; // 1 or 0 ??
110};
111
112// Turn a single index into something that looks like an array (i.e., that exposes a .size(), and operator[](int) methods)
113template<typename T, int XprSize>
114struct IndexedViewCompatibleType<T,XprSize,typename internal::enable_if<internal::is_integral<T>::value>::type> {
115 // Here we could simply use Array, but maybe it's less work for the compiler to use
116 // a simpler wrapper as SingleRange
117 //typedef Eigen::Array<Index,1,1> type;
118 typedef SingleRange type;
119};
120
121template<typename T, int XprSize>
122struct IndexedViewCompatibleType<T, XprSize, typename enable_if<symbolic::is_symbolic<T>::value>::type> {
123 typedef SingleRange type;
124};
125
126
127template<typename T>
128typename enable_if<symbolic::is_symbolic<T>::value,SingleRange>::type
129makeIndexedViewCompatible(const T& id, Index size, SpecializedType) {
130 return eval_expr_given_size(id,size);
131}
132
133//--------------------------------------------------------------------------------
134// Handling of all
135//--------------------------------------------------------------------------------
136
137struct all_t { all_t() {} };
138
139// Convert a symbolic 'all' into a usable range type
140template<int XprSize>
141struct AllRange {
142 enum { SizeAtCompileTime = XprSize };
143 AllRange(Index size = XprSize) : m_size(size) {}
144 EIGEN_CONSTEXPR Index operator[](Index i) const EIGEN_NOEXCEPT { return i; }
145 EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_size.value(); }
146 EIGEN_CONSTEXPR Index first() const EIGEN_NOEXCEPT { return 0; }
147 variable_if_dynamic<Index,XprSize> m_size;
148};
149
150template<int XprSize>
151struct IndexedViewCompatibleType<all_t,XprSize> {
152 typedef AllRange<XprSize> type;
153};
154
155template<typename XprSizeType>
156inline AllRange<get_fixed_value<XprSizeType>::value> makeIndexedViewCompatible(all_t , XprSizeType size, SpecializedType) {
157 return AllRange<get_fixed_value<XprSizeType>::value>(size);
158}
159
160template<int Size> struct get_compile_time_incr<AllRange<Size> > {
161 enum { value = 1 };
162};
163
164} // end namespace internal
165
166
171static const Eigen::internal::all_t all; // PLEASE use Eigen::all instead of Eigen::placeholders::all
172
173
174namespace placeholders {
176 typedef symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,symbolic::ValueExpr<Eigen::internal::FixedInt<1> > > end_t;
177 typedef Eigen::internal::all_t all_t;
178
179 EIGEN_DEPRECATED static const all_t all = Eigen::all; // PLEASE use Eigen::all instead of Eigen::placeholders::all
180 EIGEN_DEPRECATED static const last_t last = Eigen::last; // PLEASE use Eigen::last instead of Eigen::placeholders::last
181 EIGEN_DEPRECATED static const end_t end = Eigen::lastp1; // PLEASE use Eigen::lastp1 instead of Eigen::placeholders::end
182}
183
184} // end namespace Eigen
185
186#endif // EIGEN_INDEXED_VIEW_HELPER_H
Definition: SymbolicIndex.h:214
static const symbolic::SymbolExpr< internal::symbolic_last_tag > last
Definition: IndexedViewHelper.h:38
static const auto lastp1
Definition: IndexedViewHelper.h:53
static const Eigen::internal::all_t all
Definition: IndexedViewHelper.h:171
Namespace containing all symbols from the Eigen library.
Definition: Core:141
const int UndefinedIncr
Definition: Constants.h:31
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74