library: libMathCore
#include "Quaternion.h"

ROOT::Math::Quaternion

class description - header file - source file - inheritance tree (.pdf)

class ROOT::Math::Quaternion

Inheritance Chart:
ROOT::Math::Quaternion
 

    public:

                                                                                                               Quaternion()
                                                                                                               Quaternion(ROOT::Math::Rotation3D const& r)
                                                                                                               Quaternion(ROOT::Math::AxisAngle const& a)
                                                                                                               Quaternion(ROOT::Math::EulerAngles const& e)
                                                                                                               Quaternion(ROOT::Math::RotationZ const& r)
                                                                                                               Quaternion(ROOT::Math::RotationY const& r)
                                                                                                               Quaternion(ROOT::Math::RotationX const& r)
                                                                                                               Quaternion(ROOT::Math::Quaternion::Scalar u, ROOT::Math::Quaternion::Scalar i, ROOT::Math::Quaternion::Scalar j, ROOT::Math::Quaternion::Scalar k)
                                                                                        ROOT::Math::Quaternion Inverse() const
                                                                                        ROOT::Math::Quaternion operator*(const ROOT::Math::Quaternion& q) const
                                                                                        ROOT::Math::Quaternion operator*(const ROOT::Math::Rotation3D& r) const
                                                                                        ROOT::Math::Quaternion operator*(const ROOT::Math::AxisAngle& a) const
                                                                                        ROOT::Math::Quaternion operator*(const ROOT::Math::EulerAngles& e) const
                                                                                        ROOT::Math::Quaternion operator*(const ROOT::Math::RotationX& rx) const
                                                                                        ROOT::Math::Quaternion operator*(const ROOT::Math::RotationY& ry) const
                                                                                        ROOT::Math::Quaternion operator*(const ROOT::Math::RotationZ& rz) const
                                                                                                               Quaternion(double* begin, double* end)
                                                                                                               Quaternion(const ROOT::Math::Quaternion&)
                                                                                                               ~Quaternion()
                                                                                ROOT::Math::Quaternion::Scalar Distance(const ROOT::Math::Quaternion& q) const
                                                                                                          void GetComponents(ROOT::Math::Quaternion::Scalar& u, ROOT::Math::Quaternion::Scalar& i, ROOT::Math::Quaternion::Scalar& j, ROOT::Math::Quaternion::Scalar& k) const
                                                                                                          void GetComponents(double* begin, double* end) const
                                                                                ROOT::Math::Quaternion::Scalar I() const
                                                                                                          void Invert()
                                                                                ROOT::Math::Quaternion::Scalar J() const
                                                                                ROOT::Math::Quaternion::Scalar K() const
                                                                                                          bool operator!=(const ROOT::Math::Quaternion& rhs)
                                                                             ROOT::Math::Quaternion::XYZVector operator()(const ROOT::Math::Quaternion::XYZVector& v) const
                                                     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > operator()(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
          ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator()(const ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
          ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator*(const ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
      ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator*(const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
                                                     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
                                                                                       ROOT::Math::Quaternion& operator=(ROOT::Math::Rotation3D const& r)
                                                                                       ROOT::Math::Quaternion& operator=(ROOT::Math::AxisAngle const& a)
                                                                                       ROOT::Math::Quaternion& operator=(ROOT::Math::EulerAngles const& e)
                                                                                       ROOT::Math::Quaternion& operator=(ROOT::Math::RotationZ const& r)
                                                                                       ROOT::Math::Quaternion& operator=(ROOT::Math::RotationY const& r)
                                                                                       ROOT::Math::Quaternion& operator=(ROOT::Math::RotationX const& r)
                                                                                       ROOT::Math::Quaternion& operator=(const ROOT::Math::Quaternion&)
                                                                                                          bool operator==(const ROOT::Math::Quaternion& rhs)
                                                                                                          void Rectify()
                                                                                                          void SetComponents(ROOT::Math::Quaternion::Scalar u, ROOT::Math::Quaternion::Scalar i, ROOT::Math::Quaternion::Scalar j, ROOT::Math::Quaternion::Scalar k)
                                                                                                          void SetComponents(double* begin, double* end)
                                                                                ROOT::Math::Quaternion::Scalar U() const

Data Members

    private:

      ROOT::Math::Quaternion::Scalar fU  
      ROOT::Math::Quaternion::Scalar fI  
      ROOT::Math::Quaternion::Scalar fJ  
      ROOT::Math::Quaternion::Scalar fK

Class Description

Quaternion()


 Quaternion(IT begin, IT end)




explicit Quaternion( Rotation3D const  & r )




explicit Quaternion( AxisAngle const   & a )




explicit Quaternion( EulerAngles const & e )




explicit Quaternion( RotationZ const & r )




explicit Quaternion( RotationY const & r )




explicit Quaternion( RotationX const & r )




 Quaternion(Scalar u, Scalar i, Scalar j, Scalar k)




void Rectify()




 operator=( Rotation3D const  & r )




 operator=( AxisAngle const &   a )




 operator=( EulerAngles const & e )




 operator=( RotationZ const & r )




 operator=( RotationY const & r )




 operator=( RotationX const & r )




void SetComponents(IT begin, IT end)




void GetComponents(IT begin, IT end)




void SetComponents(Scalar u, Scalar i, Scalar j, Scalar k)




void GetComponents(Scalar & u, Scalar & i, Scalar & j, Scalar & k)




Scalar U()




Scalar I()




Scalar J()




Scalar K()




DisplacementVector3D< Cartesian3D<double> > rxyz = operator()(xyz)




DisplacementVector3D< Cartesian3D<double>,Tag > rxyz = operator()(xyz)




xyz = operator()(xyz)




void Invert()




Quaternion Inverse()




Scalar Distance(const Quaternion & q)




return ! operator==(rhs)







Last update: Tue Jul 11 11:46:55 2006









ROOT page - Class index - Class Hierarchy - Top of the page









This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.