Logo ROOT  
Reference Guide
Rotation3D.h
Go to the documentation of this file.
1// @(#)root/mathcore:$Id$
2// Authors: W. Brown, M. Fischler, L. Moneta 2005
3
4 /**********************************************************************
5 * *
6 * Copyright (c) 2005 , LCG ROOT FNAL MathLib Team *
7 * *
8 * *
9 **********************************************************************/
10
11// Header file for class Rotation in 3 dimensions, represented by 3x3 matrix
12//
13// Created by: Mark Fischler Thurs June 9 2005
14//
15// Last update: $Id$
16//
17#ifndef ROOT_Math_GenVector_Rotation3D
18#define ROOT_Math_GenVector_Rotation3D 1
19
20
28
36
37
38#include <algorithm>
39#include <cassert>
40#include <iostream>
41
42
43namespace ROOT {
44namespace Math {
45
46
47//__________________________________________________________________________________________
48 /**
49 Rotation class with the (3D) rotation represented by
50 a 3x3 orthogonal matrix.
51 This is the optimal representation for application to vectors.
52 See also ROOT::Math::AxisAngle, ROOT::Math::EulerAngles, and ROOT::Math::Quaternion for
53 classes which have conversion operators to Rotation3D.
54
55 All Rotations types (not only Rotation3D) can be applied to all 3D Vector classes
56 (like ROOT::Math::DisplacementVector3D and ROOT::Math::PositionVector3D)
57 and also to the 4D Vectors (ROOT::Math::LorentzVector classes), acting on the 3D components.
58 A rotation operation is applied by using the operator() or the operator *.
59 With the operator * is possible also to combine rotations.
60 Note that the operator is NOT commutative, the order how the rotations are applied is relevant.
61
62 @ingroup GenVector
63
64 @sa Overview of the @ref GenVector "physics vector library"
65 */
66
68
69public:
70
71 typedef double Scalar;
72
74 kXX = 0, kXY = 1, kXZ = 2
75 , kYX = 3, kYY = 4, kYZ = 5
76 , kZX = 6, kZY = 7, kZZ = 8
77 };
78
79 // ========== Constructors and Assignment =====================
80
81 /**
82 Default constructor (identity rotation)
83 */
84 Rotation3D();
85
86 /**
87 Construct given a pair of pointers or iterators defining the
88 beginning and end of an array of nine Scalars
89 */
90 template<class IT>
91 Rotation3D(IT begin, IT end) { SetComponents(begin,end); }
92
93 /**
94 copy constructor
95 */
96 Rotation3D ( Rotation3D const & r ) {
97 *this = r;
98 }
99
100 /**
101 Construct from an AxisAngle
102 */
103 explicit Rotation3D( AxisAngle const & a ) { gv_detail::convert(a, *this); }
104
105 /**
106 Construct from EulerAngles
107 */
108 explicit Rotation3D( EulerAngles const & e ) { gv_detail::convert(e, *this); }
109
110 /**
111 Construct from RotationZYX
112 */
113 explicit Rotation3D( RotationZYX const & e ) { gv_detail::convert(e, *this); }
114
115 /**
116 Construct from a Quaternion
117 */
118 explicit Rotation3D( Quaternion const & q ) { gv_detail::convert(q, *this); }
119
120 /**
121 Construct from an axial rotation
122 */
123 explicit Rotation3D( RotationZ const & r ) { gv_detail::convert(r, *this); }
124 explicit Rotation3D( RotationY const & r ) { gv_detail::convert(r, *this); }
125 explicit Rotation3D( RotationX const & r ) { gv_detail::convert(r, *this); }
126
127 /**
128 Construct from a linear algebra matrix of size at least 3x3,
129 which must support operator()(i,j) to obtain elements (0,0) thru (2,2).
130 Precondition: The matrix is assumed to be orthonormal. No checking
131 or re-adjusting is performed.
132 */
133 template<class ForeignMatrix>
134 explicit Rotation3D(const ForeignMatrix & m) { SetComponents(m); }
135
136 /**
137 Construct from three orthonormal vectors (which must have methods
138 x(), y() and z()) which will be used as the columns of the rotation
139 matrix. The orthonormality will be checked, and values adjusted
140 so that the result will always be a good rotation matrix.
141 */
142 template<class ForeignVector>
143 Rotation3D(const ForeignVector& v1,
144 const ForeignVector& v2,
145 const ForeignVector& v3 ) { SetComponents(v1, v2, v3); }
146
147 // compiler generated destruuctor is ok
148
149 /**
150 Raw constructor from nine Scalar components (without any checking)
151 */
153 Scalar yx, Scalar yy, Scalar yz,
154 Scalar zx, Scalar zy, Scalar zz)
155 {
156 SetComponents (xx, xy, xz, yx, yy, yz, zx, zy, zz);
157 }
158
159 // need to implement assignment operator to avoid using the templated one
160
161 /**
162 Assignment operator
163 */
164 Rotation3D &
165 operator=( Rotation3D const & rhs ) {
166 SetComponents( rhs.fM[0], rhs.fM[1], rhs.fM[2],
167 rhs.fM[3], rhs.fM[4], rhs.fM[5],
168 rhs.fM[6], rhs.fM[7], rhs.fM[8] );
169 return *this;
170 }
171
172 /**
173 Assign from an AxisAngle
174 */
175 Rotation3D &
176 operator=( AxisAngle const & a ) { return operator=(Rotation3D(a)); }
177
178 /**
179 Assign from EulerAngles
180 */
181 Rotation3D &
182 operator=( EulerAngles const & e ) { return operator=(Rotation3D(e)); }
183
184 /**
185 Assign from RotationZYX
186 */
187 Rotation3D &
188 operator=( RotationZYX const & r ) { return operator=(Rotation3D(r)); }
189
190 /**
191 Assign from a Quaternion
192 */
193 Rotation3D &
194 operator=( Quaternion const & q ) {return operator=(Rotation3D(q)); }
195
196 /**
197 Assign from an axial rotation
198 */
199 Rotation3D &
200 operator=( RotationZ const & r ) { return operator=(Rotation3D(r)); }
201 Rotation3D &
202 operator=( RotationY const & r ) { return operator=(Rotation3D(r)); }
203 Rotation3D &
204 operator=( RotationX const & r ) { return operator=(Rotation3D(r)); }
205
206 /**
207 Assign from an orthonormal linear algebra matrix of size 3x3,
208 which must support operator()(i,j) to obtain elements (0,0) thru (2,2).
209 */
210 template<class ForeignMatrix>
211 Rotation3D &
212 operator=(const ForeignMatrix & m) {
213 SetComponents( m(0,0), m(0,1), m(0,2),
214 m(1,0), m(1,1), m(1,2),
215 m(2,0), m(2,1), m(2,2) );
216 return *this;
217 }
218
219 /**
220 Re-adjust components to eliminate small deviations from perfect
221 orthonormality.
222 */
223 void Rectify();
224
225 // ======== Components ==============
226
227 /**
228 Set components from three orthonormal vectors (which must have methods
229 x(), y() and z()) which will be used as the columns of the rotation
230 matrix. The orthonormality will be checked, and values adjusted
231 so that the result will always be a good rotation matrix.
232 */
233 template<class ForeignVector>
234 void
235 SetComponents (const ForeignVector& v1,
236 const ForeignVector& v2,
237 const ForeignVector& v3 ) {
238 fM[kXX]=v1.x(); fM[kXY]=v2.x(); fM[kXZ]=v3.x();
239 fM[kYX]=v1.y(); fM[kYY]=v2.y(); fM[kYZ]=v3.y();
240 fM[kZX]=v1.z(); fM[kZY]=v2.z(); fM[kZZ]=v3.z();
241 Rectify();
242 }
243
244 /**
245 Get components into three vectors which will be the (orthonormal)
246 columns of the rotation matrix. (The vector class must have a
247 constructor from 3 Scalars.)
248 */
249 template<class ForeignVector>
250 void
251 GetComponents ( ForeignVector& v1,
252 ForeignVector& v2,
253 ForeignVector& v3 ) const {
254 v1 = ForeignVector ( fM[kXX], fM[kYX], fM[kZX] );
255 v2 = ForeignVector ( fM[kXY], fM[kYY], fM[kZY] );
256 v3 = ForeignVector ( fM[kXZ], fM[kYZ], fM[kZZ] );
257 }
258
259 /**
260 Set the 9 matrix components given an iterator to the start of
261 the desired data, and another to the end (9 past start).
262 */
263 template<class IT>
264 void SetComponents(IT begin, IT end) {
265 for (int i = 0; i <9; ++i) {
266 fM[i] = *begin;
267 ++begin;
268 }
269 (void)end;
270 assert (end==begin);
271 }
272
273 /**
274 Get the 9 matrix components into data specified by an iterator begin
275 and another to the end of the desired data (9 past start).
276 */
277 template<class IT>
278 void GetComponents(IT begin, IT end) const {
279 for (int i = 0; i <9; ++i) {
280 *begin = fM[i];
281 ++begin;
282 }
283 (void)end;
284 assert (end==begin);
285 }
286
287 /**
288 Get the 9 matrix components into data specified by an iterator begin
289 */
290 template<class IT>
291 void GetComponents(IT begin) const {
292 std::copy ( fM, fM+9, begin );
293 }
294
295 /**
296 Set components from a linear algebra matrix of size at least 3x3,
297 which must support operator()(i,j) to obtain elements (0,0) thru (2,2).
298 Precondition: The matrix is assumed to be orthonormal. NO checking
299 or re-adjusting is performed.
300 */
301 template<class ForeignMatrix>
302 void
303 SetRotationMatrix (const ForeignMatrix & m) {
304 fM[kXX]=m(0,0); fM[kXY]=m(0,1); fM[kXZ]=m(0,2);
305 fM[kYX]=m(1,0); fM[kYY]=m(1,1); fM[kYZ]=m(1,2);
306 fM[kZX]=m(2,0); fM[kZY]=m(2,1); fM[kZZ]=m(2,2);
307 }
308
309 /**
310 Get components into a linear algebra matrix of size at least 3x3,
311 which must support operator()(i,j) for write access to elements
312 (0,0) thru (2,2).
313 */
314 template<class ForeignMatrix>
315 void
316 GetRotationMatrix (ForeignMatrix & m) const {
317 m(0,0)=fM[kXX]; m(0,1)=fM[kXY]; m(0,2)=fM[kXZ];
318 m(1,0)=fM[kYX]; m(1,1)=fM[kYY]; m(1,2)=fM[kYZ];
319 m(2,0)=fM[kZX]; m(2,1)=fM[kZY]; m(2,2)=fM[kZZ];
320 }
321
322 /**
323 Set the components from nine scalars -- UNCHECKED for orthonormaility
324 */
325 void
327 Scalar yx, Scalar yy, Scalar yz,
328 Scalar zx, Scalar zy, Scalar zz) {
329 fM[kXX]=xx; fM[kXY]=xy; fM[kXZ]=xz;
330 fM[kYX]=yx; fM[kYY]=yy; fM[kYZ]=yz;
331 fM[kZX]=zx; fM[kZY]=zy; fM[kZZ]=zz;
332 }
333
334 /**
335 Get the nine components into nine scalars
336 */
337 void
339 Scalar &yx, Scalar &yy, Scalar &yz,
340 Scalar &zx, Scalar &zy, Scalar &zz) const {
341 xx=fM[kXX]; xy=fM[kXY]; xz=fM[kXZ];
342 yx=fM[kYX]; yy=fM[kYY]; yz=fM[kYZ];
343 zx=fM[kZX]; zy=fM[kZY]; zz=fM[kZZ];
344 }
345
346 // =========== operations ==============
347
348
349 /**
350 Rotation operation on a displacement vector in any coordinate system
351 */
352 template <class CoordSystem, class U>
356 xyz.SetXYZ( fM[kXX] * v.X() + fM[kXY] * v.Y() + fM[kXZ] * v.Z() ,
357 fM[kYX] * v.X() + fM[kYY] * v.Y() + fM[kYZ] * v.Z() ,
358 fM[kZX] * v.X() + fM[kZY] * v.Y() + fM[kZZ] * v.Z() );
360 }
361
362 /**
363 Rotation operation on a position vector in any coordinate system
364 */
365 template <class CoordSystem, class U>
370 return PositionVector3D<CoordSystem,U> ( rxyz );
371 }
372
373 /**
374 Rotation operation on a Lorentz vector in any spatial coordinate system
375 */
376 template <class CoordSystem>
380 xyz = operator()(xyz);
381 LorentzVector< PxPyPzE4D<double> > xyzt (xyz.X(), xyz.Y(), xyz.Z(), v.E());
382 return LorentzVector<CoordSystem> ( xyzt );
383 }
384
385 /**
386 Rotation operation on an arbitrary vector v.
387 Preconditions: v must implement methods x(), y(), and z()
388 and the arbitrary vector type must have a constructor taking (x,y,z)
389 */
390 template <class ForeignVector>
391 ForeignVector
392 operator() (const ForeignVector & v) const {
395 return ForeignVector ( rxyz.X(), rxyz.Y(), rxyz.Z() );
396 }
397
398 /**
399 Overload operator * for rotation on a vector
400 */
401 template <class AVector>
402 inline
403 AVector operator* (const AVector & v) const
404 {
405 return operator()(v);
406 }
407
408 /**
409 Invert a rotation in place
410 */
411 void Invert();
412
413 /**
414 Return inverse of a rotation
415 */
416 Rotation3D Inverse() const { Rotation3D t(*this); t.Invert(); return t; }
417
418 // ========= Multi-Rotation Operations ===============
419
420 /**
421 Multiply (combine) two rotations
422 */
424 return Rotation3D
425 ( fM[kXX]*r.fM[kXX] + fM[kXY]*r.fM[kYX] + fM[kXZ]*r.fM[kZX]
426 , fM[kXX]*r.fM[kXY] + fM[kXY]*r.fM[kYY] + fM[kXZ]*r.fM[kZY]
427 , fM[kXX]*r.fM[kXZ] + fM[kXY]*r.fM[kYZ] + fM[kXZ]*r.fM[kZZ]
428
429 , fM[kYX]*r.fM[kXX] + fM[kYY]*r.fM[kYX] + fM[kYZ]*r.fM[kZX]
430 , fM[kYX]*r.fM[kXY] + fM[kYY]*r.fM[kYY] + fM[kYZ]*r.fM[kZY]
431 , fM[kYX]*r.fM[kXZ] + fM[kYY]*r.fM[kYZ] + fM[kYZ]*r.fM[kZZ]
432
433 , fM[kZX]*r.fM[kXX] + fM[kZY]*r.fM[kYX] + fM[kZZ]*r.fM[kZX]
434 , fM[kZX]*r.fM[kXY] + fM[kZY]*r.fM[kYY] + fM[kZZ]*r.fM[kZY]
435 , fM[kZX]*r.fM[kXZ] + fM[kZY]*r.fM[kYZ] + fM[kZZ]*r.fM[kZZ] );
436
437 }
438
439
440 /**
441 Multiplication with arbitrary rotations
442 */
443 // note: cannot have a template method since it is ambigous with the operator * on vectors
444
445 Rotation3D operator * (const AxisAngle & a) const;
446 Rotation3D operator * (const EulerAngles & e) const;
447 Rotation3D operator * (const Quaternion & q) const;
448 Rotation3D operator * (const RotationZYX & r) const;
449 Rotation3D operator * (const RotationX & rx) const;
450 Rotation3D operator * (const RotationY & ry) const;
451 Rotation3D operator * (const RotationZ & rz) const;
452
453 /**
454 Post-Multiply (on right) by another rotation : T = T*R
455 */
456 template <class R>
457 Rotation3D & operator *= (const R & r) { return *this = (*this)*r; }
458
459 /**
460 Equality/inequality operators
461 */
462 bool operator == (const Rotation3D & rhs) const {
463 if( fM[0] != rhs.fM[0] ) return false;
464 if( fM[1] != rhs.fM[1] ) return false;
465 if( fM[2] != rhs.fM[2] ) return false;
466 if( fM[3] != rhs.fM[3] ) return false;
467 if( fM[4] != rhs.fM[4] ) return false;
468 if( fM[5] != rhs.fM[5] ) return false;
469 if( fM[6] != rhs.fM[6] ) return false;
470 if( fM[7] != rhs.fM[7] ) return false;
471 if( fM[8] != rhs.fM[8] ) return false;
472 return true;
473 }
474 bool operator != (const Rotation3D & rhs) const {
475 return ! operator==(rhs);
476 }
477
478private:
479
480 Scalar fM[9]; // 9 elements (3x3 matrix) representing the rotation
481
482}; // Rotation3D
483
484// ============ Class Rotation3D ends here ============
485
486/**
487 Distance between two rotations
488 */
489template <class R>
490inline
491typename Rotation3D::Scalar
492Distance ( const Rotation3D& r1, const R & r2) {return gv_detail::dist(r1,r2);}
493
494/**
495 Multiplication of an axial rotation by a Rotation3D
496 */
497Rotation3D operator* (RotationX const & r1, Rotation3D const & r2);
498Rotation3D operator* (RotationY const & r1, Rotation3D const & r2);
499Rotation3D operator* (RotationZ const & r1, Rotation3D const & r2);
500
501/**
502 Multiplication of an axial rotation by another axial Rotation
503 */
504Rotation3D operator* (RotationX const & r1, RotationY const & r2);
505Rotation3D operator* (RotationX const & r1, RotationZ const & r2);
506
507Rotation3D operator* (RotationY const & r1, RotationX const & r2);
508Rotation3D operator* (RotationY const & r1, RotationZ const & r2);
509
510Rotation3D operator* (RotationZ const & r1, RotationX const & r2);
511Rotation3D operator* (RotationZ const & r1, RotationY const & r2);
512
513/**
514 Stream Output and Input
515 */
516 // TODO - I/O should be put in the manipulator form
517
518std::ostream & operator<< (std::ostream & os, const Rotation3D & r);
519
520} // namespace Math
521} // namespace ROOT
522
523#endif // ROOT_Math_GenVector_Rotation3D
#define e(i)
Definition: RSha256.hxx:103
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint xy
float * q
Definition: THbookFile.cxx:89
AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotat...
Definition: AxisAngle.h:42
Class describing a generic displacement vector in 3 dimensions.
Scalar X() const
Cartesian X, converting if necessary from internal coordinate system.
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
DisplacementVector3D< CoordSystem, Tag > & SetXYZ(Scalar a, Scalar b, Scalar c)
set the values of the vector from the cartesian components (x,y,z) (if the vector is held in polar or...
Scalar Z() const
Cartesian Z, converting if necessary from internal coordinate system.
EulerAngles class describing rotation as three angles (Euler Angles).
Definition: EulerAngles.h:45
Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system ...
Definition: LorentzVector.h:59
Class describing a generic position vector (point) in 3 dimensions.
Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k).
Definition: Quaternion.h:49
Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix.
Definition: Rotation3D.h:67
Rotation3D(AxisAngle const &a)
Construct from an AxisAngle.
Definition: Rotation3D.h:103
Rotation3D(RotationZ const &r)
Construct from an axial rotation.
Definition: Rotation3D.h:123
void SetComponents(IT begin, IT end)
Set the 9 matrix components given an iterator to the start of the desired data, and another to the en...
Definition: Rotation3D.h:264
Rotation3D & operator=(Quaternion const &q)
Assign from a Quaternion.
Definition: Rotation3D.h:194
void GetComponents(IT begin) const
Get the 9 matrix components into data specified by an iterator begin.
Definition: Rotation3D.h:291
Rotation3D(IT begin, IT end)
Construct given a pair of pointers or iterators defining the beginning and end of an array of nine Sc...
Definition: Rotation3D.h:91
Rotation3D(RotationX const &r)
Definition: Rotation3D.h:125
void SetComponents(Scalar xx, Scalar xy, Scalar xz, Scalar yx, Scalar yy, Scalar yz, Scalar zx, Scalar zy, Scalar zz)
Set the components from nine scalars – UNCHECKED for orthonormaility.
Definition: Rotation3D.h:326
void Rectify()
Re-adjust components to eliminate small deviations from perfect orthonormality.
Definition: Rotation3D.cxx:38
Rotation3D & operator=(AxisAngle const &a)
Assign from an AxisAngle.
Definition: Rotation3D.h:176
void Invert()
Invert a rotation in place.
Definition: Rotation3D.cxx:109
void SetRotationMatrix(const ForeignMatrix &m)
Set components from a linear algebra matrix of size at least 3x3, which must support operator()(i,...
Definition: Rotation3D.h:303
Rotation3D & operator=(Rotation3D const &rhs)
Assignment operator.
Definition: Rotation3D.h:165
Rotation3D(RotationY const &r)
Definition: Rotation3D.h:124
DisplacementVector3D< CoordSystem, U > operator()(const DisplacementVector3D< CoordSystem, U > &v) const
Rotation operation on a displacement vector in any coordinate system.
Definition: Rotation3D.h:354
void GetComponents(ForeignVector &v1, ForeignVector &v2, ForeignVector &v3) const
Get components into three vectors which will be the (orthonormal) columns of the rotation matrix.
Definition: Rotation3D.h:251
bool operator!=(const Rotation3D &rhs) const
Definition: Rotation3D.h:474
Rotation3D & operator=(RotationZ const &r)
Assign from an axial rotation.
Definition: Rotation3D.h:200
Rotation3D Inverse() const
Return inverse of a rotation.
Definition: Rotation3D.h:416
Rotation3D & operator=(RotationZYX const &r)
Assign from RotationZYX.
Definition: Rotation3D.h:188
Rotation3D(RotationZYX const &e)
Construct from RotationZYX.
Definition: Rotation3D.h:113
AVector operator*(const AVector &v) const
Overload operator * for rotation on a vector.
Definition: Rotation3D.h:403
Rotation3D(Rotation3D const &r)
copy constructor
Definition: Rotation3D.h:96
Rotation3D(Quaternion const &q)
Construct from a Quaternion.
Definition: Rotation3D.h:118
void SetComponents(const ForeignVector &v1, const ForeignVector &v2, const ForeignVector &v3)
Set components from three orthonormal vectors (which must have methods x(), y() and z()) which will b...
Definition: Rotation3D.h:235
Rotation3D(EulerAngles const &e)
Construct from EulerAngles.
Definition: Rotation3D.h:108
void GetComponents(IT begin, IT end) const
Get the 9 matrix components into data specified by an iterator begin and another to the end of the de...
Definition: Rotation3D.h:278
Rotation3D(const ForeignVector &v1, const ForeignVector &v2, const ForeignVector &v3)
Construct from three orthonormal vectors (which must have methods x(), y() and z()) which will be use...
Definition: Rotation3D.h:143
Rotation3D & operator=(RotationY const &r)
Definition: Rotation3D.h:202
Rotation3D()
Default constructor (identity rotation)
Definition: Rotation3D.cxx:29
void GetRotationMatrix(ForeignMatrix &m) const
Get components into a linear algebra matrix of size at least 3x3, which must support operator()(i,...
Definition: Rotation3D.h:316
void GetComponents(Scalar &xx, Scalar &xy, Scalar &xz, Scalar &yx, Scalar &yy, Scalar &yz, Scalar &zx, Scalar &zy, Scalar &zz) const
Get the nine components into nine scalars.
Definition: Rotation3D.h:338
Rotation3D(const ForeignMatrix &m)
Construct from a linear algebra matrix of size at least 3x3, which must support operator()(i,...
Definition: Rotation3D.h:134
Rotation3D & operator*=(const R &r)
Post-Multiply (on right) by another rotation : T = T*R.
Definition: Rotation3D.h:457
Rotation3D(Scalar xx, Scalar xy, Scalar xz, Scalar yx, Scalar yy, Scalar yz, Scalar zx, Scalar zy, Scalar zz)
Raw constructor from nine Scalar components (without any checking)
Definition: Rotation3D.h:152
Rotation3D & operator=(EulerAngles const &e)
Assign from EulerAngles.
Definition: Rotation3D.h:182
Rotation3D & operator=(const ForeignMatrix &m)
Assign from an orthonormal linear algebra matrix of size 3x3, which must support operator()(i,...
Definition: Rotation3D.h:212
Rotation3D & operator=(RotationX const &r)
Definition: Rotation3D.h:204
bool operator==(const Rotation3D &rhs) const
Equality/inequality operators.
Definition: Rotation3D.h:462
Rotation class representing a 3D rotation about the X axis by the angle of rotation.
Definition: RotationX.h:45
Rotation class representing a 3D rotation about the Y axis by the angle of rotation.
Definition: RotationY.h:45
Rotation class with the (3D) rotation represented by angles describing first a rotation of an angle p...
Definition: RotationZYX.h:63
Rotation class representing a 3D rotation about the Z axis by the angle of rotation.
Definition: RotationZ.h:45
Namespace for new Math classes and functions.
void(off) SmallVectorTemplateBase< T
double dist(Rotation3D const &r1, Rotation3D const &r2)
Definition: 3DDistances.cxx:48
void convert(R1 const &, R2 const)
Definition: 3DConversions.h:41
std::ostream & operator<<(std::ostream &os, const AxisAngle &a)
Stream Output and Input.
Definition: AxisAngle.cxx:91
AxisAngle operator*(RotationX const &r1, AxisAngle const &r2)
Multiplication of an axial rotation by an AxisAngle.
AxisAngle::Scalar Distance(const AxisAngle &r1, const R &r2)
Distance between two rotations.
Definition: AxisAngle.h:321
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
auto * m
Definition: textangle.C:8
auto * a
Definition: textangle.C:12