devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Avoid leading underscore followed by cap in template identifiers

Browse Source
This commit is contained in:
Alexander Karatarakis
2021-08-04 22:41:52 +00:00
committed by Rasmus Munk Larsen
parent 5ad8b9bfe2
commit 4ba872bd75
129 changed files with 1481 additions and 1480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Eigen/src/Geometry/AlignedBox.h
View File

@@ -55,20 +55,20 @@ namespace Eigen {
*
* \brief An axis aligned box
*
* \tparam _Scalar the type of the scalar coefficients
* \tparam Scalar_ the type of the scalar coefficients
* \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
*
* This class represents an axis aligned box as a pair of the minimal and maximal corners.
* \warning The result of most methods is undefined when applied to an empty box. You can check for empty boxes using isEmpty().
* \sa alignedboxtypedefs
*/
template <typename _Scalar, int _AmbientDim>
template <typename Scalar_, int _AmbientDim>
class AlignedBox
{
public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_,_AmbientDim)
enum { AmbientDimAtCompileTime = _AmbientDim };
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef NumTraits<Scalar> ScalarTraits;
typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
typedef typename ScalarTraits::Real RealScalar;

14
Eigen/src/Geometry/AngleAxis.h
View File

@@ -18,7 +18,7 @@ namespace Eigen {
*
* \brief Represents a 3D rotation as a rotation angle around an arbitrary 3D axis
*
* \param _Scalar the scalar type, i.e., the type of the coefficients.
* \param Scalar_ the scalar type, i.e., the type of the coefficients.
*
* \warning When setting up an AngleAxis object, the axis vector \b must \b be \b normalized.
*
@@ -39,16 +39,16 @@ namespace Eigen {
*/
namespace internal {
template<typename _Scalar> struct traits<AngleAxis<_Scalar> >
template<typename Scalar_> struct traits<AngleAxis<Scalar_> >
{
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
};
}
template<typename _Scalar>
class AngleAxis : public RotationBase<AngleAxis<_Scalar>,3>
template<typename Scalar_>
class AngleAxis : public RotationBase<AngleAxis<Scalar_>,3>
{
typedef RotationBase<AngleAxis<_Scalar>,3> Base;
typedef RotationBase<AngleAxis<Scalar_>,3> Base;
public:
@@ -56,7 +56,7 @@ public:
enum { Dim = 3 };
/** the scalar type of the coefficients */
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef Matrix<Scalar,3,3> Matrix3;
typedef Matrix<Scalar,3,1> Vector3;
typedef Quaternion<Scalar> QuaternionType;

6
Eigen/src/Geometry/Homogeneous.h
View File

@@ -57,13 +57,13 @@ template<typename MatrixType,typename Rhs> struct homogeneous_right_product_impl
} // end namespace internal
template<typename MatrixType,int _Direction> class Homogeneous
: public MatrixBase<Homogeneous<MatrixType,_Direction> >, internal::no_assignment_operator
template<typename MatrixType,int Direction_> class Homogeneous
: public MatrixBase<Homogeneous<MatrixType,Direction_> >, internal::no_assignment_operator
{
public:
typedef MatrixType NestedExpression;
enum { Direction = _Direction };
enum { Direction = Direction_ };
typedef MatrixBase<Homogeneous> Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous)

10
Eigen/src/Geometry/Hyperplane.h
View File

@@ -22,7 +22,7 @@ namespace Eigen {
* A hyperplane is an affine subspace of dimension n-1 in a space of dimension n.
* For example, a hyperplane in a plane is a line; a hyperplane in 3-space is a plane.
*
* \tparam _Scalar the scalar type, i.e., the type of the coefficients
* \tparam Scalar_ the scalar type, i.e., the type of the coefficients
* \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
* Notice that the dimension of the hyperplane is _AmbientDim-1.
*
@@ -30,16 +30,16 @@ namespace Eigen {
* \f$ n \cdot x + d = 0 \f$ where \f$ n \f$ is a unit normal vector of the plane (linear part)
* and \f$ d \f$ is the distance (offset) to the origin.
*/
template <typename _Scalar, int _AmbientDim, int _Options>
template <typename Scalar_, int _AmbientDim, int Options_>
class Hyperplane
{
public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
enum {
AmbientDimAtCompileTime = _AmbientDim,
Options = _Options
Options = Options_
};
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef typename NumTraits<Scalar>::Real RealScalar;
typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
typedef Matrix<Scalar,AmbientDimAtCompileTime,1> VectorType;

42
Eigen/src/Geometry/ParametrizedLine.h
View File

@@ -23,19 +23,19 @@ namespace Eigen {
* direction vector \f$ \mathbf{d} \f$ such that the line corresponds to
* the set \f$ l(t) = \mathbf{o} + t \mathbf{d} \f$, \f$ t \in \mathbf{R} \f$.
*
* \tparam _Scalar the scalar type, i.e., the type of the coefficients
* \tparam Scalar_ the scalar type, i.e., the type of the coefficients
* \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
*/
template <typename _Scalar, int _AmbientDim, int _Options>
template <typename Scalar_, int _AmbientDim, int Options_>
class ParametrizedLine
{
public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_,_AmbientDim)
enum {
AmbientDimAtCompileTime = _AmbientDim,
Options = _Options
Options = Options_
};
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef typename NumTraits<Scalar>::Real RealScalar;
typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
typedef Matrix<Scalar,AmbientDimAtCompileTime,1,Options> VectorType;
@@ -59,7 +59,7 @@ public:
: m_origin(origin), m_direction(direction) {}
template <int OtherOptions>
EIGEN_DEVICE_FUNC explicit ParametrizedLine(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane);
EIGEN_DEVICE_FUNC explicit ParametrizedLine(const Hyperplane<Scalar_, _AmbientDim, OtherOptions>& hyperplane);
/** Constructs a parametrized line going from \a p0 to \a p1. */
EIGEN_DEVICE_FUNC static inline ParametrizedLine Through(const VectorType& p0, const VectorType& p1)
@@ -96,13 +96,13 @@ public:
EIGEN_DEVICE_FUNC VectorType pointAt(const Scalar& t) const;
template <int OtherOptions>
EIGEN_DEVICE_FUNC Scalar intersectionParameter(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
EIGEN_DEVICE_FUNC Scalar intersectionParameter(const Hyperplane<Scalar_, _AmbientDim, OtherOptions>& hyperplane) const;
template <int OtherOptions>
EIGEN_DEVICE_FUNC Scalar intersection(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
EIGEN_DEVICE_FUNC Scalar intersection(const Hyperplane<Scalar_, _AmbientDim, OtherOptions>& hyperplane) const;
template <int OtherOptions>
EIGEN_DEVICE_FUNC VectorType intersectionPoint(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
EIGEN_DEVICE_FUNC VectorType intersectionPoint(const Hyperplane<Scalar_, _AmbientDim, OtherOptions>& hyperplane) const;
/** Applies the transformation matrix \a mat to \c *this and returns a reference to \c *this.
*
@@ -178,9 +178,9 @@ protected:
*
* \warning the ambient space must have dimension 2 such that the hyperplane actually describes a line
*/
template <typename _Scalar, int _AmbientDim, int _Options>
template <typename Scalar_, int _AmbientDim, int Options_>
template <int OtherOptions>
EIGEN_DEVICE_FUNC inline ParametrizedLine<_Scalar, _AmbientDim,_Options>::ParametrizedLine(const Hyperplane<_Scalar, _AmbientDim,OtherOptions>& hyperplane)
EIGEN_DEVICE_FUNC inline ParametrizedLine<Scalar_, _AmbientDim,Options_>::ParametrizedLine(const Hyperplane<Scalar_, _AmbientDim,OtherOptions>& hyperplane)
{
EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
direction() = hyperplane.normal().unitOrthogonal();
@@ -189,18 +189,18 @@ EIGEN_DEVICE_FUNC inline ParametrizedLine<_Scalar, _AmbientDim,_Options>::Parame
/** \returns the point at \a t along this line
*/
template <typename _Scalar, int _AmbientDim, int _Options>
EIGEN_DEVICE_FUNC inline typename ParametrizedLine<_Scalar, _AmbientDim,_Options>::VectorType
ParametrizedLine<_Scalar, _AmbientDim,_Options>::pointAt(const _Scalar& t) const
template <typename Scalar_, int _AmbientDim, int Options_>
EIGEN_DEVICE_FUNC inline typename ParametrizedLine<Scalar_, _AmbientDim,Options_>::VectorType
ParametrizedLine<Scalar_, _AmbientDim,Options_>::pointAt(const Scalar_& t) const
{
return origin() + (direction()*t);
}
/** \returns the parameter value of the intersection between \c *this and the given \a hyperplane
*/
template <typename _Scalar, int _AmbientDim, int _Options>
template <typename Scalar_, int _AmbientDim, int Options_>
template <int OtherOptions>
EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersectionParameter(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
EIGEN_DEVICE_FUNC inline Scalar_ ParametrizedLine<Scalar_, _AmbientDim,Options_>::intersectionParameter(const Hyperplane<Scalar_, _AmbientDim, OtherOptions>& hyperplane) const
{
return -(hyperplane.offset()+hyperplane.normal().dot(origin()))
/ hyperplane.normal().dot(direction());
@@ -210,19 +210,19 @@ EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>
/** \deprecated use intersectionParameter()
* \returns the parameter value of the intersection between \c *this and the given \a hyperplane
*/
template <typename _Scalar, int _AmbientDim, int _Options>
template <typename Scalar_, int _AmbientDim, int Options_>
template <int OtherOptions>
EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersection(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
EIGEN_DEVICE_FUNC inline Scalar_ ParametrizedLine<Scalar_, _AmbientDim,Options_>::intersection(const Hyperplane<Scalar_, _AmbientDim, OtherOptions>& hyperplane) const
{
return intersectionParameter(hyperplane);
}
/** \returns the point of the intersection between \c *this and the given hyperplane
*/
template <typename _Scalar, int _AmbientDim, int _Options>
template <typename Scalar_, int _AmbientDim, int Options_>
template <int OtherOptions>
EIGEN_DEVICE_FUNC inline typename ParametrizedLine<_Scalar, _AmbientDim,_Options>::VectorType
ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersectionPoint(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
EIGEN_DEVICE_FUNC inline typename ParametrizedLine<Scalar_, _AmbientDim,Options_>::VectorType
ParametrizedLine<Scalar_, _AmbientDim,Options_>::intersectionPoint(const Hyperplane<Scalar_, _AmbientDim, OtherOptions>& hyperplane) const
{
return pointAt(intersectionParameter(hyperplane));
}

70
Eigen/src/Geometry/Quaternion.h
View File

@@ -236,8 +236,8 @@ protected:
*
* \brief The quaternion class used to represent 3D orientations and rotations
*
* \tparam _Scalar the scalar type, i.e., the type of the coefficients
* \tparam _Options controls the memory alignment of the coefficients. Can be \# AutoAlign or \# DontAlign. Default is AutoAlign.
* \tparam Scalar_ the scalar type, i.e., the type of the coefficients
* \tparam Options_ controls the memory alignment of the coefficients. Can be \# AutoAlign or \# DontAlign. Default is AutoAlign.
*
* This class represents a quaternion \f$ w+xi+yj+zk \f$ that is a convenient representation of
* orientations and rotations of objects in three dimensions. Compared to other representations
@@ -256,12 +256,12 @@ protected:
*/
namespace internal {
template<typename _Scalar,int _Options>
struct traits<Quaternion<_Scalar,_Options> >
template<typename Scalar_,int Options_>
struct traits<Quaternion<Scalar_,Options_> >
{
typedef Quaternion<_Scalar,_Options> PlainObject;
typedef _Scalar Scalar;
typedef Matrix<_Scalar,4,1,_Options> Coefficients;
typedef Quaternion<Scalar_,Options_> PlainObject;
typedef Scalar_ Scalar;
typedef Matrix<Scalar_,4,1,Options_> Coefficients;
enum{
Alignment = internal::traits<Coefficients>::Alignment,
Flags = LvalueBit
@@ -269,14 +269,14 @@ struct traits<Quaternion<_Scalar,_Options> >
};
}
template<typename _Scalar, int _Options>
class Quaternion : public QuaternionBase<Quaternion<_Scalar,_Options> >
template<typename Scalar_, int Options_>
class Quaternion : public QuaternionBase<Quaternion<Scalar_,Options_> >
{
public:
typedef QuaternionBase<Quaternion<_Scalar,_Options> > Base;
typedef QuaternionBase<Quaternion<Scalar_,Options_> > Base;
enum { NeedsAlignment = internal::traits<Quaternion>::Alignment>0 };
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Quaternion)
using Base::operator*=;
@@ -352,7 +352,7 @@ protected:
#ifndef EIGEN_PARSED_BY_DOXYGEN
static EIGEN_STRONG_INLINE void _check_template_params()
{
EIGEN_STATIC_ASSERT( (_Options & DontAlign) == _Options,
EIGEN_STATIC_ASSERT( (Options_ & DontAlign) == Options_,
INVALID_MATRIX_TEMPLATE_PARAMETERS)
}
#endif
@@ -370,19 +370,19 @@ typedef Quaternion<double> Quaterniond;
***************************************************************************/
namespace internal {
template<typename _Scalar, int _Options>
struct traits<Map<Quaternion<_Scalar>, _Options> > : traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> >
template<typename Scalar_, int Options_>
struct traits<Map<Quaternion<Scalar_>, Options_> > : traits<Quaternion<Scalar_, (int(Options_)&Aligned)==Aligned ? AutoAlign : DontAlign> >
{
typedef Map<Matrix<_Scalar,4,1>, _Options> Coefficients;
typedef Map<Matrix<Scalar_,4,1>, Options_> Coefficients;
};
}
namespace internal {
template<typename _Scalar, int _Options>
struct traits<Map<const Quaternion<_Scalar>, _Options> > : traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> >
template<typename Scalar_, int Options_>
struct traits<Map<const Quaternion<Scalar_>, Options_> > : traits<Quaternion<Scalar_, (int(Options_)&Aligned)==Aligned ? AutoAlign : DontAlign> >
{
typedef Map<const Matrix<_Scalar,4,1>, _Options> Coefficients;
typedef traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> > TraitsBase;
typedef Map<const Matrix<Scalar_,4,1>, Options_> Coefficients;
typedef traits<Quaternion<Scalar_, (int(Options_)&Aligned)==Aligned ? AutoAlign : DontAlign> > TraitsBase;
enum {
Flags = TraitsBase::Flags & ~LvalueBit
};
@@ -392,22 +392,22 @@ namespace internal {
/** \ingroup Geometry_Module
* \brief Quaternion expression mapping a constant memory buffer
*
* \tparam _Scalar the type of the Quaternion coefficients
* \tparam _Options see class Map
* \tparam Scalar_ the type of the Quaternion coefficients
* \tparam Options_ see class Map
*
* This is a specialization of class Map for Quaternion. This class allows to view
* a 4 scalar memory buffer as an Eigen's Quaternion object.
*
* \sa class Map, class Quaternion, class QuaternionBase
*/
template<typename _Scalar, int _Options>
class Map<const Quaternion<_Scalar>, _Options >
: public QuaternionBase<Map<const Quaternion<_Scalar>, _Options> >
template<typename Scalar_, int Options_>
class Map<const Quaternion<Scalar_>, Options_ >
: public QuaternionBase<Map<const Quaternion<Scalar_>, Options_> >
{
public:
typedef QuaternionBase<Map<const Quaternion<_Scalar>, _Options> > Base;
typedef QuaternionBase<Map<const Quaternion<Scalar_>, Options_> > Base;
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef typename internal::traits<Map>::Coefficients Coefficients;
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
using Base::operator*=;
@@ -417,7 +417,7 @@ class Map<const Quaternion<_Scalar>, _Options >
* The pointer \a coeffs must reference the four coefficients of Quaternion in the following order:
* \code *coeffs == {x, y, z, w} \endcode
*
* If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */
* If the template parameter Options_ is set to #Aligned, then the pointer coeffs must be aligned. */
EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {}
EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs;}
@@ -429,22 +429,22 @@ class Map<const Quaternion<_Scalar>, _Options >
/** \ingroup Geometry_Module
* \brief Expression of a quaternion from a memory buffer
*
* \tparam _Scalar the type of the Quaternion coefficients
* \tparam _Options see class Map
* \tparam Scalar_ the type of the Quaternion coefficients
* \tparam Options_ see class Map
*
* This is a specialization of class Map for Quaternion. This class allows to view
* a 4 scalar memory buffer as an Eigen's Quaternion object.
*
* \sa class Map, class Quaternion, class QuaternionBase
*/
template<typename _Scalar, int _Options>
class Map<Quaternion<_Scalar>, _Options >
: public QuaternionBase<Map<Quaternion<_Scalar>, _Options> >
template<typename Scalar_, int Options_>
class Map<Quaternion<Scalar_>, Options_ >
: public QuaternionBase<Map<Quaternion<Scalar_>, Options_> >
{
public:
typedef QuaternionBase<Map<Quaternion<_Scalar>, _Options> > Base;
typedef QuaternionBase<Map<Quaternion<Scalar_>, Options_> > Base;
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef typename internal::traits<Map>::Coefficients Coefficients;
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
using Base::operator*=;
@@ -454,7 +454,7 @@ class Map<Quaternion<_Scalar>, _Options >
* The pointer \a coeffs must reference the four coefficients of Quaternion in the following order:
* \code *coeffs == {x, y, z, w} \endcode
*
* If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */
* If the template parameter Options_ is set to #Aligned, then the pointer coeffs must be aligned. */
EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {}
EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }

14
Eigen/src/Geometry/Rotation2D.h
View File

@@ -18,7 +18,7 @@ namespace Eigen {
*
* \brief Represents a rotation/orientation in a 2 dimensional space.
*
* \tparam _Scalar the scalar type, i.e., the type of the coefficients
* \tparam Scalar_ the scalar type, i.e., the type of the coefficients
*
* This class is equivalent to a single scalar representing a counter clock wise rotation
* as a single angle in radian. It provides some additional features such as the automatic
@@ -31,16 +31,16 @@ namespace Eigen {
namespace internal {
template<typename _Scalar> struct traits<Rotation2D<_Scalar> >
template<typename Scalar_> struct traits<Rotation2D<Scalar_> >
{
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
};
} // end namespace internal
template<typename _Scalar>
class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2>
template<typename Scalar_>
class Rotation2D : public RotationBase<Rotation2D<Scalar_>,2>
{
typedef RotationBase<Rotation2D<_Scalar>,2> Base;
typedef RotationBase<Rotation2D<Scalar_>,2> Base;
public:
@@ -48,7 +48,7 @@ public:
enum { Dim = 2 };
/** the scalar type of the coefficients */
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef Matrix<Scalar,2,1> Vector2;
typedef Matrix<Scalar,2,2> Matrix2;

16
Eigen/src/Geometry/RotationBase.h
View File

@@ -23,13 +23,13 @@ struct rotation_base_generic_product_selector;
* \brief Common base class for compact rotation representations
*
* \tparam Derived is the derived type, i.e., a rotation type
* \tparam _Dim the dimension of the space
* \tparam Dim_ the dimension of the space
*/
template<typename Derived, int _Dim>
template<typename Derived, int Dim_>
class RotationBase
{
public:
enum { Dim = _Dim };
enum { Dim = Dim_ };
/** the scalar type of the coefficients */
typedef typename internal::traits<Derived>::Scalar Scalar;
@@ -135,9 +135,9 @@ struct rotation_base_generic_product_selector<RotationDerived,OtherVectorType,tr
*
* \brief Constructs a Dim x Dim rotation matrix from the rotation \a r
*/
template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
template<typename Scalar_, int Rows_, int Cols_, int _Storage, int MaxRows_, int MaxCols_>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
EIGEN_DEVICE_FUNC Matrix<Scalar_, Rows_, Cols_, _Storage, MaxRows_, MaxCols_>
::Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
{
EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
@@ -148,10 +148,10 @@ EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
*
* \brief Set a Dim x Dim rotation matrix from the rotation \a r
*/
template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
template<typename Scalar_, int Rows_, int Cols_, int _Storage, int MaxRows_, int MaxCols_>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>&
Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
EIGEN_DEVICE_FUNC Matrix<Scalar_, Rows_, Cols_, _Storage, MaxRows_, MaxCols_>&
Matrix<Scalar_, Rows_, Cols_, _Storage, MaxRows_, MaxCols_>
::operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
{
EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))

6
Eigen/src/Geometry/Scaling.h
View File

@@ -18,7 +18,7 @@ namespace Eigen {
*
* \brief Represents a generic uniform scaling transformation
*
* \tparam _Scalar the scalar type, i.e., the type of the coefficients.
* \tparam Scalar_ the scalar type, i.e., the type of the coefficients.
*
* This class represent a uniform scaling transformation. It is the return
* type of Scaling(Scalar), and most of the time this is the only way it
@@ -45,12 +45,12 @@ namespace internal
};
}
template<typename _Scalar>
template<typename Scalar_>
class UniformScaling
{
public:
/** the scalar type of the coefficients */
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
protected:

30
Eigen/src/Geometry/Transform.h
View File

@@ -63,15 +63,15 @@ struct transform_construct_from_matrix;
template<typename TransformType> struct transform_take_affine_part;
template<typename _Scalar, int _Dim, int _Mode, int _Options>
struct traits<Transform<_Scalar,_Dim,_Mode,_Options> >
template<typename Scalar_, int Dim_, int _Mode, int Options_>
struct traits<Transform<Scalar_,Dim_,_Mode,Options_> >
{
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef Eigen::Index StorageIndex;
typedef Dense StorageKind;
enum {
Dim1 = _Dim==Dynamic ? _Dim : _Dim + 1,
RowsAtCompileTime = _Mode==Projective ? Dim1 : _Dim,
Dim1 = Dim_==Dynamic ? Dim_ : Dim_ + 1,
RowsAtCompileTime = _Mode==Projective ? Dim1 : Dim_,
ColsAtCompileTime = Dim1,
MaxRowsAtCompileTime = RowsAtCompileTime,
MaxColsAtCompileTime = ColsAtCompileTime,
@@ -89,8 +89,8 @@ template<int Mode> struct transform_make_affine;
*
* \brief Represents an homogeneous transformation in a N dimensional space
*
* \tparam _Scalar the scalar type, i.e., the type of the coefficients
* \tparam _Dim the dimension of the space
* \tparam Scalar_ the scalar type, i.e., the type of the coefficients
* \tparam Dim_ the dimension of the space
* \tparam _Mode the type of the transformation. Can be:
* - #Affine: the transformation is stored as a (Dim+1)^2 matrix,
* where the last row is assumed to be [0 ... 0 1].
@@ -100,7 +100,7 @@ template<int Mode> struct transform_make_affine;
* - #Isometry: same as #Affine with the additional assumption that
* the linear part represents a rotation. This assumption is exploited
* to speed up some functions such as inverse() and rotation().
* \tparam _Options has the same meaning as in class Matrix. It allows to specify DontAlign and/or RowMajor.
* \tparam Options_ has the same meaning as in class Matrix. It allows to specify DontAlign and/or RowMajor.
* These Options are passed directly to the underlying matrix type.
*
* The homography is internally represented and stored by a matrix which
@@ -200,20 +200,20 @@ template<int Mode> struct transform_make_affine;
*
* \sa class Matrix, class Quaternion
*/
template<typename _Scalar, int _Dim, int _Mode, int _Options>
template<typename Scalar_, int Dim_, int _Mode, int Options_>
class Transform
{
public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1))
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_,Dim_==Dynamic ? Dynamic : (Dim_+1)*(Dim_+1))
enum {
Mode = _Mode,
Options = _Options,
Dim = _Dim, ///< space dimension in which the transformation holds
HDim = _Dim+1, ///< size of a respective homogeneous vector
Options = Options_,
Dim = Dim_, ///< space dimension in which the transformation holds
HDim = Dim_+1, ///< size of a respective homogeneous vector
Rows = int(Mode)==(AffineCompact) ? Dim : HDim
};
/** the scalar type of the coefficients */
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
typedef Eigen::Index StorageIndex;
typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
/** type of the matrix used to represent the transformation */
@@ -443,7 +443,7 @@ public:
* \li a general transformation matrix of size Dim+1 x Dim+1.
*/
template<typename OtherDerived> friend
EIGEN_DEVICE_FUNC inline const typename internal::transform_left_product_impl<OtherDerived,Mode,Options,_Dim,_Dim+1>::ResultType
EIGEN_DEVICE_FUNC inline const typename internal::transform_left_product_impl<OtherDerived,Mode,Options,Dim_,Dim_+1>::ResultType
operator * (const EigenBase<OtherDerived> &a, const Transform &b)
{ return internal::transform_left_product_impl<OtherDerived,Mode,Options,Dim,HDim>::run(a.derived(),b); }

12
Eigen/src/Geometry/Translation.h
View File

@@ -18,23 +18,23 @@ namespace Eigen {
*
* \brief Represents a translation transformation
*
* \tparam _Scalar the scalar type, i.e., the type of the coefficients.
* \tparam _Dim the dimension of the space, can be a compile time value or Dynamic
* \tparam Scalar_ the scalar type, i.e., the type of the coefficients.
* \tparam Dim_ the dimension of the space, can be a compile time value or Dynamic
*
* \note This class is not aimed to be used to store a translation transformation,
* but rather to make easier the constructions and updates of Transform objects.
*
* \sa class Scaling, class Transform
*/
template<typename _Scalar, int _Dim>
template<typename Scalar_, int Dim_>
class Translation
{
public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_,Dim_)
/** dimension of the space */
enum { Dim = _Dim };
enum { Dim = Dim_ };
/** the scalar type of the coefficients */
typedef _Scalar Scalar;
typedef Scalar_ Scalar;
/** corresponding vector type */
typedef Matrix<Scalar,Dim,1> VectorType;
/** corresponding linear transformation matrix type */