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

protect calls to min and max with parentheses to make Eigen compatible with default windows.h

Browse Source 
(transplanted from 49b6e9143e
)
This commit is contained in:
Gael Guennebaud
2011-07-21 11:19:36 +02:00
parent d4bd8bddb5
commit 22bff949c8
67 changed files with 238 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Eigen/src/Eigen2Support/Cwise.h
View File

@@ -84,11 +84,11 @@ template<typename ExpressionType> class Cwise
template<typename OtherDerived>
const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op)
min(const MatrixBase<OtherDerived> &other) const;
(min)(const MatrixBase<OtherDerived> &other) const;
template<typename OtherDerived>
const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op)
max(const MatrixBase<OtherDerived> &other) const;
(max)(const MatrixBase<OtherDerived> &other) const;
const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_abs_op) abs() const;
const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_abs2_op) abs2() const;

4
Eigen/src/Eigen2Support/CwiseOperators.h
View File

@@ -100,7 +100,7 @@ inline ExpressionType& Cwise<ExpressionType>::operator/=(const MatrixBase<OtherD
template<typename ExpressionType>
template<typename OtherDerived>
EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op)
Cwise<ExpressionType>::min(const MatrixBase<OtherDerived> &other) const
(Cwise<ExpressionType>::min)(const MatrixBase<OtherDerived> &other) const
{
return EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op)(_expression(), other.derived());
}
@@ -109,7 +109,7 @@ Cwise<ExpressionType>::min(const MatrixBase<OtherDerived> &other) const
template<typename ExpressionType>
template<typename OtherDerived>
EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op)
Cwise<ExpressionType>::max(const MatrixBase<OtherDerived> &other) const
(Cwise<ExpressionType>::max)(const MatrixBase<OtherDerived> &other) const
{
return EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op)(_expression(), other.derived());
}

30
Eigen/src/Eigen2Support/Geometry/AlignedBox.h
View File

