
   *
   * \param other element of the group SO2
   * \returns     corresponding tangent space element
   *              (=rotation angle \f$ \theta \f$)
   *
   * Computes the logarithmic, the inverse of the group exponential.
   * To be specific, this function computes \f$ \log({\cdot})^\vee \f$
   * with \f$ \vee(\cdot) \f$ being the matrix logarithm
   * and \f$ \vee{\cdot} \f$ the vee()-operator of SO2.
   *
   * \see exp()
   * \see vee()
   */
  inline static
  const Tangent log(const SO2Group<Scalar> & other) {
    // todo: general implementation for Scalar not being float or double.
    return atan2(other.unit_complex_.y(), other.unit_complex().x());
  }

  /**
   * \brief vee-operator
   *
   * \param Omega 2x2-matrix representation of Lie algebra element
   * \pre         Omega need to be a skew-symmetric matrix
   * \returns     scalar representatin of Lie algebra element
   *s
   * This is the inverse of the hat()-operator.
   *
   * \see hat()
   */
  inline static
  const Tangent vee(const Transformation & Omega) {
    return static_cast<Scalar>(0.5)*(Omega(1,0) - Omega(0,1));
  }

private:
  // Mutator of complex number is private so users are hampered
  // from setting non-unit complex numbers.
  EIGEN_STRONG_INLINE
  ComplexReference unit_complex_nonconst() {
    return static_cast<Derived*>(this)->unit_complex_nonconst();
  }

};

/**
 * \brief SO2 default type - Constructors and default storage for SO2 Type
 */
template<typename _Scalar, int _Options>
class SO2Group : public SO2GroupBase<SO2Group<_Scalar,_Options> > {
  typedef SO2GroupBase<SO2Group<_Scalar,_Options> > Base;
public:
  /** \brief scalar type */
  typedef typename internal::traits<SO2Group<_Scalar,_Options> >
  ::Scalar Scalar;
  /** \brief complex number reference type */
  typedef typename internal::traits<SO2Group<_Scalar,_Options> >
  ::ComplexType & ComplexReference;
  /** \brief complex number const reference type */
  typedef const typename internal::traits<SO2Group<_Scalar,_Options> >
  ::ComplexType & ConstComplexRefere