+
class ROOT::Math::AxisAngle
-
library: libMathCore
#include "AxisAngle.h"
Display options:
Show inherited
Show non-public

class ROOT::Math::AxisAngle

Function Members (Methods)

public:
~AxisAngle()
ROOT::Math::AxisAngle::ScalarAngle() const
ROOT::Math::AxisAngle::AxisVectorAxis() const
ROOT::Math::AxisAngleAxisAngle()
ROOT::Math::AxisAngleAxisAngle(const ROOT::Math::AxisAngle&)
ROOT::Math::AxisAngleAxisAngle(const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v, ROOT::Math::AxisAngle::Scalar angle)
ROOT::Math::AxisAngleAxisAngle(double* begin, double* end)
voidGetComponents(double* begin) const
ROOT::Math::AxisAngleInverse() const
voidInvert()
booloperator!=(const ROOT::Math::AxisAngle& rhs) const
ROOT::Math::AxisAngle::XYZVectoroperator()(const ROOT::Math::AxisAngle::XYZVector& v) const
ROOT::Math::AxisAngleoperator*(const ROOT::Math::Rotation3D& r) const
ROOT::Math::AxisAngleoperator*(const ROOT::Math::AxisAngle& a) const
ROOT::Math::AxisAngleoperator*(const ROOT::Math::EulerAngles& e) const
ROOT::Math::AxisAngleoperator*(const ROOT::Math::Quaternion& q) const
ROOT::Math::AxisAngleoperator*(const ROOT::Math::RotationZYX& r) const
ROOT::Math::AxisAngleoperator*(const ROOT::Math::RotationX& rx) const
ROOT::Math::AxisAngleoperator*(const ROOT::Math::RotationY& ry) const
ROOT::Math::AxisAngleoperator*(const ROOT::Math::RotationZ& rz) 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::AxisAngle&operator=(ROOT::Math::Rotation3D const& r)
ROOT::Math::AxisAngle&operator=(ROOT::Math::RotationX const& r)
ROOT::Math::AxisAngle&operator=(ROOT::Math::RotationY const& r)
ROOT::Math::AxisAngle&operator=(ROOT::Math::RotationZ const& r)
ROOT::Math::AxisAngle&operator=(ROOT::Math::Quaternion const& r)
ROOT::Math::AxisAngle&operator=(const ROOT::Math::AxisAngle&)
booloperator==(const ROOT::Math::AxisAngle& rhs) const
voidRectify()
voidSetComponents(double* begin, double* end)
private:
static doublePi()
voidRectifyAngle()

Data Members

private:
ROOT::Math::AxisAngle::ScalarfAngle
ROOT::Math::AxisAngle::AxisVectorfAxis

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

void RectifyAngle()
 Note: We could require the angle to be in [0,pi) since we
       can represent negative angles by flipping the axis.
       We choose not to do this.
void Rectify()
 The two conditions are that the angle is in (-pi, pi] and
 the axis is a unit vector.
AxisAngle(const ROOT::Math::AxisAngle& )
Default constructor (axis is z and angle is zero)

{ }
AxisAngle(const AnyVector & v, Scalar angle)
Construct from a non-zero vector (x,y,z) and an angle.
Precondition:  the Vector needs to implement x(), y(), z(), and unit()

{ }
AxisAngle(IT begin, IT end)
Construct given a pair of pointers or iterators defining the
beginning and end of an array of four Scalars, to be treated as
the x, y, and z components of a unit axis vector, and the angle
of rotation.
Precondition:  The first three components are assumed to represent
the rotation axis vector and the 4-th the rotation angle.
The angle is assumed to be in the range (-pi,pi].
The axis vector is automatically normalized to be a unit vector

{ SetComponents(begin,end); }
explicit AxisAngle(const ROOT::Math::AxisAngle& )
 ======== Construction From other Rotation Forms ==================

Construct from another supported rotation type (see gv_detail::convert )

{gv_detail::convert(r,*this);}
AxisAngle & operator=( OtherRotation const & r )
Assign from another supported rotation type (see gv_detail::convert )

void SetComponents(double* begin, double* end)
 ======== Components ==============

Set the axis and then the angle given a pair of pointers or iterators
defining the beginning and end of an array of four Scalars.
Precondition:  The first three components are assumed to represent
the rotation axis vector and the 4-th the rotation angle.
The angle is assumed to be in the range (-pi,pi].
The axis vector is automatically normalized to be a unit vector

void GetComponents(IT begin, IT end)
Get the axis and then the angle into data specified by an iterator begin
and another to the end of the desired data (4 past start).

Scalar Angle()
access to rotation angle

{ return fAngle; }
XYZVector operator()(const ROOT::Math::AxisAngle::XYZVector& v) const
AVector operator*(const AVector & v)
Overload operator * for rotation on a vector

void Invert()
Invert an AxisAngle rotation in place

{ fAngle = -fAngle; }
AxisAngle Inverse()
Return inverse of an AxisAngle rotation

{ AxisAngle result(*this); result.Invert(); return result; }
return ! operator==(const ROOT::Math::AxisAngle& rhs) const
double Pi()
{ return 3.14159265358979323; }
AxisAngle operator*(RotationX const & r1, AxisAngle const & r2)
Multiplication of an axial rotation by an AxisAngle

AxisAngle operator*(RotationY const & r1, AxisAngle const & r2)
AxisAngle operator*(RotationZ const & r1, AxisAngle const & r2)

Last update: root/mathcore:$Name: $:$Id: AxisAngle.cxx,v 1.5 2006/06/22 08:36:27 moneta Exp $
Copyright (c) 2005 , LCG ROOT FNAL MathLib Team *

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.