Path Tracer
Block.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
6 //
7 // This Source Code Form is subject to the terms of the Mozilla
8 // Public License v. 2.0. If a copy of the MPL was not distributed
9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10 
11 #ifndef EIGEN_BLOCK_H
12 #define EIGEN_BLOCK_H
13 
14 namespace Eigen {
15 
16 namespace internal {
17 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
18 struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel> > : traits<XprType>
19 {
20  typedef typename traits<XprType>::Scalar Scalar;
21  typedef typename traits<XprType>::StorageKind StorageKind;
22  typedef typename traits<XprType>::XprKind XprKind;
23  typedef typename ref_selector<XprType>::type XprTypeNested;
24  typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
25  enum{
26  MatrixRows = traits<XprType>::RowsAtCompileTime,
27  MatrixCols = traits<XprType>::ColsAtCompileTime,
28  RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows,
29  ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols,
30  MaxRowsAtCompileTime = BlockRows==0 ? 0
31  : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime)
32  : int(traits<XprType>::MaxRowsAtCompileTime),
33  MaxColsAtCompileTime = BlockCols==0 ? 0
34  : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime)
35  : int(traits<XprType>::MaxColsAtCompileTime),
36 
37  XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
38  IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
39  : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
40  : XprTypeIsRowMajor,
41  HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
42  InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
43  InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
44  ? int(inner_stride_at_compile_time<XprType>::ret)
45  : int(outer_stride_at_compile_time<XprType>::ret),
46  OuterStrideAtCompileTime = HasSameStorageOrderAsXprType
47  ? int(outer_stride_at_compile_time<XprType>::ret)
48  : int(inner_stride_at_compile_time<XprType>::ret),
49 
50  // FIXME, this traits is rather specialized for dense object and it needs to be cleaned further
51  FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
52  FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
53  Flags = (traits<XprType>::Flags & (DirectAccessBit | (InnerPanel?CompressedAccessBit:0))) | FlagsLvalueBit | FlagsRowMajorBit,
54  // FIXME DirectAccessBit should not be handled by expressions
55  //
56  // Alignment is needed by MapBase's assertions
57  // We can sefely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the respective evaluator
58  Alignment = 0
59  };
60 };
61 
62 template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
63  bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class BlockImpl_dense;
64 
65 } // end namespace internal
66 
67 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, typename StorageKind> class BlockImpl;
68 
103 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class Block
104  : public BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind>
105 {
106  typedef BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> Impl;
107  public:
108  //typedef typename Impl::Base Base;
109  typedef Impl Base;
110  EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
111  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
112 
113  typedef typename internal::remove_all<XprType>::type NestedExpression;
114 
117  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
118  Block(XprType& xpr, Index i) : Impl(xpr,i)
119  {
120  eigen_assert( (i>=0) && (
121  ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows())
122  ||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols())));
123  }
124 
127  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
128  Block(XprType& xpr, Index startRow, Index startCol)
129  : Impl(xpr, startRow, startCol)
130  {
131  EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
132  eigen_assert(startRow >= 0 && BlockRows >= 0 && startRow + BlockRows <= xpr.rows()
133  && startCol >= 0 && BlockCols >= 0 && startCol + BlockCols <= xpr.cols());
134  }
135 
138  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
139  Block(XprType& xpr,
140  Index startRow, Index startCol,
141  Index blockRows, Index blockCols)
142  : Impl(xpr, startRow, startCol, blockRows, blockCols)
143  {
144  eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
145  && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
146  eigen_assert(startRow >= 0 && blockRows >= 0 && startRow <= xpr.rows() - blockRows
147  && startCol >= 0 && blockCols >= 0 && startCol <= xpr.cols() - blockCols);
148  }
149 };
150 
151 // The generic default implementation for dense block simplu forward to the internal::BlockImpl_dense
152 // that must be specialized for direct and non-direct access...
153 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
154 class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
155  : public internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel>
156 {
157  typedef internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel> Impl;
158  typedef typename XprType::StorageIndex StorageIndex;
159  public:
160  typedef Impl Base;
161  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl)
162  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
163  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {}
164  EIGEN_DEVICE_FUNC
165  EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
166  : Impl(xpr, startRow, startCol, blockRows, blockCols) {}
167 };
168 
169 namespace internal {
170 
172 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> class BlockImpl_dense
173  : public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel> >::type
174 {
175  typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
176  typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
177  public:
178 
179  typedef typename internal::dense_xpr_base<BlockType>::type Base;
180  EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
181  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
182 
183  // class InnerIterator; // FIXME apparently never used
184 
185 
187  EIGEN_DEVICE_FUNC
188  inline BlockImpl_dense(XprType& xpr, Index i)
189  : m_xpr(xpr),
190  // It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime,
191  // and it is a column if and only if BlockRows==XprType::RowsAtCompileTime and BlockCols==1,
192  // all other cases are invalid.
193  // The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
194  m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
195  m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
196  m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
197  m_blockCols(BlockCols==1 ? 1 : xpr.cols())
198  {}
199 
202  EIGEN_DEVICE_FUNC
203  inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
204  : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
205  m_blockRows(BlockRows), m_blockCols(BlockCols)
206  {}
207 
210  EIGEN_DEVICE_FUNC
211  inline BlockImpl_dense(XprType& xpr,
212  Index startRow, Index startCol,
213  Index blockRows, Index blockCols)
214  : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
215  m_blockRows(blockRows), m_blockCols(blockCols)
216  {}
217 
218  EIGEN_DEVICE_FUNC inline Index rows() const { return m_blockRows.value(); }
219  EIGEN_DEVICE_FUNC inline Index cols() const { return m_blockCols.value(); }
220 
221  EIGEN_DEVICE_FUNC
222  inline Scalar& coeffRef(Index rowId, Index colId)
223  {
224  EIGEN_STATIC_ASSERT_LVALUE(XprType)
225  return m_xpr.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
226  }
227 
228  EIGEN_DEVICE_FUNC
229  inline const Scalar& coeffRef(Index rowId, Index colId) const
230  {
231  return m_xpr.derived().coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
232  }
233 
234  EIGEN_DEVICE_FUNC
235  EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
236  {
237  return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value());
238  }
239 
240  EIGEN_DEVICE_FUNC
241  inline Scalar& coeffRef(Index index)
242  {
243  EIGEN_STATIC_ASSERT_LVALUE(XprType)
244  return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
245  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
246  }
247 
248  EIGEN_DEVICE_FUNC
249  inline const Scalar& coeffRef(Index index) const
250  {
251  return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
252  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
253  }
254 
255  EIGEN_DEVICE_FUNC
256  inline const CoeffReturnType coeff(Index index) const
257  {
258  return m_xpr.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
259  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
260  }
261 
262  template<int LoadMode>
263  inline PacketScalar packet(Index rowId, Index colId) const
264  {
265  return m_xpr.template packet<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value());
266  }
267 
268  template<int LoadMode>
269  inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
270  {
271  m_xpr.template writePacket<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value(), val);
272  }
273 
274  template<int LoadMode>
275  inline PacketScalar packet(Index index) const
276  {
277  return m_xpr.template packet<Unaligned>
278  (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
279  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
280  }
281 
282  template<int LoadMode>
283  inline void writePacket(Index index, const PacketScalar& val)
284  {
285  m_xpr.template writePacket<Unaligned>
286  (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
287  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), val);
288  }
289 
290  #ifdef EIGEN_PARSED_BY_DOXYGEN
291 
292  EIGEN_DEVICE_FUNC inline const Scalar* data() const;
293  EIGEN_DEVICE_FUNC inline Index innerStride() const;
294  EIGEN_DEVICE_FUNC inline Index outerStride() const;
295  #endif
296 
297  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
298  const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
299  {
300  return m_xpr;
301  }
302 
303  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
304  XprType& nestedExpression() { return m_xpr; }
305 
306  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
307  StorageIndex startRow() const
308  {
309  return m_startRow.value();
310  }
311 
312  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
313  StorageIndex startCol() const
314  {
315  return m_startCol.value();
316  }
317 
318  protected:
319 
320  XprTypeNested m_xpr;
321  const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
322  const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
323  const internal::variable_if_dynamic<StorageIndex, RowsAtCompileTime> m_blockRows;
324  const internal::variable_if_dynamic<StorageIndex, ColsAtCompileTime> m_blockCols;
325 };
326 
328 template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
329 class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
330  : public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel> >
331 {
332  typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
333  typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
334  enum {
335  XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0
336  };
337  public:
338 
339  typedef MapBase<BlockType> Base;
340  EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
341  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
342 
343 
345  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
346  BlockImpl_dense(XprType& xpr, Index i)
347  : Base(xpr.data() + i * ( ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && (!XprTypeIsRowMajor))
348  || ((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && ( XprTypeIsRowMajor)) ? xpr.innerStride() : xpr.outerStride()),
349  BlockRows==1 ? 1 : xpr.rows(),
350  BlockCols==1 ? 1 : xpr.cols()),
351  m_xpr(xpr),
352  m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
353  m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0)
354  {
355  init();
356  }
357 
360  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
361  BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
362  : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol)),
363  m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
364  {
365  init();
366  }
367 
370  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
371  BlockImpl_dense(XprType& xpr,
372  Index startRow, Index startCol,
373  Index blockRows, Index blockCols)
374  : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol), blockRows, blockCols),
375  m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
376  {
377  init();
378  }
379 
380  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
381  const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
382  {
383  return m_xpr;
384  }
385 
386  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
387  XprType& nestedExpression() { return m_xpr; }
388 
390  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
391  Index innerStride() const
392  {
393  return internal::traits<BlockType>::HasSameStorageOrderAsXprType
394  ? m_xpr.innerStride()
395  : m_xpr.outerStride();
396  }
397 
399  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
400  Index outerStride() const
401  {
402  return m_outerStride;
403  }
404 
405  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
406  StorageIndex startRow() const
407  {
408  return m_startRow.value();
409  }
410 
411  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
412  StorageIndex startCol() const
413  {
414  return m_startCol.value();
415  }
416 
417  #ifndef __SUNPRO_CC
418  // FIXME sunstudio is not friendly with the above friend...
419  // META-FIXME there is no 'friend' keyword around here. Is this obsolete?
420  protected:
421  #endif
422 
423  #ifndef EIGEN_PARSED_BY_DOXYGEN
424 
425  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
426  BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
427  : Base(data, blockRows, blockCols), m_xpr(xpr)
428  {
429  init();
430  }
431  #endif
432 
433  protected:
434  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
435  void init()
436  {
437  m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType
438  ? m_xpr.outerStride()
439  : m_xpr.innerStride();
440  }
441 
442  XprTypeNested m_xpr;
443  const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
444  const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
445  Index m_outerStride;
446 };
447 
448 } // end namespace internal
449 
450 } // end namespace Eigen
451 
452 #endif // EIGEN_BLOCK_H
Eigen::internal::BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel, true >::BlockImpl_dense
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl_dense(XprType &xpr, Index i)
Definition: Block.h:346
Eigen
Namespace containing all symbols from the Eigen library.
Definition: LDLT.h:16
Eigen::internal::BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel, true >::BlockImpl_dense
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl_dense(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:371
Eigen::Block
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:105
Eigen::Block::Block
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Block(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:128
Eigen::internal::BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel, true >::BlockImpl_dense
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl_dense(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:361
Eigen::internal::dense_xpr_base
Definition: XprHelper.h:492
Eigen::internal::is_lvalue
Definition: XprHelper.h:668
Eigen::RowMajorBit
const unsigned int RowMajorBit
Definition: Constants.h:65
Eigen::CompressedAccessBit
const unsigned int CompressedAccessBit
Definition: Constants.h:190
Eigen::DirectAccessBit
const unsigned int DirectAccessBit
Definition: Constants.h:154
Eigen::BlockImpl
Definition: Block.h:67
Eigen::internal::true_type
Definition: Meta.h:63
Eigen::internal::BlockImpl_dense::BlockImpl_dense
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, Index i)
Definition: Block.h:188
Eigen::internal::BlockImpl_dense::BlockImpl_dense
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:211
Eigen::LvalueBit
const unsigned int LvalueBit
Definition: Constants.h:143
Eigen::MapBase
Definition: ForwardDeclarations.h:112
Eigen::Dynamic
const int Dynamic
Definition: Constants.h:21
Eigen::internal::BlockImpl_dense::BlockImpl_dense
EIGEN_DEVICE_FUNC BlockImpl_dense(XprType &xpr, Index startRow, Index startCol)
Definition: Block.h:203
Eigen::internal::outer_stride_at_compile_time
Definition: DenseCoeffsBase.h:671
Eigen::internal::BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel, true >::innerStride
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index innerStride() const
Definition: Block.h:391
Eigen::internal::ref_selector
Definition: XprHelper.h:425
Eigen::internal::inner_stride_at_compile_time
Definition: DenseCoeffsBase.h:659
Eigen::internal::traits
Definition: ForwardDeclarations.h:17
Eigen::internal::BlockImpl_dense
Definition: Block.h:174
Eigen::Block::Block
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Block(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: Block.h:139
Eigen::Block::Block
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Block(XprType &xpr, Index i)
Definition: Block.h:118
Eigen::internal::BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel, true >::outerStride
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outerStride() const
Definition: Block.h:400
Eigen::internal::has_direct_access
Definition: ForwardDeclarations.h:26
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:42
Eigen::Dense
Definition: Constants.h:503
Generated by   doxygen 1.8.19