LieAlgebra.h

Go to the documentation of this file.

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009-2013 CEA LIST (DIASI/LSI) <xde-support@saxifrage.cea.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_LGSM_LIE_ALGEBRA_H
#define EIGEN_LGSM_LIE_ALGEBRA_H

/***************************************************************************
* Definition/implementation of LieAlgebraBase<A, Derived>
***************************************************************************/

namespace internal {
  template<class A, class Derived>
    struct traits<LieAlgebraBase<A, Derived> > : public traits<A> {};
}

template<class A, class Derived> class LieAlgebraBase : public MatrixBase<Derived> {
protected:
  typedef MatrixBase<Derived> Base;
public:  
  // inherit MatrixBase interface
  EIGEN_DENSE_PUBLIC_INTERFACE(LieAlgebraBase)
  // inherit operator=
  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(LieAlgebraBase)
  // accessor needed for MatrixBase inheritance
  LIE_INHERIT_MATRIX_BASE(A::RowsAtCompileTime, A::ColsAtCompileTime)

  typedef A BaseType;
  typedef typename internal::traits<Derived>::Coefficients Coefficients;
  typedef LieAlgebra<BaseType> PlainObject;   
  typedef LieAlgebraDual<BaseType> AlgebraDual;
  typedef typename Derived::LieGroup Group;


  template<class OtherDerived> inline PlainObject bracket(const LieAlgebraBase<BaseType, OtherDerived>& a) const;
  template<class OtherDerived> inline const PlainObject adjoint(const LieAlgebraBase<BaseType, OtherDerived>& a) const;
  
  Group exp(Scalar precision = 1.e-6) const;

  inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
  inline Derived& derived() { return *static_cast<Derived*>(this); }

  inline Coefficients& get();
  inline const Coefficients& get() const;
};

/***************************************************************************
* Definition/implementation of LieAlgebraDualBase<A, Derived>
***************************************************************************/

namespace internal {
  template<class A, class Derived>
    struct traits<LieAlgebraDualBase<A, Derived> > : public traits<A> {};
}

template<class A, class Derived> class LieAlgebraDualBase : public MatrixBase<Derived > {
protected:
  typedef MatrixBase<Derived>  Base;
public:
  // inherit MatrixBase interface
  EIGEN_DENSE_PUBLIC_INTERFACE(LieAlgebraDualBase)
  // inherit operator=
  //EIGEN_INHERIT_ASSIGNMENT_OPERATORS(LieAlgebraDualBase)
  // accessor needed for MatrixBase inheritance
  LIE_INHERIT_MATRIX_BASE(A::RowsAtCompileTime, A::ColsAtCompileTime)

  
  EIGEN_STRONG_INLINE LieAlgebraDualBase& operator=(const LieAlgebraDualBase& other) {
    this->get() = other.get();
    return *this;
  }
  template<class BaseType, class OtherDerived> EIGEN_STRONG_INLINE Derived& operator=(const LieAlgebraDualBase<BaseType, OtherDerived>& other) {
    this->get() = other.get();
    return derived();
  }

  typedef A BaseType;
  typedef typename internal::traits<Derived>::Coefficients Coefficients;
  typedef LieAlgebraDual<BaseType> PlainObject;   
  typedef LieAlgebra<BaseType> Algebra;
  typedef typename internal::traits<Derived>::Group Group;

  inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
  inline Derived& derived() { return *static_cast<Derived*>(this); }

  inline Coefficients& get() {return this->derived().get(); }
  inline const Coefficients& get() const {return this->derived().get(); }
};


/***************************************************************************
* Definition of LieAlgebra<A>
***************************************************************************/

namespace internal {
  template<class A>
    struct traits<LieAlgebra<A> > : public traits<LieAlgebraBase<A, LieAlgebra<A> > >
    {
      typedef A Coefficients;
    };
}

template<class A> class LieAlgebra : public LieAlgebraBase<A, LieAlgebra<A> > {
protected:
  typedef LieAlgebraBase<A, LieAlgebra<A> > Base;
public:
  // inherit MatrixBase operator
  EIGEN_DENSE_PUBLIC_INTERFACE(LieAlgebra)
  // inherit assignement operator
  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(LieAlgebra)

  typedef typename internal::traits<LieAlgebra<A> >::Coefficients Coefficients;

  inline LieAlgebra(const LieAlgebra&);

  inline Coefficients& get() { return m_coeffs; }
  inline const Coefficients& get() const { return m_coeffs; }

protected:
  Coefficients m_coeffs;
};

/***************************************************************************
* Definition of LieAlgebraDual<A>
***************************************************************************/

namespace internal {
  template<class A>
    struct traits<LieAlgebraDual<A> > : public traits<LieAlgebraDualBase<A, LieAlgebraDual<A> > >
    {
      typedef A Coefficients;
    };
}

template<class A> class LieAlgebraDual : public LieAlgebraDualBase<A, LieAlgebraDual<A> > {
protected:
  typedef LieAlgebraDualBase<A, LieAlgebraDual<A> > Base;
public:
  // inherit MatrixBase operator
  EIGEN_DENSE_PUBLIC_INTERFACE(LieAlgebraDual)
  // inherit assignement operator
  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(LieAlgebraDual)

  typedef typename internal::traits<LieAlgebraDual<A> >::Coefficients Coefficients;

  inline LieAlgebraDual(const LieAlgebraDual&);

  inline Coefficients& get() { return m_coeffs; }
  inline const Coefficients& get() const { return m_coeffs; }
protected:
  Coefficients m_coeffs;
};


