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
ArithmeticSequence.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_ARITHMETIC_SEQUENCE_H
11#define EIGEN_ARITHMETIC_SEQUENCE_H
12
13namespace Eigen {
14
15namespace internal {
16
17#if (!EIGEN_HAS_CXX11) || !((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48)
18template<typename T> struct aseq_negate {};
19
20template<> struct aseq_negate<Index> {
21 typedef Index type;
22};
23
24template<int N> struct aseq_negate<FixedInt<N> > {
25 typedef FixedInt<-N> type;
26};
27
28// Compilation error in the following case:
29template<> struct aseq_negate<FixedInt<DynamicIndex> > {};
30
31template<typename FirstType,typename SizeType,typename IncrType,
32 bool FirstIsSymbolic=symbolic::is_symbolic<FirstType>::value,
33 bool SizeIsSymbolic =symbolic::is_symbolic<SizeType>::value>
34struct aseq_reverse_first_type {
35 typedef Index type;
36};
37
38template<typename FirstType,typename SizeType,typename IncrType>
39struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,true> {
40 typedef symbolic::AddExpr<FirstType,
41 symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >,
42 symbolic::ValueExpr<IncrType> >
43 > type;
44};
45
46template<typename SizeType,typename IncrType,typename EnableIf = void>
47struct aseq_reverse_first_type_aux {
48 typedef Index type;
49};
50
51template<typename SizeType,typename IncrType>
52struct aseq_reverse_first_type_aux<SizeType,IncrType,typename internal::enable_if<bool((SizeType::value+IncrType::value)|0x1)>::type> {
53 typedef FixedInt<(SizeType::value-1)*IncrType::value> type;
54};
55
56template<typename FirstType,typename SizeType,typename IncrType>
57struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,false> {
58 typedef typename aseq_reverse_first_type_aux<SizeType,IncrType>::type Aux;
59 typedef symbolic::AddExpr<FirstType,symbolic::ValueExpr<Aux> > type;
60};
61
62template<typename FirstType,typename SizeType,typename IncrType>
63struct aseq_reverse_first_type<FirstType,SizeType,IncrType,false,true> {
64 typedef symbolic::AddExpr<symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >,
65 symbolic::ValueExpr<IncrType> >,
66 symbolic::ValueExpr<> > type;
67};
68#endif
69
70// Helper to cleanup the type of the increment:
71template<typename T> struct cleanup_seq_incr {
72 typedef typename cleanup_index_type<T,DynamicIndex>::type type;
73};
74
75}
76
77//--------------------------------------------------------------------------------
78// seq(first,last,incr) and seqN(first,size,incr)
79//--------------------------------------------------------------------------------
80
81template<typename FirstType=Index,typename SizeType=Index,typename IncrType=internal::FixedInt<1> >
82class ArithmeticSequence;
83
84template<typename FirstType,typename SizeType,typename IncrType>
85ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
86 typename internal::cleanup_index_type<SizeType>::type,
87 typename internal::cleanup_seq_incr<IncrType>::type >
88seqN(FirstType first, SizeType size, IncrType incr);
89
109template<typename FirstType,typename SizeType,typename IncrType>
111{
112public:
113 ArithmeticSequence(FirstType first, SizeType size) : m_first(first), m_size(size) {}
114 ArithmeticSequence(FirstType first, SizeType size, IncrType incr) : m_first(first), m_size(size), m_incr(incr) {}
115
116 enum {
117 SizeAtCompileTime = internal::get_fixed_value<SizeType>::value,
118 IncrAtCompileTime = internal::get_fixed_value<IncrType,DynamicIndex>::value
119 };
120
122 Index size() const { return m_size; }
123
125 Index first() const { return m_first; }
126
128 Index operator[](Index i) const { return m_first + i * m_incr; }
129
130 const FirstType& firstObject() const { return m_first; }
131 const SizeType& sizeObject() const { return m_size; }
132 const IncrType& incrObject() const { return m_incr; }
133
134protected:
135 FirstType m_first;
136 SizeType m_size;
137 IncrType m_incr;
138
139public:
140
141#if EIGEN_HAS_CXX11 && ((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48)
142 auto reverse() const -> decltype(Eigen::seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr)) {
143 return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr);
144 }
145#else
146protected:
147 typedef typename internal::aseq_negate<IncrType>::type ReverseIncrType;
148 typedef typename internal::aseq_reverse_first_type<FirstType,SizeType,IncrType>::type ReverseFirstType;
149public:
150 ArithmeticSequence<ReverseFirstType,SizeType,ReverseIncrType>
151 reverse() const {
152 return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr);
153 }
154#endif
155};
156
160template<typename FirstType,typename SizeType,typename IncrType>
161ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type >
162seqN(FirstType first, SizeType size, IncrType incr) {
163 return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type>(first,size,incr);
164}
165
169template<typename FirstType,typename SizeType>
170ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type >
171seqN(FirstType first, SizeType size) {
172 return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type>(first,size);
173}
174
175#ifdef EIGEN_PARSED_BY_DOXYGEN
176
186template<typename FirstType,typename LastType, typename IncrType>
187auto seq(FirstType f, LastType l, IncrType incr);
188
198template<typename FirstType,typename LastType>
199auto seq(FirstType f, LastType l);
200
201#else // EIGEN_PARSED_BY_DOXYGEN
202
203#if EIGEN_HAS_CXX11
204template<typename FirstType,typename LastType>
205auto seq(FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
206 ( typename internal::cleanup_index_type<LastType>::type(l)
207 - typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())))
208{
209 return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
210 (typename internal::cleanup_index_type<LastType>::type(l)
211 -typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
212}
213
214template<typename FirstType,typename LastType, typename IncrType>
215auto seq(FirstType f, LastType l, IncrType incr)
216 -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
217 ( typename internal::cleanup_index_type<LastType>::type(l)
218 - typename internal::cleanup_index_type<FirstType>::type(f)+typename internal::cleanup_seq_incr<IncrType>::type(incr)
219 ) / typename internal::cleanup_seq_incr<IncrType>::type(incr),
220 typename internal::cleanup_seq_incr<IncrType>::type(incr)))
221{
222 typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
223 return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
224 ( typename internal::cleanup_index_type<LastType>::type(l)
225 -typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr)) / CleanedIncrType(incr),
226 CleanedIncrType(incr));
227}
228
229#else // EIGEN_HAS_CXX11
230
231template<typename FirstType,typename LastType>
232typename internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value),
233 ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index> >::type
234seq(FirstType f, LastType l)
235{
236 return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
237 Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())));
238}
239
240template<typename FirstTypeDerived,typename LastType>
241typename internal::enable_if<!symbolic::is_symbolic<LastType>::value,
242 ArithmeticSequence<FirstTypeDerived, symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>,symbolic::ValueExpr<> >,
243 symbolic::ValueExpr<internal::FixedInt<1> > > > >::type
244seq(const symbolic::BaseExpr<FirstTypeDerived> &f, LastType l)
245{
246 return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+fix<1>()));
247}
248
249template<typename FirstType,typename LastTypeDerived>
250typename internal::enable_if<!symbolic::is_symbolic<FirstType>::value,
251 ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
252 symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >,
253 symbolic::ValueExpr<internal::FixedInt<1> > > > >::type
254seq(FirstType f, const symbolic::BaseExpr<LastTypeDerived> &l)
255{
256 return seqN(typename internal::cleanup_index_type<FirstType>::type(f),(l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
257}
258
259template<typename FirstTypeDerived,typename LastTypeDerived>
260ArithmeticSequence<FirstTypeDerived,
261 symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::NegateExpr<FirstTypeDerived> >,symbolic::ValueExpr<internal::FixedInt<1> > > >
262seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<LastTypeDerived> &l)
263{
264 return seqN(f.derived(),(l.derived()-f.derived()+fix<1>()));
265}
266
267
268template<typename FirstType,typename LastType, typename IncrType>
269typename internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value),
270 ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index,typename internal::cleanup_seq_incr<IncrType>::type> >::type
271seq(FirstType f, LastType l, IncrType incr)
272{
273 typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
274 return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
275 Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr)), incr);
276}
277
278template<typename FirstTypeDerived,typename LastType, typename IncrType>
279typename internal::enable_if<!symbolic::is_symbolic<LastType>::value,
280 ArithmeticSequence<FirstTypeDerived,
281 symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>,
282 symbolic::ValueExpr<> >,
283 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
284 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
285 typename internal::cleanup_seq_incr<IncrType>::type> >::type
286seq(const symbolic::BaseExpr<FirstTypeDerived> &f, LastType l, IncrType incr)
287{
288 typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
289 return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
290}
291
292template<typename FirstType,typename LastTypeDerived, typename IncrType>
293typename internal::enable_if<!symbolic::is_symbolic<FirstType>::value,
294 ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
295 symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >,
296 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
297 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
298 typename internal::cleanup_seq_incr<IncrType>::type> >::type
299seq(FirstType f, const symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr)
300{
301 typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
302 return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
303 (l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
304}
305
306template<typename FirstTypeDerived,typename LastTypeDerived, typename IncrType>
307ArithmeticSequence<FirstTypeDerived,
308 symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,
309 symbolic::NegateExpr<FirstTypeDerived> >,
310 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
311 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
312 typename internal::cleanup_seq_incr<IncrType>::type>
313seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr)
314{
315 typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
316 return seqN(f.derived(),(l.derived()-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
317}
318#endif // EIGEN_HAS_CXX11
319
320#endif // EIGEN_PARSED_BY_DOXYGEN
321
322
323#if EIGEN_HAS_CXX11 || defined(EIGEN_PARSED_BY_DOXYGEN)
330template<typename SizeType,typename IncrType>
331auto lastN(SizeType size, IncrType incr)
332-> decltype(seqN(Eigen::last-(size-fix<1>())*incr, size, incr))
333{
334 return seqN(Eigen::last-(size-fix<1>())*incr, size, incr);
335}
336
343template<typename SizeType>
344auto lastN(SizeType size)
345-> decltype(seqN(Eigen::last+fix<1>()-size, size))
346{
347 return seqN(Eigen::last+fix<1>()-size, size);
348}
349#endif
350
351namespace internal {
352
353// Convert a symbolic span into a usable one (i.e., remove last/end "keywords")
354template<typename T>
355struct make_size_type {
356 typedef typename internal::conditional<symbolic::is_symbolic<T>::value, Index, T>::type type;
357};
358
359template<typename FirstType,typename SizeType,typename IncrType,int XprSize>
360struct IndexedViewCompatibleType<ArithmeticSequence<FirstType,SizeType,IncrType>, XprSize> {
361 typedef ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType> type;
362};
363
364template<typename FirstType,typename SizeType,typename IncrType>
365ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>
366makeIndexedViewCompatible(const ArithmeticSequence<FirstType,SizeType,IncrType>& ids, Index size,SpecializedType) {
367 return ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>(
368 eval_expr_given_size(ids.firstObject(),size),eval_expr_given_size(ids.sizeObject(),size),ids.incrObject());
369}
370
371template<typename FirstType,typename SizeType,typename IncrType>
372struct get_compile_time_incr<ArithmeticSequence<FirstType,SizeType,IncrType> > {
373 enum { value = get_fixed_value<IncrType,DynamicIndex>::value };
374};
375
376} // end namespace internal
377
399namespace indexing {
400 using Eigen::all;
401 using Eigen::seq;
402 using Eigen::seqN;
403 #if EIGEN_HAS_CXX11
404 using Eigen::lastN;
405 #endif
406 using Eigen::last;
407 using Eigen::lastp1;
408 using Eigen::fix;
409}
410
411} // end namespace Eigen
412
413#endif // EIGEN_ARITHMETIC_SEQUENCE_H
Definition: ArithmeticSequence.h:111
Index operator[](Index i) const
Definition: ArithmeticSequence.h:128
Index first() const
Definition: ArithmeticSequence.h:125
Index size() const
Definition: ArithmeticSequence.h:122
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
static const auto fix()
Namespace containing all symbols from the Eigen library.
Definition: Core:141
auto seq(FirstType f, LastType l, IncrType incr)
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::type > seqN(FirstType first, SizeType size, IncrType incr)
Definition: ArithmeticSequence.h:162
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const int DynamicIndex
Definition: Constants.h:27
auto lastN(SizeType size, IncrType incr) -> decltype(seqN(Eigen::last-(size-fix< 1 >()) *incr, size, incr))
Definition: ArithmeticSequence.h:331