@@ -51,14 +51,14 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==
{ if (AmbientDimAtCompileTime!=Dynamic) setNull(); }
/** Constructs a null box with \a _dim the dimension of the ambient space. */
inline explicit AlignedBox(int _dim) : m_min(_dim), m_max(_dim)
inline explicit AlignedBox(int _dim) : m_(min)(_dim), m_(max)(_dim)
{ setNull(); }
/** Constructs a box with extremities \a _min and \a _max. */
inline AlignedBox(const VectorType& _min, const VectorType& _max) : m_min(_min), m_max(_max) {}
inline AlignedBox(const VectorType& _min, const VectorType& _max) : m_(min)(_min), m_(max)(_max) {}
/** Constructs a box containing a single point \a p. */
inline explicit AlignedBox(const VectorType& p) : m_min(p), m_max(p) {}
inline explicit AlignedBox(const VectorType& p) : m_(min)(p), m_(max)(p) {}
~AlignedBox() {}
@@ -71,18 +71,18 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==
/** Makes \c *this a null/empty box. */
inline void setNull()
{
m_min.setConstant( std::numeric_limits<Scalar>::max());
m_max.setConstant(-std::numeric_limits<Scalar>::max());
m_min.setConstant( std::numeric_limits<Scalar>::(max)());
m_max.setConstant(-std::numeric_limits<Scalar>::(max)());
}
/** \returns the minimal corner */
inline const VectorType& min() const { return m_min; }
inline const VectorType& (min)() const { return m_min; }
/** \returns a non const reference to the minimal corner */
inline VectorType& min() { return m_min; }
inline VectorType& (min)() { return m_min; }
/** \returns the maximal corner */
inline const VectorType& max() const { return m_max; }
inline const VectorType& (max)() const { return m_max; }
/** \returns a non const reference to the maximal corner */
inline VectorType& max() { return m_max; }
inline VectorType& (max)() { return m_max; }
/** \returns true if the point \a p is inside the box \c *this. */
inline bool contains(const VectorType& p) const
@@ -90,19 +90,19 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==
/** \returns true if the box \a b is entirely inside the box \c *this. */
inline bool contains(const AlignedBox& b) const
{ return (m_min.cwise()<=b.min()).all() && (b.max().cwise()<=m_max).all(); }
{ return (m_min.cwise()<=b.(min)()).all() && (b.(max)().cwise()<=m_max).all(); }
/** Extends \c *this such that it contains the point \a p and returns a reference to \c *this. */
inline AlignedBox& extend(const VectorType& p)
{ m_min = m_min.cwise().min(p); m_max = m_max.cwise().max(p); return *this; }
{ m_min = m_min.cwise().(min)(p); m_max = m_max.cwise().(max)(p); return *this; }
/** Extends \c *this such that it contains the box \a b and returns a reference to \c *this. */
inline AlignedBox& extend(const AlignedBox& b)
{ m_min = m_min.cwise().min(b.m_min); m_max = m_max.cwise().max(b.m_max); return *this; }
{ m_min = m_min.cwise().(min)(b.m_min); m_max = m_max.cwise().(max)(b.m_max); return *this; }
/** Clamps \c *this by the box \a b and returns a reference to \c *this. */
inline AlignedBox& clamp(const AlignedBox& b)
{ m_min = m_min.cwise().max(b.m_min); m_max = m_max.cwise().min(b.m_max); return *this; }
{ m_min = m_min.cwise().(max)(b.m_min); m_max = m_max.cwise().(min)(b.m_max); return *this; }
/** Translate \c *this by the vector \a t and returns a reference to \c *this. */
inline AlignedBox& translate(const VectorType& t)
@@ -138,8 +138,8 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==
template<typename OtherScalarType>
inline explicit AlignedBox(const AlignedBox<OtherScalarType,AmbientDimAtCompileTime>& other)
{
m_min = other.min().template cast<Scalar>();
m_max = other.max().template cast<Scalar>();
m_min = other.(min)().template cast<Scalar>();
m_max = other.(max)().template cast<Scalar>();
}
/** \returns \c true if \c *this is approximately equal to \a other, within the precision

18
Eigen/src/Eigen2Support/SVD.h
View File

@@ -64,9 +64,9 @@ template<typename MatrixType> class SVD
SVD() {} // a user who relied on compiler-generated default compiler reported problems with MSVC in 2.0.7
SVD(const MatrixType& matrix)
: m_matU(matrix.rows(), std::min(matrix.rows(), matrix.cols())),
: m_matU(matrix.rows(), (std::min)(matrix.rows(), matrix.cols())),
m_matV(matrix.cols(),matrix.cols()),
m_sigma(std::min(matrix.rows(),matrix.cols()))
m_sigma((std::min)(matrix.rows(),matrix.cols()))
{
compute(matrix);
}
@@ -108,13 +108,13 @@ void SVD<MatrixType>::compute(const MatrixType& matrix)
{
const int m = matrix.rows();
const int n = matrix.cols();
const int nu = std::min(m,n);
const int nu = (std::min)(m,n);
ei_assert(m>=n && "In Eigen 2.0, SVD only works for MxN matrices with M>=N. Sorry!");
ei_assert(m>1 && "In Eigen 2.0, SVD doesn't work on 1x1 matrices");
m_matU.resize(m, nu);
m_matU.setZero();
m_sigma.resize(std::min(m,n));
m_sigma.resize((std::min)(m,n));
m_matV.resize(n,n);
RowVector e(n);
@@ -126,9 +126,9 @@ void SVD<MatrixType>::compute(const MatrixType& matrix)
// Reduce A to bidiagonal form, storing the diagonal elements
// in s and the super-diagonal elements in e.
int nct = std::min(m-1,n);
int nrt = std::max(0,std::min(n-2,m));
for (k = 0; k < std::max(nct,nrt); ++k)
int nct = (std::min)(m-1,n);
int nrt = (std::max)(0,(std::min)(n-2,m));
for (k = 0; k < (std::max)(nct,nrt); ++k)
{
if (k < nct)
{
@@ -193,7 +193,7 @@ void SVD<MatrixType>::compute(const MatrixType& matrix)
// Set up the final bidiagonal matrix or order p.
int p = std::min(n,m+1);
int p = (std::min)(n,m+1);
if (nct < n)
m_sigma[nct] = matA(nct,nct);
if (m < p)
@@ -380,7 +380,7 @@ void SVD<MatrixType>::compute(const MatrixType& matrix)
case 3:
{
// Calculate the shift.
Scalar scale = std::max(std::max(std::max(std::max(
Scalar scale = (std::max)((std::max)((std::max)((std::max)(
ei_abs(m_sigma[p-1]),ei_abs(m_sigma[p-2])),ei_abs(e[p-2])),
ei_abs(m_sigma[k])),ei_abs(e[k]));
Scalar sp = m_sigma[p-1]/scale;