[prev in list] [next in list] [prev in thread] [next in thread]
List: kde-commits
Subject: kdesupport/eigen2/Eigen/src/Core
From: Benoît Jacob <jacob.benoit.1 () gmail ! com>
Date: 2008-11-30 21:49:02
Message-ID: 1228081742.940998.30051.nullmailer () svn ! kde ! org
[Download RAW message or body]
SVN commit 891007 by bjacob:
add internal documentation
M +2 -2 Dot.h
M +3 -4 Matrix.h
M +22 -4 util/Constants.h
M +5 -2 util/Macros.h
M +22 -0 util/XprHelper.h
--- trunk/kdesupport/eigen2/Eigen/src/Core/Dot.h #891006:891007
@@ -273,7 +273,7 @@
/** \returns the squared norm of *this, i.e. the dot product of *this with itself.
*
- * \note This is \em not the \em l2 norm.
+ * \note This is \em not the \em l2 norm, but its square.
*
* \deprecated Use squaredNorm() instead. This norm2() function is kept only for compatibility and will \
be removed in Eigen 2.0.
*
@@ -282,7 +282,7 @@
* \sa dot(), norm()
*/
template<typename Derived>
-inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real MatrixBase<Derived>::norm2() const
+EIGEN_DEPRECATED inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real \
MatrixBase<Derived>::norm2() const {
return ei_real(dot(*this));
}
--- trunk/kdesupport/eigen2/Eigen/src/Core/Matrix.h #891006:891007
@@ -44,11 +44,11 @@
*
* \note <b>Fixed-size versus dynamic-size:</b>
* Fixed-size means that the numbers of rows and columns are known are compile-time. In this case, \
Eigen allocates the array
- * of coefficients as a fixed-size array on the stack. This makes sense for very small matrices, \
typically up to 4x4, sometimes up + * of coefficients as a fixed-size array, as a class member. This \
makes sense for very small matrices, typically up to 4x4, sometimes up
* to 16x16. Larger matrices should be declared as dynamic-size even if one happens to know their size \
at compile-time.
*
* Dynamic-size means that the numbers of rows or columns are not necessarily known at compile-time. In \
this case they are runtime variables,
- * and the array of coefficients is allocated dynamically, typically on the heap (See note on heap \
allocation below). + * and the array of coefficients is allocated dynamically, typically on the heap \
(See note on Usage of alloca() below).
*
* Note that dense matrices, be they Fixed-size or Dynamic-size, <em>do not</em> expand dynamically in \
the sense of a std::map.
* If you want this behavior, see the Sparse module.
@@ -60,7 +60,7 @@
* exceed a certain value. This happens when taking dynamic-size blocks inside fixed-size matrices: in \
this case _MaxRows and _MaxCols
* are the dimensions of the original matrix, while _Rows and _Cols are Dynamic.
*
- * \note <b> Heap allocation:</b>
+ * \note <b> Usage of alloca():</b>
* On the Linux platform, for small enough arrays, Eigen will avoid heap allocation and instead will \
use alloca() to perform a dynamic
* allocation on the stack.
*
@@ -85,7 +85,6 @@
* v[1] = 0.2;
* v(0) = 0.1;
* v(1) = 0.2;
-
*
* Eigen::MatrixXi m(10, 10);
* m(0, 1) = 1;
--- trunk/kdesupport/eigen2/Eigen/src/Core/util/Constants.h #891006:891007
@@ -26,7 +26,25 @@
#ifndef EIGEN_CONSTANTS_H
#define EIGEN_CONSTANTS_H
+/** This value means that a quantity is not known at compile-time, and that instead the value is
+ * stored in some runtime variable.
+ *
+ * Explanation for the choice of this value:
+ * - It should be positive and larger than any reasonable compile-time-fixed number of rows or columns.
+ * This means that it should be at least 128 or so.
+ * - It should be smaller than the sqrt of INT_MAX. Indeed, we often multiply a number of rows with a \
number + * of columns in order to compute a number of coefficients. Even if we guard that with an "if" \
checking whether + * the values are Dynamic, we still get a compiler warning "integer overflow". So \
the only way to get around + * it would be a meta-selector. Doing this everywhere would reduce code \
readability and lenghten compilation times. + * Also, disabling compiler warnings for integer \
overflow, sounds like a bad idea. + *
+ * If you wish to port Eigen to a platform where sizeof(int)==2, it is perfectly possible to set \
Dynamic to, say, 250. + */
const int Dynamic = 10000;
+
+/** This value means +Infinity; it is currently used only as the p parameter to \
MatrixBase::lpNorm<int>(). + * The value Infinity there means the L-infinity norm.
+ */
const int Infinity = -1;
/** \defgroup flags flags
@@ -199,9 +217,9 @@
};
enum {
- CompleteUnrolling,
+ NoUnrolling,
InnerUnrolling,
- NoUnrolling
+ CompleteUnrolling
};
enum {
@@ -211,9 +229,9 @@
enum {
IsDense = 0,
+ IsSparse = SparseBit,
NoDirectAccess = 0,
- HasDirectAccess = DirectAccessBit,
- IsSparse = SparseBit
+ HasDirectAccess = DirectAccessBit
};
const int FullyCoherentAccessPattern = 0x1;
--- trunk/kdesupport/eigen2/Eigen/src/Core/util/Macros.h #891006:891007
@@ -28,7 +28,10 @@
#undef minor
-/** \internal Defines the maximal loop size to enable meta unrolling of loops */
+/** \internal Defines the maximal loop size to enable meta unrolling of loops.
+ * Note that the value here is expressed in Eigen's own notion of "number of FLOPS",
+ * it does not correspond to the number of iterations or the number of instructions
+ */
#ifndef EIGEN_UNROLLING_LIMIT
#define EIGEN_UNROLLING_LIMIT 100
#endif
@@ -36,7 +39,7 @@
/** \internal Define the maximal size in Bytes of L2 blocks.
* The current value is set to generate blocks of 256x256 for float */
#ifndef EIGEN_TUNE_FOR_L2_CACHE_SIZE
-#define EIGEN_TUNE_FOR_L2_CACHE_SIZE (1024*256)
+#define EIGEN_TUNE_FOR_L2_CACHE_SIZE (sizeof(float)*256*256)
#endif
#define USING_PART_OF_NAMESPACE_EIGEN \
--- trunk/kdesupport/eigen2/Eigen/src/Core/util/XprHelper.h #891006:891007
@@ -41,6 +41,10 @@
ei_no_assignment_operator& operator=(const ei_no_assignment_operator&);
};
+/** \internal If the template parameter Value is Dynamic, this class is just a wrapper around an int \
variable that + * can be accessed using value() and setValue().
+ * Otherwise, this class is an empty structure and value() just returns the template parameter Value.
+ */
template<int Value> class ei_int_if_dynamic EIGEN_EMPTY_STRUCT
{
public:
@@ -136,6 +140,24 @@
template<typename T> struct ei_must_nest_by_value { enum { ret = false }; };
template<typename T> struct ei_must_nest_by_value<NestByValue<T> > { enum { ret = true }; };
+/** \internal Determines how a given expression should be nested into another one.
+ * For example, when you do a * (b+c), Eigen will determine how the expression b+c should be
+ * nested into the bigger product expression. The choice is between nesting the expression b+c as-is, \
or + * evaluating that expression b+c into a temporary variable d, and nest d so that the resulting \
expression is + * a*d. Evaluating can be beneficial for example if every coefficient access in the \
resulting expression causes + * many coefficient accesses in the nested expressions -- as is the case \
with matrix product for example. + *
+ * \param T the type of the expression being nested
+ * \param n the number of coefficient accesses in the nested expression for each coefficient access in \
the bigger expression. + *
+ * Example. Suppose that a, b, and c are of type Matrix3d. The user forms the expression a*(b+c).
+ * b+c is an expression "sum of matrices", which we will denote by S. In order to determine how to nest \
it, + * the Product expression uses: ei_nested<S, 3>::ret, which turns out to be Matrix3d because the \
internal logic of + * ei_nested determined that in this case it was better to evaluate the expression \
b+c into a temporary. On the other hand, + * since a is of type Matrix3d, the Product expression nests \
it as ei_nested<Matrix3d, 3>::ret, which turns out to be + * const Matrix3d&, because the internal logic \
of ei_nested determined that since a was already a matrix, there was no point + * in copying it into \
another matrix. + */
template<typename T, int n=1, typename EvalType = typename ei_eval<T>::type> struct ei_nested
{
enum {
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic