casadi 3.6.4__cp310-none-macosx_11_0_arm64.whl → 3.6.6__cp310-none-macosx_11_0_arm64.whl

casadi/include/include/eigen3/Eigen/src/Geometry/Rotation2D.h

@@ -1,199 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_ROTATION2D_H
-#define EIGEN_ROTATION2D_H
-
-namespace Eigen { 
-
-/** \geometry_module \ingroup Geometry_Module
-  *
-  * \class Rotation2D
-  *
-  * \brief Represents a rotation/orientation in a 2 dimensional space.
-  *
-  * \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
-  * conversion from/to a 2x2 rotation matrix. Moreover this class aims to provide a similar
-  * interface to Quaternion in order to facilitate the writing of generic algorithms
-  * dealing with rotations.
-  *
-  * \sa class Quaternion, class Transform
-  */
-
-namespace internal {
-
-template<typename _Scalar> struct traits<Rotation2D<_Scalar> >
-{
-  typedef _Scalar Scalar;
-};
-} // end namespace internal
-
-template<typename _Scalar>
-class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2>
-{
-  typedef RotationBase<Rotation2D<_Scalar>,2> Base;
-
-public:
-
-  using Base::operator*;
-
-  enum { Dim = 2 };
-  /** the scalar type of the coefficients */
-  typedef _Scalar Scalar;
-  typedef Matrix<Scalar,2,1> Vector2;
-  typedef Matrix<Scalar,2,2> Matrix2;
-
-protected:
-
-  Scalar m_angle;
-
-public:
-
-  /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */
-  EIGEN_DEVICE_FUNC explicit inline Rotation2D(const Scalar& a) : m_angle(a) {}
-  
-  /** Default constructor wihtout initialization. The represented rotation is undefined. */
-  EIGEN_DEVICE_FUNC Rotation2D() {}
-
-  /** Construct a 2D rotation from a 2x2 rotation matrix \a mat.
-    *
-    * \sa fromRotationMatrix()
-    */
-  template<typename Derived>
-  EIGEN_DEVICE_FUNC explicit Rotation2D(const MatrixBase<Derived>& m)
-  {
-    fromRotationMatrix(m.derived());
-  }
-
-  /** \returns the rotation angle */
-  EIGEN_DEVICE_FUNC inline Scalar angle() const { return m_angle; }
-
-  /** \returns a read-write reference to the rotation angle */
-  EIGEN_DEVICE_FUNC inline Scalar& angle() { return m_angle; }
-  
-  /** \returns the rotation angle in [0,2pi] */
-  EIGEN_DEVICE_FUNC inline Scalar smallestPositiveAngle() const {
-    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
-    return tmp<Scalar(0) ? tmp + Scalar(2*EIGEN_PI) : tmp;
-  }
-  
-  /** \returns the rotation angle in [-pi,pi] */
-  EIGEN_DEVICE_FUNC inline Scalar smallestAngle() const {
-    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
-    if(tmp>Scalar(EIGEN_PI))       tmp -= Scalar(2*EIGEN_PI);
-    else if(tmp<-Scalar(EIGEN_PI)) tmp += Scalar(2*EIGEN_PI);
-    return tmp;
-  }
-
-  /** \returns the inverse rotation */
-  EIGEN_DEVICE_FUNC inline Rotation2D inverse() const { return Rotation2D(-m_angle); }
-
-  /** Concatenates two rotations */
-  EIGEN_DEVICE_FUNC inline Rotation2D operator*(const Rotation2D& other) const
-  { return Rotation2D(m_angle + other.m_angle); }
-
-  /** Concatenates two rotations */
-  EIGEN_DEVICE_FUNC inline Rotation2D& operator*=(const Rotation2D& other)
-  { m_angle += other.m_angle; return *this; }
-
-  /** Applies the rotation to a 2D vector */
-  EIGEN_DEVICE_FUNC Vector2 operator* (const Vector2& vec) const
-  { return toRotationMatrix() * vec; }
-  
-  template<typename Derived>
-  EIGEN_DEVICE_FUNC Rotation2D& fromRotationMatrix(const MatrixBase<Derived>& m);
-  EIGEN_DEVICE_FUNC Matrix2 toRotationMatrix() const;
-
-  /** Set \c *this from a 2x2 rotation matrix \a mat.
-    * In other words, this function extract the rotation angle from the rotation matrix.
-    *
-    * This method is an alias for fromRotationMatrix()
-    *
-    * \sa fromRotationMatrix()
-    */
-  template<typename Derived>
-  EIGEN_DEVICE_FUNC Rotation2D& operator=(const  MatrixBase<Derived>& m)
-  { return fromRotationMatrix(m.derived()); }
-
-  /** \returns the spherical interpolation between \c *this and \a other using
-    * parameter \a t. It is in fact equivalent to a linear interpolation.
-    */
-  EIGEN_DEVICE_FUNC inline Rotation2D slerp(const Scalar& t, const Rotation2D& other) const
-  {
-    Scalar dist = Rotation2D(other.m_angle-m_angle).smallestAngle();
-    return Rotation2D(m_angle + dist*t);
-  }
-
-  /** \returns \c *this with scalar type casted to \a NewScalarType
-    *
-    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
-    * then this function smartly returns a const reference to \c *this.
-    */
-  template<typename NewScalarType>
-  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const
-  { return typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); }
-
-  /** Copy constructor with scalar type conversion */
-  template<typename OtherScalarType>
-  EIGEN_DEVICE_FUNC inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
-  {
-    m_angle = Scalar(other.angle());
-  }
-
-  EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2D(0); }
-
-  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
-    * determined by \a prec.
-    *
-    * \sa MatrixBase::isApprox() */
-  EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
-  { return internal::isApprox(m_angle,other.m_angle, prec); }
-  
-};
-
-/** \ingroup Geometry_Module
-  * single precision 2D rotation type */
-typedef Rotation2D<float> Rotation2Df;
-/** \ingroup Geometry_Module
-  * double precision 2D rotation type */
-typedef Rotation2D<double> Rotation2Dd;
-
-/** Set \c *this from a 2x2 rotation matrix \a mat.
-  * In other words, this function extract the rotation angle
-  * from the rotation matrix.
-  */
-template<typename Scalar>
-template<typename Derived>
-EIGEN_DEVICE_FUNC Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
-{
-  EIGEN_USING_STD(atan2)
-  EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
-  m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0));
-  return *this;
-}
-
-/** Constructs and \returns an equivalent 2x2 rotation matrix.
-  */
-template<typename Scalar>
-typename Rotation2D<Scalar>::Matrix2
-EIGEN_DEVICE_FUNC Rotation2D<Scalar>::toRotationMatrix(void) const
-{
-  EIGEN_USING_STD(sin)
-  EIGEN_USING_STD(cos)
-  Scalar sinA = sin(m_angle);
-  Scalar cosA = cos(m_angle);
-  return (Matrix2() << cosA, -sinA, sinA, cosA).finished();
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_ROTATION2D_H

casadi/include/include/eigen3/Eigen/src/Geometry/RotationBase.h

@@ -1,206 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_ROTATIONBASE_H
-#define EIGEN_ROTATIONBASE_H
-
-namespace Eigen { 
-
-// forward declaration
-namespace internal {
-template<typename RotationDerived, typename MatrixType, bool IsVector=MatrixType::IsVectorAtCompileTime>
-struct rotation_base_generic_product_selector;
-}
-
-/** \class RotationBase
-  *
-  * \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
-  */
-template<typename Derived, int _Dim>
-class RotationBase
-{
-  public:
-    enum { Dim = _Dim };
-    /** the scalar type of the coefficients */
-    typedef typename internal::traits<Derived>::Scalar Scalar;
-
-    /** corresponding linear transformation matrix type */
-    typedef Matrix<Scalar,Dim,Dim> RotationMatrixType;
-    typedef Matrix<Scalar,Dim,1> VectorType;
-
-  public:
-    EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
-    EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
-
-    /** \returns an equivalent rotation matrix */
-    EIGEN_DEVICE_FUNC inline RotationMatrixType toRotationMatrix() const { return derived().toRotationMatrix(); }
-
-    /** \returns an equivalent rotation matrix 
-      * This function is added to be conform with the Transform class' naming scheme.
-      */
-    EIGEN_DEVICE_FUNC inline RotationMatrixType matrix() const { return derived().toRotationMatrix(); }
-
-    /** \returns the inverse rotation */
-    EIGEN_DEVICE_FUNC inline Derived inverse() const { return derived().inverse(); }
-
-    /** \returns the concatenation of the rotation \c *this with a translation \a t */
-    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Isometry> operator*(const Translation<Scalar,Dim>& t) const
-    { return Transform<Scalar,Dim,Isometry>(*this) * t; }
-
-    /** \returns the concatenation of the rotation \c *this with a uniform scaling \a s */
-    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const UniformScaling<Scalar>& s) const
-    { return toRotationMatrix() * s.factor(); }
-
-    /** \returns the concatenation of the rotation \c *this with a generic expression \a e
-      * \a e can be:
-      *  - a DimxDim linear transformation matrix
-      *  - a DimxDim diagonal matrix (axis aligned scaling)
-      *  - a vector of size Dim
-      */
-    template<typename OtherDerived>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::rotation_base_generic_product_selector<Derived,OtherDerived,OtherDerived::IsVectorAtCompileTime>::ReturnType
-    operator*(const EigenBase<OtherDerived>& e) const
-    { return internal::rotation_base_generic_product_selector<Derived,OtherDerived>::run(derived(), e.derived()); }
-
-    /** \returns the concatenation of a linear transformation \a l with the rotation \a r */
-    template<typename OtherDerived> friend
-    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const EigenBase<OtherDerived>& l, const Derived& r)
-    { return l.derived() * r.toRotationMatrix(); }
-
-    /** \returns the concatenation of a scaling \a l with the rotation \a r */
-    EIGEN_DEVICE_FUNC friend inline Transform<Scalar,Dim,Affine> operator*(const DiagonalMatrix<Scalar,Dim>& l, const Derived& r)
-    { 
-      Transform<Scalar,Dim,Affine> res(r);
-      res.linear().applyOnTheLeft(l);
-      return res;
-    }
-
-    /** \returns the concatenation of the rotation \c *this with a transformation \a t */
-    template<int Mode, int Options>
-    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator*(const Transform<Scalar,Dim,Mode,Options>& t) const
-    { return toRotationMatrix() * t; }
-
-    template<typename OtherVectorType>
-    EIGEN_DEVICE_FUNC inline VectorType _transformVector(const OtherVectorType& v) const
-    { return toRotationMatrix() * v; }
-};
-
-namespace internal {
-
-// implementation of the generic product rotation * matrix
-template<typename RotationDerived, typename MatrixType>
-struct rotation_base_generic_product_selector<RotationDerived,MatrixType,false>
-{
-  enum { Dim = RotationDerived::Dim };
-  typedef Matrix<typename RotationDerived::Scalar,Dim,Dim> ReturnType;
-  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const MatrixType& m)
-  { return r.toRotationMatrix() * m; }
-};
-
-template<typename RotationDerived, typename Scalar, int Dim, int MaxDim>
-struct rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix<Scalar,Dim,MaxDim>, false >
-{
-  typedef Transform<Scalar,Dim,Affine> ReturnType;
-  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const DiagonalMatrix<Scalar,Dim,MaxDim>& m)
-  {
-    ReturnType res(r);
-    res.linear() *= m;
-    return res;
-  }
-};
-
-template<typename RotationDerived,typename OtherVectorType>
-struct rotation_base_generic_product_selector<RotationDerived,OtherVectorType,true>
-{
-  enum { Dim = RotationDerived::Dim };
-  typedef Matrix<typename RotationDerived::Scalar,Dim,1> ReturnType;
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE ReturnType run(const RotationDerived& r, const OtherVectorType& v)
-  {
-    return r._transformVector(v);
-  }
-};
-
-} // end namespace internal
-
-/** \geometry_module
-  *
-  * \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 OtherDerived>
-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))
-  *this = r.toRotationMatrix();
-}
-
-/** \geometry_module
-  *
-  * \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 OtherDerived>
-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))
-  return *this = r.toRotationMatrix();
-}
-
-namespace internal {
-
-/** \internal
-  *
-  * Helper function to return an arbitrary rotation object to a rotation matrix.
-  *
-  * \tparam Scalar the numeric type of the matrix coefficients
-  * \tparam Dim the dimension of the current space
-  *
-  * It returns a Dim x Dim fixed size matrix.
-  *
-  * Default specializations are provided for:
-  *   - any scalar type (2D),
-  *   - any matrix expression,
-  *   - any type based on RotationBase (e.g., Quaternion, AngleAxis, Rotation2D)
-  *
-  * Currently toRotationMatrix is only used by Transform.
-  *
-  * \sa class Transform, class Rotation2D, class Quaternion, class AngleAxis
-  */
-template<typename Scalar, int Dim>
-EIGEN_DEVICE_FUNC static inline Matrix<Scalar,2,2> toRotationMatrix(const Scalar& s)
-{
-  EIGEN_STATIC_ASSERT(Dim==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
-  return Rotation2D<Scalar>(s).toRotationMatrix();
-}
-
-template<typename Scalar, int Dim, typename OtherDerived>
-EIGEN_DEVICE_FUNC static inline Matrix<Scalar,Dim,Dim> toRotationMatrix(const RotationBase<OtherDerived,Dim>& r)
-{
-  return r.toRotationMatrix();
-}
-
-template<typename Scalar, int Dim, typename OtherDerived>
-EIGEN_DEVICE_FUNC static inline const MatrixBase<OtherDerived>& toRotationMatrix(const MatrixBase<OtherDerived>& mat)
-{
-  EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime==Dim && OtherDerived::ColsAtCompileTime==Dim,
-    YOU_MADE_A_PROGRAMMING_MISTAKE)
-  return mat;
-}
-
-} // end namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_ROTATIONBASE_H

