|
131
|
1 /* { dg-do compile } */
|
|
|
2 /* { dg-additional-options "-w" } */
|
|
|
3 /* { dg-additional-options "-mavx2" { target { x86_64-*-* i?86-*-* } } } */
|
|
|
4
|
|
|
5 namespace std {
|
|
|
6 template < typename _Default > struct __detector { using type = _Default; };
|
|
|
7 template < typename _Default, template < typename > class >
|
|
|
8 using __detected_or = __detector< _Default >;
|
|
|
9 template < typename _Default, template < typename > class _Op >
|
|
|
10 using __detected_or_t = typename __detected_or< _Default, _Op >::type;
|
|
|
11 template < typename > struct iterator_traits;
|
|
|
12 template < typename _Tp > struct iterator_traits< _Tp * > {
|
|
|
13 typedef _Tp reference;
|
|
|
14 };
|
|
|
15 } // std
|
|
|
16 using std::iterator_traits;
|
|
|
17 template < typename _Iterator, typename > struct __normal_iterator {
|
|
|
18 typename iterator_traits< _Iterator >::reference operator*();
|
|
|
19 void operator++();
|
|
|
20 };
|
|
|
21 template < typename _IteratorL, typename _IteratorR, typename _Container >
|
|
|
22 int operator!=(__normal_iterator< _IteratorL, _Container >,
|
|
|
23 __normal_iterator< _IteratorR, _Container >);
|
|
|
24 namespace std {
|
|
|
25 template < typename _Tp > struct allocator { typedef _Tp value_type; };
|
|
|
26 struct __allocator_traits_base {
|
|
|
27 template < typename _Tp > using __pointer = typename _Tp::pointer;
|
|
|
28 };
|
|
|
29 template < typename _Alloc > struct allocator_traits : __allocator_traits_base {
|
|
|
30 using pointer = __detected_or_t< typename _Alloc::value_type *, __pointer >;
|
|
|
31 };
|
|
|
32 } // std
|
|
|
33 typedef double __m128d __attribute__((__vector_size__(16)));
|
|
|
34 typedef double __m256d __attribute__((__vector_size__(32)));
|
|
|
35 enum { InnerVectorizedTraversal, LinearVectorizedTraversal };
|
|
|
36 enum { ReadOnlyAccessors };
|
|
|
37 template < int, typename Then, typename > struct conditional {
|
|
|
38 typedef Then type;
|
|
|
39 };
|
|
|
40 template < typename Then, typename Else > struct conditional< 0, Then, Else > {
|
|
|
41 typedef Else type;
|
|
|
42 };
|
|
|
43 template < typename, typename > struct is_same {
|
|
|
44 enum { value };
|
|
|
45 };
|
|
|
46 template < typename T > struct is_same< T, T > {
|
|
|
47 enum { value = 1 };
|
|
|
48 };
|
|
|
49 template < typename > struct traits;
|
|
|
50 struct accessors_level {
|
|
|
51 enum { has_direct_access, has_write_access, value };
|
|
|
52 };
|
|
|
53 template < typename > struct EigenBase;
|
|
|
54 template < typename > struct PlainObjectBase;
|
|
|
55 template < typename, int = accessors_level::value > struct DenseCoeffsBase;
|
|
|
56 template < typename, int, int, int = 0, int = 0, int = 0 > struct Matrix;
|
|
|
57 template < typename > struct MatrixBase;
|
|
|
58 template < typename, int, int, bool = 0 > struct Block;
|
|
|
59 struct VectorBlock;
|
|
|
60 template < typename, typename > struct CwiseNullaryOp;
|
|
|
61 template < typename, typename, typename > struct CwiseBinaryOp;
|
|
|
62 template < typename, int = accessors_level::has_write_access > struct MapBase;
|
|
|
63 template < typename > struct packet_traits;
|
|
|
64 template < typename > struct unpacket_traits;
|
|
|
65 template < int Size, typename PacketType,
|
|
|
66 int = Size == is_same< PacketType, typename unpacket_traits<
|
|
|
67 PacketType >::half >::value >
|
|
|
68 struct find_best_packet_helper;
|
|
|
69 template < int Size, typename PacketType >
|
|
|
70 struct find_best_packet_helper< Size, PacketType, 1 > {
|
|
|
71 typedef PacketType type;
|
|
|
72 };
|
|
|
73 template < int Size, typename PacketType >
|
|
|
74 struct find_best_packet_helper< Size, PacketType, 0 > {
|
|
|
75 typedef typename find_best_packet_helper<
|
|
|
76 1, typename unpacket_traits< PacketType >::half >::type type;
|
|
|
77 };
|
|
|
78 template < typename T, int Size > struct find_best_packet {
|
|
|
79 typedef typename find_best_packet_helper<
|
|
|
80 Size, typename packet_traits< T >::type >::type type;
|
|
|
81 };
|
|
|
82 struct compute_matrix_flags {
|
|
|
83 enum { ret = 1 };
|
|
|
84 };
|
|
|
85 struct ref_selector {
|
|
|
86 typedef Matrix< double, 10, 1 > &type;
|
|
|
87 };
|
|
|
88 template < typename Derived > struct dense_xpr_base {
|
|
|
89 typedef MatrixBase< Derived > type;
|
|
|
90 };
|
|
|
91 template < typename ExpressionType > struct is_lvalue {
|
|
|
92 enum { value = traits< ExpressionType >::Flags };
|
|
|
93 };
|
|
|
94 template < typename Packet > void pmul(Packet);
|
|
|
95 template < typename Packet >
|
|
|
96 Packet pload(const typename unpacket_traits< Packet >::type *);
|
|
|
97 template < typename Packet >
|
|
|
98 Packet pset1(const typename unpacket_traits< Packet >::type &);
|
|
|
99 template < typename Scalar, typename Packet > void pstoreu(Scalar, Packet &);
|
|
|
100 template < typename Packet, int >
|
|
|
101 Packet ploadt(const typename unpacket_traits< Packet >::type *from) {
|
|
|
102 return pload< Packet >(from);
|
|
|
103 }
|
|
|
104 template < typename Scalar, typename Packet, int >
|
|
|
105 void pstoret(Scalar *to, const Packet from) {
|
|
|
106 pstoreu(to, from);
|
|
|
107 }
|
|
|
108 typedef __m128d Packet2d;
|
|
|
109 template <> struct unpacket_traits< Packet2d > {
|
|
|
110 typedef double type;
|
|
|
111 typedef Packet2d half;
|
|
|
112 };
|
|
|
113 template <> Packet2d pload(const double *from) { return *(__m128d *)from; }
|
|
|
114 typedef __m256d Packet4d;
|
|
|
115 template <> struct packet_traits< double > { typedef Packet4d type; };
|
|
|
116 template <> struct unpacket_traits< Packet4d > {
|
|
|
117 typedef double type;
|
|
|
118 typedef Packet2d half;
|
|
|
119 };
|
|
|
120 __m256d pset1___trans_tmp_1;
|
|
|
121 template <> Packet4d pset1(const double &) {
|
|
|
122 int __A;
|
|
|
123 pset1___trans_tmp_1 = __m256d{__A};
|
|
|
124 return pset1___trans_tmp_1;
|
|
|
125 }
|
|
|
126 template <> void pstoreu(double *to, const Packet4d &from) {
|
|
|
127 *(__attribute__((__vector_size__(4 * sizeof(double)))) double *)to = from;
|
|
|
128 }
|
|
|
129 struct scalar_product_op {
|
|
|
130 template < typename Packet > void packetOp(Packet a, Packet) { pmul(a); }
|
|
|
131 };
|
|
|
132 struct scalar_constant_op {
|
|
|
133 template < typename PacketType > PacketType packetOp() {
|
|
|
134 return pset1< PacketType >(0);
|
|
|
135 }
|
|
|
136 };
|
|
|
137 struct assign_op {
|
|
|
138 template < int, typename Packet > void assignPacket(double *a, Packet b) {
|
|
|
139 pstoret< double, Packet, 0 >(a, b);
|
|
|
140 }
|
|
|
141 };
|
|
|
142 template < typename Derived >
|
|
|
143 struct DenseCoeffsBase< Derived, 0 > : EigenBase< Derived > {};
|
|
|
144 template < typename Derived >
|
|
|
145 struct DenseCoeffsBase< Derived > : DenseCoeffsBase< Derived, 0 > {};
|
|
|
146 template < typename Derived > struct DenseBase : DenseCoeffsBase< Derived > {
|
|
|
147 using DenseCoeffsBase< Derived >::derived;
|
|
|
148 enum { SizeAtCompileTime, MaxSizeAtCompileTime };
|
|
|
149 static CwiseNullaryOp< scalar_constant_op, Derived > Constant();
|
|
|
150 Derived &setConstant();
|
|
|
151 struct FixedSegmentReturnType {
|
|
|
152 typedef VectorBlock Type;
|
|
|
153 };
|
|
|
154 template < int > typename FixedSegmentReturnType::Type segment() {
|
|
|
155 return typename FixedSegmentReturnType::Type(derived(), 0, 0);
|
|
|
156 }
|
|
|
157 };
|
|
|
158 template < typename Derived > struct MatrixBase : DenseBase< Derived > {
|
|
|
159 using DenseBase< Derived >::derived;
|
|
|
160 template < typename OtherDerived >
|
|
|
161 CwiseBinaryOp< scalar_product_op, const Derived, const OtherDerived >
|
|
|
162 cwiseProduct(OtherDerived) {
|
|
|
163 return CwiseBinaryOp< scalar_product_op, const Derived,
|
|
|
164 const OtherDerived >(derived(), derived());
|
|
|
165 }
|
|
|
166 template < typename OtherDerived >
|
|
|
167 Derived &operator=(const DenseBase< OtherDerived > &);
|
|
|
168 };
|
|
|
169 template < typename Derived > struct EigenBase {
|
|
|
170 Derived &derived() { return *static_cast< Derived * >(this); }
|
|
|
171 Derived derived() const;
|
|
|
172 };
|
|
|
173 template < typename > struct binary_evaluator;
|
|
|
174 template < typename Derived > struct evaluator {
|
|
|
175 typedef Derived PlainObjectType;
|
|
|
176 typedef typename PlainObjectType::Scalar Scalar;
|
|
|
177 enum { IsVectorAtCompileTime, Flags };
|
|
|
178 evaluator(PlainObjectType m) : m_data(m.data()) {}
|
|
|
179 Scalar &coeffRef(int, int);
|
|
|
180 template < int, typename PacketType > PacketType packet(int, int) {
|
|
|
181 return ploadt< PacketType, 0 >(m_data);
|
|
|
182 }
|
|
|
183 const Scalar *m_data;
|
|
|
184 };
|
|
|
185 template < typename Scalar, int Rows, int Cols, int Options, int MaxRows,
|
|
|
186 int MaxCols >
|
|
|
187 struct evaluator< Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
|
|
|
188 : evaluator< PlainObjectBase< Matrix< Scalar, Rows, Cols > > > {
|
|
|
189 typedef Matrix< Scalar, Rows, Cols > XprType;
|
|
|
190 evaluator(XprType m) : evaluator< PlainObjectBase< XprType > >(m) {}
|
|
|
191 };
|
|
|
192 struct nullary_wrapper {
|
|
|
193 template < typename T, typename IndexType >
|
|
|
194 T packetOp(scalar_constant_op op, IndexType, IndexType) {
|
|
|
195 return op.packetOp< T >();
|
|
|
196 }
|
|
|
197 };
|
|
|
198 template < typename NullaryOp, typename PlainObjectType >
|
|
|
199 struct evaluator< CwiseNullaryOp< NullaryOp, PlainObjectType > > {
|
|
|
200 evaluator(CwiseNullaryOp< NullaryOp, PlainObjectType >);
|
|
|
201 template < int, typename PacketType, typename IndexType >
|
|
|
202 PacketType packet(IndexType row, IndexType col) {
|
|
|
203 return m_wrapper.packetOp< PacketType >(m_functor, row, col);
|
|
|
204 }
|
|
|
205 NullaryOp m_functor;
|
|
|
206 nullary_wrapper m_wrapper;
|
|
|
207 };
|
|
|
208 template < typename BinaryOp, typename Lhs, typename Rhs >
|
|
|
209 struct evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs > >
|
|
|
210 : binary_evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs > > {
|
|
|
211 evaluator(CwiseBinaryOp< BinaryOp, Lhs, Rhs > xpr)
|
|
|
212 : binary_evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs > >(xpr) {}
|
|
|
213 };
|
|
|
214 template < typename BinaryOp, typename Lhs, typename Rhs >
|
|
|
215 struct binary_evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs > > {
|
|
|
216 binary_evaluator(CwiseBinaryOp< BinaryOp, Lhs, Rhs > xpr)
|
|
|
217 : m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) {}
|
|
|
218 template < int, typename PacketType > PacketType packet(int, int) {
|
|
|
219 PacketType __trans_tmp_1 = m_lhsImpl.template packet< 0, PacketType >(0, 0);
|
|
|
220 PacketType __trans_tmp_2;
|
|
|
221 m_functor.packetOp(__trans_tmp_1, __trans_tmp_2);
|
|
|
222 }
|
|
|
223 BinaryOp m_functor;
|
|
|
224 evaluator< Lhs > m_lhsImpl;
|
|
|
225 evaluator< Rhs > m_rhsImpl;
|
|
|
226 };
|
|
|
227 template < typename Derived > struct mapbase_evaluator {
|
|
|
228 typedef Derived XprType;
|
|
|
229 mapbase_evaluator(XprType map) : m_data(map.data()) {}
|
|
|
230 typename XprType::Scalar &coeffRef(int, int) { return m_data[0]; }
|
|
|
231 typename XprType::PointerType m_data;
|
|
|
232 };
|
|
|
233 template < int > struct block_evaluator;
|
|
|
234 template < typename ArgType, int BlockRows, int BlockCols, bool InnerPanel >
|
|
|
235 struct evaluator< Block< ArgType, BlockRows, BlockCols, InnerPanel > >
|
|
|
236 : block_evaluator< BlockCols > {
|
|
|
237 enum { Flags };
|
|
|
238 evaluator(Block< ArgType, 1, 1 > block) : block_evaluator< 1 >(block) {}
|
|
|
239 };
|
|
|
240 template < int BlockCols >
|
|
|
241 struct block_evaluator
|
|
|
242 : mapbase_evaluator< Block< Matrix< double, 10, 1 >, 1, BlockCols > > {
|
|
|
243 typedef Block< Matrix< double, 10, 1 >, 1, BlockCols > XprType;
|
|
|
244 block_evaluator(XprType block) : mapbase_evaluator< XprType >(block) {}
|
|
|
245 };
|
|
|
246 template < typename DstEvaluator > struct copy_using_evaluator_traits {
|
|
|
247 typedef typename DstEvaluator::XprType Dst;
|
|
|
248 typedef typename Dst::Scalar DstScalar;
|
|
|
249 enum { DstFlags = DstEvaluator::Flags };
|
|
|
250 enum { InnerSize = DstFlags };
|
|
|
251 typedef typename conditional<
|
|
|
252 int() == LinearVectorizedTraversal,
|
|
|
253 typename find_best_packet< DstScalar, Dst::SizeAtCompileTime >::type,
|
|
|
254 typename find_best_packet< DstScalar, InnerSize >::type >::type
|
|
|
255 PacketType;
|
|
|
256 };
|
|
|
257 template < typename Kernel >
|
|
|
258 struct copy_using_evaluator_innervec_CompleteUnrolling {
|
|
|
259 enum { outer, inner, SrcAlignment, DstAlignment };
|
|
|
260 static void run(Kernel kernel) {
|
|
|
261 kernel.template assignPacketByOuterInner< DstAlignment, SrcAlignment,
|
|
|
262 typename Kernel::PacketType >(
|
|
|
263 outer, inner);
|
|
|
264 }
|
|
|
265 };
|
|
|
266 template < typename Kernel > struct dense_assignment_loop {
|
|
|
267 static void run(Kernel kernel) {
|
|
|
268 copy_using_evaluator_innervec_CompleteUnrolling< Kernel >::run(kernel);
|
|
|
269 }
|
|
|
270 };
|
|
|
271 template < typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT,
|
|
|
272 typename Functor >
|
|
|
273 struct generic_dense_assignment_kernel {
|
|
|
274 typedef DstEvaluatorTypeT DstXprType;
|
|
|
275 typedef DstEvaluatorTypeT DstEvaluatorType;
|
|
|
276 typedef SrcEvaluatorTypeT SrcEvaluatorType;
|
|
|
277 typedef typename copy_using_evaluator_traits< DstEvaluatorTypeT >::PacketType
|
|
|
278 PacketType;
|
|
|
279 generic_dense_assignment_kernel(DstEvaluatorType dst, SrcEvaluatorType src,
|
|
|
280 Functor, DstXprType dstExpr)
|
|
|
281 : m_dst(dst), m_src(src), m_dstExpr(dstExpr) {}
|
|
|
282 template < int StoreMode, int LoadMode, typename >
|
|
|
283 void assignPacketByOuterInner(long, long) {
|
|
|
284 long row;
|
|
|
285 long col;
|
|
|
286 m_functor.template assignPacket< StoreMode >(
|
|
|
287 &m_dst.coeffRef(row, col),
|
|
|
288 m_src.template packet< LoadMode, PacketType >(row, col));
|
|
|
289 }
|
|
|
290 DstEvaluatorType &m_dst;
|
|
|
291 SrcEvaluatorType m_src;
|
|
|
292 Functor m_functor;
|
|
|
293 DstXprType m_dstExpr;
|
|
|
294 };
|
|
|
295 template < typename DstXprType, typename SrcXprType, typename Functor >
|
|
|
296 void call_dense_assignment_loop(DstXprType dst, SrcXprType src, Functor func) {
|
|
|
297 typedef evaluator< DstXprType > DstEvaluatorType;
|
|
|
298 typedef evaluator< SrcXprType > SrcEvaluatorType;
|
|
|
299 SrcEvaluatorType srcEvaluator(src);
|
|
|
300 DstEvaluatorType dstEvaluator(dst);
|
|
|
301 typedef generic_dense_assignment_kernel< DstEvaluatorType, SrcEvaluatorType,
|
|
|
302 Functor >
|
|
|
303 Kernel;
|
|
|
304 Kernel kernel(dstEvaluator, srcEvaluator, func, dst);
|
|
|
305 dense_assignment_loop< Kernel >::run(kernel);
|
|
|
306 }
|
|
|
307 template < typename, typename, typename > struct Assignment;
|
|
|
308 template < typename Dst, typename Src > void call_assignment(Dst dst, Src src) {
|
|
|
309 call_assignment(dst, src, assign_op());
|
|
|
310 }
|
|
|
311 template < typename Dst, typename Src, typename Func >
|
|
|
312 void call_assignment(Dst dst, Src src, Func func) {
|
|
|
313 call_assignment_no_alias(dst, src, func);
|
|
|
314 }
|
|
|
315 template < typename Dst, typename Src, typename Func >
|
|
|
316 void call_assignment_no_alias(Dst dst, Src src, Func func) {
|
|
|
317 enum { NeedToTranspose };
|
|
|
318 Assignment< typename conditional< NeedToTranspose, int, Dst >::type, Src,
|
|
|
319 Func >::run(dst, src, func);
|
|
|
320 }
|
|
|
321 template < typename DstXprType, typename SrcXprType, typename Functor >
|
|
|
322 struct Assignment {
|
|
|
323 static void run(DstXprType dst, SrcXprType src, Functor func) {
|
|
|
324 call_dense_assignment_loop(dst, src, func);
|
|
|
325 }
|
|
|
326 };
|
|
|
327 template < typename Derived >
|
|
|
328 template < typename OtherDerived >
|
|
|
329 Derived &MatrixBase< Derived >::
|
|
|
330 operator=(const DenseBase< OtherDerived > &other) {
|
|
|
331 call_assignment(derived(), other.derived());
|
|
|
332 }
|
|
|
333 template < int Size > struct plain_array { double array[Size]; };
|
|
|
334 template < int Size > class DenseStorage {
|
|
|
335 plain_array< Size > m_data;
|
|
|
336
|
|
|
337 public:
|
|
|
338 const double *data() const { return m_data.array; }
|
|
|
339 double *data() { return m_data.array; }
|
|
|
340 };
|
|
|
341 template < typename Derived >
|
|
|
342 struct PlainObjectBase : dense_xpr_base< Derived >::type {
|
|
|
343 typedef typename dense_xpr_base< Derived >::type Base;
|
|
|
344 typedef typename traits< Derived >::Scalar Scalar;
|
|
|
345 DenseStorage< Base::MaxSizeAtCompileTime > m_storage;
|
|
|
346 const Scalar *data() const { return m_storage.data(); }
|
|
|
347 Scalar *data() { return m_storage.data(); }
|
|
|
348 PlainObjectBase() {}
|
|
|
349 template < typename OtherDerived > PlainObjectBase(OtherDerived other) {
|
|
|
350 call_assignment_no_alias(this->derived(), other, assign_op());
|
|
|
351 }
|
|
|
352 };
|
|
|
353 template < typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows,
|
|
|
354 int _MaxCols >
|
|
|
355 struct traits< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > > {
|
|
|
356 typedef _Scalar Scalar;
|
|
|
357 enum { Flags = compute_matrix_flags::ret };
|
|
|
358 };
|
|
|
359 template < typename, int _Rows, int _Cols, int, int, int >
|
|
|
360 struct Matrix : PlainObjectBase< Matrix< double, _Rows, _Cols > > {
|
|
|
361 PlainObjectBase< Matrix > Base;
|
|
|
362 Matrix() {}
|
|
|
363 template < typename OtherDerived > Matrix(OtherDerived other) : Base(other) {}
|
|
|
364 };
|
|
|
365 template < typename, typename, typename > struct CwiseBinaryOp {
|
|
|
366 typedef ref_selector::type LhsNested;
|
|
|
367 CwiseBinaryOp(Matrix< double, 10, 1 > &aLhs, Matrix< double, 0, 0 >)
|
|
|
368 : m_lhs(aLhs) {}
|
|
|
369 LhsNested lhs() { return m_lhs; }
|
|
|
370 Matrix< double, 8, 1 > rhs() {}
|
|
|
371 LhsNested m_lhs;
|
|
|
372 };
|
|
|
373 template < typename NullaryOp, typename >
|
|
|
374 struct CwiseNullaryOp
|
|
|
375 : dense_xpr_base< CwiseNullaryOp< NullaryOp, int > >::type {};
|
|
|
376 template < typename Derived > Derived &DenseBase< Derived >::setConstant() {
|
|
|
377 derived() = Constant();
|
|
|
378 }
|
|
|
379 template < typename Derived >
|
|
|
380 struct MapBase< Derived, ReadOnlyAccessors > : dense_xpr_base< Derived >::type {
|
|
|
381 typedef typename dense_xpr_base< Derived >::type Base;
|
|
|
382 typedef typename traits< Derived >::Scalar Scalar;
|
|
|
383 typedef typename conditional< is_lvalue< Derived >::value, Scalar *,
|
|
|
384 Scalar >::type PointerType;
|
|
|
385 Scalar *data() { return m_data; }
|
|
|
386 MapBase(PointerType dataPtr, long, long) : m_data(dataPtr) {}
|
|
|
387 PointerType m_data;
|
|
|
388 };
|
|
|
389 template < typename Derived >
|
|
|
390 struct MapBase< Derived > : MapBase< Derived, ReadOnlyAccessors > {
|
|
|
391 typedef MapBase< Derived, ReadOnlyAccessors > Base;
|
|
|
392 MapBase(typename Base::PointerType dataPtr, long rows, long cols)
|
|
|
393 : Base(dataPtr, rows, cols) {}
|
|
|
394 using MapBase< Derived, ReadOnlyAccessors >::Base::operator=;
|
|
|
395 };
|
|
|
396 template < typename XprType, int BlockRows, int BlockCols, bool InnerPanel >
|
|
|
397 struct traits< Block< XprType, BlockRows, BlockCols, InnerPanel > >
|
|
|
398 : traits< XprType > {};
|
|
|
399 template < int, int > struct BlockImpl_dense;
|
|
|
400 template < typename, int, int, typename > class BlockImpl;
|
|
|
401 template < typename, int BlockRows, int BlockCols, bool >
|
|
|
402 struct Block : BlockImpl< Matrix< double, 10, 1 >, BlockRows, BlockCols, int > {
|
|
|
403 typedef BlockImpl< Matrix< double, 10, 1 >, BlockRows, BlockCols, int > Impl;
|
|
|
404 using Impl::operator=;
|
|
|
405 Block(Matrix< double, 10, 1 > &xpr, long startRow, long startCol,
|
|
|
406 long blockRows, long blockCols)
|
|
|
407 : Impl(xpr, startRow, startCol, blockRows, blockCols) {}
|
|
|
408 };
|
|
|
409 template < typename XprType, int BlockRows, int BlockCols >
|
|
|
410 struct BlockImpl< XprType, BlockRows, BlockCols, int >
|
|
|
411 : BlockImpl_dense< BlockRows, BlockCols > {
|
|
|
412 typedef BlockImpl_dense< BlockRows, BlockCols > Impl;
|
|
|
413 typedef Impl Base;
|
|
|
414 using Base::operator=;
|
|
|
415 BlockImpl(XprType &xpr, long startRow, long startCol, long blockRows,
|
|
|
416 long blockCols)
|
|
|
417 : Impl(xpr, startRow, startCol, blockRows, blockCols) {}
|
|
|
418 };
|
|
|
419 template < int BlockRows, int BlockCols >
|
|
|
420 struct BlockImpl_dense
|
|
|
421 : MapBase< Block< Matrix< double, 10, 1 >, BlockRows, BlockCols > > {
|
|
|
422 typedef MapBase< Block< Matrix< double, 10, 1 >, BlockRows, BlockCols > >
|
|
|
423 Base;
|
|
|
424 using Base::operator=;
|
|
|
425 BlockImpl_dense(Matrix< double, 10, 1 > &xpr, long, long, long blockRows,
|
|
|
426 long blockCols)
|
|
|
427 : Base(xpr.data(), blockRows, blockCols) {}
|
|
|
428 };
|
|
|
429 struct VectorBlock : Block< int, traits< Matrix< double, 0, 1 > >::Flags, 1 > {
|
|
|
430 VectorBlock(Matrix< double, 10, 1 > &vector, long start, long size)
|
|
|
431 : Block(vector, 0, start, 1, size) {}
|
|
|
432 };
|
|
|
433 namespace std {
|
|
|
434 template < typename _Alloc > struct _Vector_base {
|
|
|
435 typedef typename allocator_traits< _Alloc >::pointer pointer;
|
|
|
436 };
|
|
|
437 template < typename _Tp, typename _Alloc = allocator< _Tp > > class vector {
|
|
|
438 public:
|
|
|
439 typedef __normal_iterator< typename _Vector_base< _Alloc >::pointer, int >
|
|
|
440 iterator;
|
|
|
441 iterator begin();
|
|
|
442 iterator end();
|
|
|
443 };
|
|
|
444 struct FrameHessian {
|
|
|
445 Matrix< double, 0, 1 > step;
|
|
|
446 void setState(Matrix< double, 0, 1 >);
|
|
|
447 };
|
|
|
448 struct FullSystem {
|
|
|
449 bool doStepFromBackup();
|
|
|
450 vector< FrameHessian * > frameHessians;
|
|
|
451 };
|
|
|
452 bool FullSystem::doStepFromBackup() {
|
|
|
453 Matrix< double, 10, 1 > pstepfac;
|
|
|
454 pstepfac.segment< 4 >().setConstant();
|
|
|
455 for (FrameHessian *fh : frameHessians)
|
|
|
456 fh->setState(pstepfac.cwiseProduct(fh->step));
|
|
|
457 }
|
|
|
458 } // namespace std
|