/***************************************************************************
* Definition of Map<LieAlgebra<A> >
***************************************************************************/

namespace internal {
  template<class A, int MapOptions, typename StrideType>
    struct traits<Map<LieAlgebra<A>, MapOptions, StrideType> > : public traits<LieAlgebraBase<A, Map<LieAlgebra<A>, MapOptions, StrideType> > >
    {
      typedef Map<A, MapOptions, StrideType> Coefficients;
    };
}

namespace internal {
  template<class A, int MapOptions, typename StrideType>
    struct traits<Map<const LieAlgebra<A>, MapOptions, StrideType> > : public traits<LieAlgebraBase<A, Map<const LieAlgebra<A>, MapOptions, StrideType> > >
    {
      typedef Map<const A, MapOptions, StrideType> Coefficients;
    };
}

template<class A, int MapOptions, typename StrideType>
class Map<LieAlgebra<A>, MapOptions, StrideType> : public LieAlgebraBase<A, Map<LieAlgebra<A>, MapOptions, StrideType> > {
  protected:
    typedef LieAlgebraBase<A, Map<LieAlgebra<A>, MapOptions, StrideType> > Base;
  public:
    // inherit MatrixBase operator
    EIGEN_DENSE_PUBLIC_INTERFACE(Map)
      // inherit assignement operator
      EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)

      typedef typename internal::traits<Map<LieAlgebra<A>, MapOptions, StrideType> >::Coefficients Coefficients;

    Map(const A& a) : m_coeffs(a.data()) {};
    Map(Scalar* data) : m_coeffs(data) {};
    Map(const Map& m) : m_coeffs(m.get()) {};

    Coefficients& get() { return m_coeffs; }
    const Coefficients& get() const { return m_coeffs; }

  protected:
    Coefficients m_coeffs;
};

template<class A, int MapOptions, typename StrideType>
class Map<const LieAlgebra<A>, MapOptions, StrideType> : public LieAlgebraBase<A, Map<const LieAlgebra<A>, MapOptions, StrideType> > {
  protected:
    typedef LieAlgebraBase<A, Map<const LieAlgebra<A>, MapOptions, StrideType> > Base;
  public:
    // inherit MatrixBase operator
    EIGEN_DENSE_PUBLIC_INTERFACE(Map)

      
      typedef typename internal::traits<Map<const LieAlgebra<A>, MapOptions, StrideType> >::Coefficients Coefficients;

    Map(const A& a) : m_coeffs(a.data()) {};
    Map(const Scalar* data) : m_coeffs(data) {};
    Map(const Map& m) : m_coeffs(m.get()) {};

    Coefficients& get() { return m_coeffs; }
    const Coefficients& get() const { return m_coeffs; }

  protected:
    Coefficients m_coeffs;
};


/***************************************************************************
 * Definition of Map<LieAlgebraDual<A> >
 ***************************************************************************/

namespace internal {
  template<class A, int MapOptions, typename StrideType>
    struct traits<Map<LieAlgebraDual<A>, MapOptions, StrideType> > : public traits<LieAlgebraDualBase<A, Map<LieAlgebraDual<A>, MapOptions, StrideType> > >
    {
      typedef Map<A, MapOptions, StrideType> Coefficients;
    };

  template<class A, int MapOptions, typename StrideType>
    struct traits<Map<const LieAlgebraDual<A>, MapOptions, StrideType> > : public traits<LieAlgebraDualBase<A, Map<const LieAlgebraDual<A>, MapOptions, StrideType> > >
    {
      typedef Map<A, MapOptions, StrideType> Coefficients;
    };

}
template<class A, int MapOptions, typename StrideType>
class Map<LieAlgebraDual<A>, MapOptions, StrideType> : public LieAlgebraDualBase<A, Map<LieAlgebraDual<A>, MapOptions, StrideType> > {
  protected:
    typedef LieAlgebraDualBase<A, Map<LieAlgebraDual<A>, MapOptions, StrideType> > Base;
  public:
    // inherit MatrixBase operator
    EIGEN_DENSE_PUBLIC_INTERFACE(Map)
      // inherit assignement operator
      EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)

      typedef typename internal::traits<Map<LieAlgebraDual<A>, MapOptions, StrideType> >::Coefficients Coefficients;

    Map(const A& a) : m_coeffs(a) {};
    Map(Scalar* data) : m_coeffs(data) {};
    Map(const Map& m) : m_coeffs(m.get()) {};

    Coefficients& get() { return m_coeffs; }
    const Coefficients& get() const { return m_coeffs; }

  protected:
    Coefficients m_coeffs;
};

template<class A, int MapOptions, typename StrideType>
class Map<const LieAlgebraDual<A>, MapOptions, StrideType> : public LieAlgebraDualBase<A, Map<const LieAlgebraDual<A>, MapOptions, StrideType> > {
  protected:
    typedef LieAlgebraDualBase<A, Map<const LieAlgebraDual<A>, MapOptions, StrideType> > Base;
  public:
    // inherit MatrixBase operator
    EIGEN_DENSE_PUBLIC_INTERFACE(Map)

      
      typedef typename internal::traits<Map<const LieAlgebraDual<A>, MapOptions, StrideType> >::Coefficients Coefficients;

    Map(const A& a) : m_coeffs(a) {};
    Map(const Scalar* data) : m_coeffs(data) {};
    Map(const Map& m) : m_coeffs(m.get()) {};

    Coefficients& get() { return m_coeffs; }
    const Coefficients& get() const { return m_coeffs; }

  protected:
    Coefficients m_coeffs;
};

#endif