casadi/include/include/eigen3/Eigen/src/Geometry/Scaling.h

@@ -1,188 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SCALING_H
-#define EIGEN_SCALING_H
-
-namespace Eigen { 
-
-/** \geometry_module \ingroup Geometry_Module
-  *
-  * \class UniformScaling
-  *
-  * \brief Represents a generic uniform scaling transformation
-  *
-  * \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
-  * is used. In particular, this class is not aimed to be used to store a scaling transformation,
-  * but rather to make easier the constructions and updates of Transform objects.
-  *
-  * To represent an axis aligned scaling, use the DiagonalMatrix class.
-  *
-  * \sa Scaling(), class DiagonalMatrix, MatrixBase::asDiagonal(), class Translation, class Transform
-  */
-
-namespace internal
-{
-  // This helper helps nvcc+MSVC to properly parse this file.
-  // See bug 1412.
-  template <typename Scalar, int Dim, int Mode>
-  struct uniformscaling_times_affine_returntype
-  {
-    enum
-    {
-      NewMode = int(Mode) == int(Isometry) ? Affine : Mode
-    };
-    typedef Transform <Scalar, Dim, NewMode> type;
-  };
-}
-
-template<typename _Scalar>
-class UniformScaling
-{
-public:
-  /** the scalar type of the coefficients */
-  typedef _Scalar Scalar;
-
-protected:
-
-  Scalar m_factor;
-
-public:
-
-  /** Default constructor without initialization. */
-  UniformScaling() {}
-  /** Constructs and initialize a uniform scaling transformation */
-  explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
-
-  inline const Scalar& factor() const { return m_factor; }
-  inline Scalar& factor() { return m_factor; }
-
-  /** Concatenates two uniform scaling */
-  inline UniformScaling operator* (const UniformScaling& other) const
-  { return UniformScaling(m_factor * other.factor()); }
-
-  /** Concatenates a uniform scaling and a translation */
-  template<int Dim>
-  inline Transform<Scalar,Dim,Affine> operator* (const Translation<Scalar,Dim>& t) const;
-
-  /** Concatenates a uniform scaling and an affine transformation */
-  template<int Dim, int Mode, int Options>
-  inline typename
-	internal::uniformscaling_times_affine_returntype<Scalar,Dim,Mode>::type
-	operator* (const Transform<Scalar, Dim, Mode, Options>& t) const
-  {
-    typename internal::uniformscaling_times_affine_returntype<Scalar,Dim,Mode>::type res = t;
-    res.prescale(factor());
-    return res;
-  }
-
-  /** Concatenates a uniform scaling and a linear transformation matrix */
-  // TODO returns an expression
-  template<typename Derived>
-  inline typename Eigen::internal::plain_matrix_type<Derived>::type operator* (const MatrixBase<Derived>& other) const
-  { return other * m_factor; }
-
-  template<typename Derived,int Dim>
-  inline Matrix<Scalar,Dim,Dim> operator*(const RotationBase<Derived,Dim>& r) const
-  { return r.toRotationMatrix() * m_factor; }
-
-  /** \returns the inverse scaling */
-  inline UniformScaling inverse() const
-  { return UniformScaling(Scalar(1)/m_factor); }
-
-  /** \returns \c *this with scalar type casted to \a NewScalarType
-    *
-    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
-    * then this function smartly returns a const reference to \c *this.
-    */
-  template<typename NewScalarType>
-  inline UniformScaling<NewScalarType> cast() const
-  { return UniformScaling<NewScalarType>(NewScalarType(m_factor)); }
-
-  /** Copy constructor with scalar type conversion */
-  template<typename OtherScalarType>
-  inline explicit UniformScaling(const UniformScaling<OtherScalarType>& other)
-  { m_factor = Scalar(other.factor()); }
-
-  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
-    * determined by \a prec.
-    *
-    * \sa MatrixBase::isApprox() */
-  bool isApprox(const UniformScaling& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
-  { return internal::isApprox(m_factor, other.factor(), prec); }
-
-};
-
-/** \addtogroup Geometry_Module */
-//@{
-
-/** Concatenates a linear transformation matrix and a uniform scaling
-  * \relates UniformScaling
-  */
-// NOTE this operator is defined in MatrixBase and not as a friend function
-// of UniformScaling to fix an internal crash of Intel's ICC
-template<typename Derived,typename Scalar>
-EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,Scalar,product)
-operator*(const MatrixBase<Derived>& matrix, const UniformScaling<Scalar>& s)
-{ return matrix.derived() * s.factor(); }
-
-/** Constructs a uniform scaling from scale factor \a s */
-inline UniformScaling<float> Scaling(float s) { return UniformScaling<float>(s); }
-/** Constructs a uniform scaling from scale factor \a s */
-inline UniformScaling<double> Scaling(double s) { return UniformScaling<double>(s); }
-/** Constructs a uniform scaling from scale factor \a s */
-template<typename RealScalar>
-inline UniformScaling<std::complex<RealScalar> > Scaling(const std::complex<RealScalar>& s)
-{ return UniformScaling<std::complex<RealScalar> >(s); }
-
-/** Constructs a 2D axis aligned scaling */
-template<typename Scalar>
-inline DiagonalMatrix<Scalar,2> Scaling(const Scalar& sx, const Scalar& sy)
-{ return DiagonalMatrix<Scalar,2>(sx, sy); }
-/** Constructs a 3D axis aligned scaling */
-template<typename Scalar>
-inline DiagonalMatrix<Scalar,3> Scaling(const Scalar& sx, const Scalar& sy, const Scalar& sz)
-{ return DiagonalMatrix<Scalar,3>(sx, sy, sz); }
-
-/** Constructs an axis aligned scaling expression from vector expression \a coeffs
-  * This is an alias for coeffs.asDiagonal()
-  */
-template<typename Derived>
-inline const DiagonalWrapper<const Derived> Scaling(const MatrixBase<Derived>& coeffs)
-{ return coeffs.asDiagonal(); }
-
-/** \deprecated */
-typedef DiagonalMatrix<float, 2> AlignedScaling2f;
-/** \deprecated */
-typedef DiagonalMatrix<double,2> AlignedScaling2d;
-/** \deprecated */
-typedef DiagonalMatrix<float, 3> AlignedScaling3f;
-/** \deprecated */
-typedef DiagonalMatrix<double,3> AlignedScaling3d;
-//@}
-
-template<typename Scalar>
-template<int Dim>
-inline Transform<Scalar,Dim,Affine>
-UniformScaling<Scalar>::operator* (const Translation<Scalar,Dim>& t) const
-{
-  Transform<Scalar,Dim,Affine> res;
-  res.matrix().setZero();
-  res.linear().diagonal().fill(factor());
-  res.translation() = factor() * t.vector();
-  res(Dim,Dim) = Scalar(1);
-  return res;
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_SCALING_H