ROOT   Reference Guide
PositionVector3D.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 MathLib Team *
7 * *
8 * *
9 **********************************************************************/
10
11// Header file for class PositionVector3D
12//
13// Created by: Lorenzo Moneta at Mon May 30 15:25:04 2005
14//
15// Last update: $Id$
16//
17#ifndef ROOT_Math_GenVector_PositionVector3D
18#define ROOT_Math_GenVector_PositionVector3D 1
19
21
23
25
27
29
30
31#include <cassert>
32
33namespace ROOT {
34
35 namespace Math {
36
37
38//__________________________________________________________________________________________
39 /**
40 Class describing a generic position vector (point) in 3 dimensions.
41 This class is templated on the type of Coordinate system.
42 One example is the XYZPoint which is a vector based on
43 double precision x,y,z data members by using the
44 ROOT::Math::Cartesian3D<double> Coordinate system.
45 The class is having also an extra template parameter, the coordinate system tag,
46 to be able to identify (tag) vector described in different reference coordinate system,
47 like global or local coordinate systems.
48
49 @ingroup GenVector
50
51 @sa Overview of the @ref GenVector "physics vector library"
52 */
53
54 template <class CoordSystem, class Tag = DefaultCoordinateSystemTag >
56
57 public:
58
59 typedef typename CoordSystem::Scalar Scalar;
60 typedef CoordSystem CoordinateType;
62
63 // ------ ctors ------
64
65 /**
66 Default constructor. Construct an empty object with zero values
67 */
68
70
71 /**
72 Construct from three values of type <em>Scalar</em>.
73 In the case of a XYZPoint the values are x,y,z
74 In the case of a polar vector they are r,theta,phi
75 */
76 PositionVector3D(const Scalar & a, const Scalar & b, const Scalar & c) :
77 fCoordinates ( a , b, c) { }
78
79 /**
80 Construct from a position vector expressed in different
81 coordinates, or using a different Scalar type
82 */
83 template <class T>
85 fCoordinates ( v.Coordinates() ) { }
86
87 /**
88 Construct from an arbitrary displacement vector
89 */
90 template <class T>
92 fCoordinates ( p.Coordinates() ) { }
93
94 /**
95 Construct from a foreign 3D vector type, for example, Hep3Vector
96 Precondition: v must implement methods x(), y() and z()
97 */
98 template <class ForeignVector>
99 explicit PositionVector3D( const ForeignVector & v) :
100 fCoordinates ( Cartesian3D<Scalar>( v.x(), v.y(), v.z() ) ) { }
101
102#ifdef LATER
103 /**
104 construct from a generic linear algebra vector of at least size 3
105 implementing operator []. This could be also a C array
106 \par v LAVector
107 \par index0 index where coordinates starts (typically zero)
108 It works for all Coordinates types,
109 ( x= v[index0] for Cartesian and r=v[index0] for Polar )
110 */
111 template <class LAVector>
112 PositionVector3D(const LAVector & v, size_t index0 ) {
113 fCoordinates = CoordSystem ( v[index0], v[index0+1], v[index0+2] );
114 }
115#endif
116
117 // compiler-generated copy ctor and dtor are fine.
118
119 // ------ assignment ------
120
121 /**
122 Assignment operator from a position vector of arbitrary type
123 */
124 template <class OtherCoords>
127 fCoordinates = v.Coordinates();
128 return *this;
129 }
130
131 /**
132 Assignment operator from a displacement vector of arbitrary type
133 */
134 template <class OtherCoords>
137 fCoordinates = v.Coordinates();
138 return *this;
139 }
140
141 /**
142 Assignment from a foreign 3D vector type, for example, Hep3Vector
143 Precondition: v must implement methods x(), y() and z()
144 */
145 template <class ForeignVector>
146 PositionVector3D & operator= ( const ForeignVector & v) {
147 SetXYZ( v.x(), v.y(), v.z() );
148 return *this;
149 }
150
151#ifdef LATER
152 /**
153 assign from a generic linear algebra vector of at least size 3
154 implementing operator [].
155 \par v LAVector
156 \par index0 index where coordinates starts (typically zero)
157 It works for all Coordinates types,
158 ( x= v[index0] for Cartesian and r=v[index0] for Polar )
159 */
160 template <class LAVector>
161 PositionVector3D & assignFrom(const LAVector & v, size_t index0 = 0) {
162 fCoordinates = CoordSystem ( v[index0], v[index0+1], v[index0+2] );
163 return *this;
164 }
165#endif
166
167 /**
168 Retrieve a copy of the coordinates object
169 */
170 const CoordSystem & Coordinates() const {
171 return fCoordinates;
172 }
173
174 /**
175 Set internal data based on a C-style array of 3 Scalar numbers
176 */
178 { fCoordinates.SetCoordinates(src); return *this; }
179
180 /**
181 Set internal data based on 3 Scalar numbers
182 */
184 { fCoordinates.SetCoordinates(a, b, c); return *this; }
185
186 /**
187 Set internal data based on 3 Scalars at *begin to *end
188 */
189 template <class IT>
191 { IT a = begin; IT b = ++begin; IT c = ++begin;
192 (void)end;
193 assert (++begin==end);
194 SetCoordinates (*a,*b,*c);
195 return *this;
196 }
197
198 /**
199 get internal data into 3 Scalar numbers
200 */
201 void GetCoordinates( Scalar& a, Scalar& b, Scalar& c ) const
202 { fCoordinates.GetCoordinates(a, b, c); }
203
204 /**
205 get internal data into a C-style array of 3 Scalar numbers
206 */
207 void GetCoordinates( Scalar dest[] ) const
208 { fCoordinates.GetCoordinates(dest); }
209
210 /**
211 get internal data into 3 Scalars at *begin to *end (3 past begin)
212 */
213 template <class IT>
214 void GetCoordinates( IT begin, IT end ) const
215 { IT a = begin; IT b = ++begin; IT c = ++begin;
216 (void)end;
217 assert (++begin==end);
218 GetCoordinates (*a,*b,*c);
219 }
220
221 /**
222 get internal data into 3 Scalars at *begin
223 */
224 template <class IT>
225 void GetCoordinates( IT begin ) const {
226 Scalar a = Scalar(0);
227 Scalar b = Scalar(0);
228 Scalar c = Scalar(0);
229 GetCoordinates(a, b, c);
230 *begin++ = a;
231 *begin++ = b;
232 *begin = c;
233 }
234
235 /**
236 set the values of the vector from the cartesian components (x,y,z)
237 (if the vector is held in polar or cylindrical eta coordinates,
238 then (x, y, z) are converted to that form)
239 */
241 fCoordinates.SetXYZ(a,b,c);
242 return *this;
243 }
244
245 // ------------------- Equality -----------------
246
247 /**
248 Exact equality
249 */
250 bool operator==(const PositionVector3D & rhs) const {
251 return fCoordinates==rhs.fCoordinates;
252 }
253 bool operator!= (const PositionVector3D & rhs) const {
254 return !(operator==(rhs));
255 }
256
257 // ------ Individual element access, in various coordinate systems ------
258
259 /**
260 Cartesian X, converting if necessary from internal coordinate system.
261 */
262 Scalar X() const { return fCoordinates.X(); }
263
264 /**
265 Cartesian Y, converting if necessary from internal coordinate system.
266 */
267 Scalar Y() const { return fCoordinates.Y(); }
268
269 /**
270 Cartesian Z, converting if necessary from internal coordinate system.
271 */
272 Scalar Z() const { return fCoordinates.Z(); }
273
274 /**
275 Polar R, converting if necessary from internal coordinate system.
276 */
277 Scalar R() const { return fCoordinates.R(); }
278
279 /**
280 Polar theta, converting if necessary from internal coordinate system.
281 */
282 Scalar Theta() const { return fCoordinates.Theta(); }
283
284 /**
285 Polar phi, converting if necessary from internal coordinate system.
286 */
287 Scalar Phi() const { return fCoordinates.Phi(); }
288
289 /**
290 Polar eta, converting if necessary from internal coordinate system.
291 */
292 Scalar Eta() const { return fCoordinates.Eta(); }
293
294 /**
295 Cylindrical transverse component rho
296 */
297 Scalar Rho() const { return fCoordinates.Rho(); }
298
299 // ----- Other fundamental properties -----
300
301 /**
302 Magnitute squared ( r^2 in spherical coordinate)
303 */
304 Scalar Mag2() const { return fCoordinates.Mag2();}
305
306 /**
307 Transverse component squared (rho^2 in cylindrical coordinates.
308 */
309 Scalar Perp2() const { return fCoordinates.Perp2();}
310
311 // It is physically meaningless to speak of the unit vector corresponding
312 // to a point.
313
314 // ------ Setting individual elements present in coordinate system ------
315
316 /**
317 Change X - Cartesian3D coordinates only
318 */
320
321 /**
322 Change Y - Cartesian3D coordinates only
323 */
325
326 /**
327 Change Z - Cartesian3D coordinates only
328 */
330
331 /**
332 Change R - Polar3D coordinates only
333 */
335
336 /**
337 Change Theta - Polar3D coordinates only
338 */
339 PositionVector3D<CoordSystem, Tag>& SetTheta (Scalar ang) { fCoordinates.SetTheta(ang); return *this;}
340
341 /**
342 Change Phi - Polar3D or CylindricalEta3D coordinates
343 */
345
346 /**
347 Change Rho - CylindricalEta3D coordinates only
348 */
350
351 /**
352 Change Eta - CylindricalEta3D coordinates only
353 */
354 PositionVector3D<CoordSystem, Tag>& SetEta (Scalar etaval) { fCoordinates.SetEta(etaval); return *this;}
355
356 // ------ Operations combining two vectors ------
357 // need to specialize to exclude those with a different tags
358
359 /**
360 Return the scalar (Dot) product of this with a displacement vector in
361 any coordinate system, but with the same tag
362 */
363 template< class OtherCoords >
365 return X()*v.x() + Y()*v.y() + Z()*v.z();
366 }
367
368
369 /**
370 Return vector (Cross) product of this point with a displacement, as a
371 point vector in this coordinate system of the first.
372 */
373 template< class OtherCoords >
376 result.SetXYZ ( Y()*v.z() - v.y()*Z(),
377 Z()*v.x() - v.z()*X(),
378 X()*v.y() - v.x()*Y() );
379 return result;
380 }
381
382 // The Dot and Cross products of a pair of point vectors are physically
383 // meaningless concepts and thus are defined as private methods
384
385 // It is physically meaningless to speak of the Unit vector corresponding
386 // to a point.
387
388
389 /**
390 Self Addition with a displacement vector.
391 */
392 template <class OtherCoords>
394 {
395 SetXYZ( X() + v.X(), Y() + v.Y(), Z() + v.Z() );
396 return *this;
397 }
398
399 /**
400 Self Difference with a displacement vector.
401 */
402 template <class OtherCoords>
404 {
405 SetXYZ( X() - v.X(), Y() - v.Y(), Z() - v.Z() );
406 return *this;
407 }
408
409 /**
410 multiply this vector by a scalar quantity
411 */
413 fCoordinates.Scale(a);
414 return *this;
415 }
416
417 /**
418 divide this vector by a scalar quantity
419 */
421 fCoordinates.Scale(1/a);
422 return *this;
423 }
424
425 // The following methods (v*a and v/a) could instead be free functions.
426 // They were moved into the class to solve a problem on AIX.
427 /**
428 Multiply a vector by a real number
429 */
431 PositionVector3D tmp(*this);
432 tmp *= a;
433 return tmp;
434 }
435
436 /**
437 Division of a vector with a real number
438 */
440 PositionVector3D tmp(*this);
441 tmp /= a;
442 return tmp;
443 }
444
445 // Limited backward name compatibility with CLHEP
446
447 Scalar x() const { return fCoordinates.X(); }
448 Scalar y() const { return fCoordinates.Y(); }
449 Scalar z() const { return fCoordinates.Z(); }
450 Scalar r() const { return fCoordinates.R(); }
451 Scalar theta() const { return fCoordinates.Theta(); }
452 Scalar phi() const { return fCoordinates.Phi(); }
453 Scalar eta() const { return fCoordinates.Eta(); }
454 Scalar rho() const { return fCoordinates.Rho(); }
455 Scalar mag2() const { return fCoordinates.Mag2(); }
456 Scalar perp2() const { return fCoordinates.Perp2(); }
457
458 private:
459
460 CoordSystem fCoordinates;
461
462 // Prohibited methods
463
464 // this should not compile (if from a vector or points with different tag
465
466 template <class OtherCoords, class OtherTag>
468
469 template <class OtherCoords, class OtherTag>
471
472 template <class OtherCoords, class OtherTag>
474
475 template <class OtherCoords, class OtherTag>
477
478 template <class OtherCoords, class OtherTag>
480
481 template <class OtherCoords, class OtherTag>
483
484// /**
485// Dot product of two position vectors is inappropriate
486// */
487// template <class T2, class U>
488// PositionVector3D Dot( const PositionVector3D<T2,U> & v) const;
489
490// /**
491// Cross product of two position vectors is inappropriate
492// */
493// template <class T2, class U>
494// PositionVector3D Cross( const PositionVector3D<T2,U> & v) const;
495
496
497
498 };
499
500// ---------- PositionVector3D class template ends here ----------------
501// ---------------------------------------------------------------------
502
503 /**
504 Multiplication of a position vector by real number a*v
505 */
506 template <class CoordSystem, class U>
507 inline
511 return v *= a;
512 // Note - passing v by value and using operator *= may save one
513 // copy relative to passing v by const ref and creating a temporary.
514 }
515
516 /**
517 Difference between two PositionVector3D vectors.
518 The result is a DisplacementVector3D.
519 The (coordinate system) type of the returned vector is defined to
520 be identical to that of the first position vector.
521 */
522
523 template <class CoordSystem1, class CoordSystem2, class U>
524 inline
525 DisplacementVector3D<CoordSystem1,U>
529 v1.X()-v2.X(), v1.Y()-v2.Y(),v1.Z()-v2.Z() )
530 );
531 }
532
533 /**
534 Addition of a PositionVector3D and a DisplacementVector3D.
535 The return type is a PositionVector3D,
536 of the same (coordinate system) type as the input PositionVector3D.
537 */
538 template <class CoordSystem1, class CoordSystem2, class U>
539 inline
540 PositionVector3D<CoordSystem2,U>
543 return p1 += v2;
544 }
545
546 /**
547 Addition of a DisplacementVector3D and a PositionVector3D.
548 The return type is a PositionVector3D,
549 of the same (coordinate system) type as the input PositionVector3D.
550 */
551 template <class CoordSystem1, class CoordSystem2, class U>
552 inline
553 PositionVector3D<CoordSystem2,U>
556 return p2 += v1;
557 }
558
559 /**
560 Subtraction of a DisplacementVector3D from a PositionVector3D.
561 The return type is a PositionVector3D,
562 of the same (coordinate system) type as the input PositionVector3D.
563 */
564 template <class CoordSystem1, class CoordSystem2, class U>
565 inline
566 PositionVector3D<CoordSystem2,U>
569 return p1 -= v2;
570 }
571
572 // Scaling of a position vector with a real number is not physically meaningful
573
574 // ------------- I/O to/from streams -------------
575
576 template <
577 class char_t, class traits_t, class T, class U,
579 std::basic_ostream<char_t, traits_t> &operator<<(std::basic_ostream<char_t, traits_t> &os,
580 PositionVector3D<T, U> const &v)
581 {
582 if (os) {
583
584 typename T::Scalar a = 0;
585 typename T::Scalar b = 0;
586 typename T::Scalar c = 0;
587 v.GetCoordinates(a, b, c);
588
591 typedef GenVector_detail::BitReproducible BR;
592 BR::Output(os, a);
593 BR::Output(os, b);
594 BR::Output(os, c);
595 } else {
598 }
599 }
600 return os;
601 } // op<< <>()
602
603 template <
604 class char_t, class traits_t, class T, class U,
606 std::basic_ostream<char_t, traits_t> &operator<<(std::basic_ostream<char_t, traits_t> &os,
607 PositionVector3D<T, U> const &v)
608 {
609 if (os) {
610 os << "{ ";
611 for (std::size_t i = 0; i < PositionVector3D<T, U>::Scalar::Size; ++i) {
612 os << "(" << v.x()[i] << "," << v.y()[i] << "," << v.z()[i] << ") ";
613 }
614 os << "}";
615 }
616 return os;
617 } // op<< <>()
618
619 template< class char_t, class traits_t, class T, class U >
620 inline
621 std::basic_istream<char_t,traits_t> &
622 operator >> ( std::basic_istream<char_t,traits_t> & is
624 )
625 {
626 if( !is ) return is;
627
628 typename T::Scalar a, b, c;
629
633 BR::Input(is, a);
634 BR::Input(is, b);
635 BR::Input(is, c);
636 }
637 else {
639 detail::require_delim( is, detail::sep ); is >> b;
640 detail::require_delim( is, detail::sep ); is >> c;
642 }
643
644 if( is )
645 v.SetCoordinates(a, b, c);
646 return is;
647
648 } // op>> <>()
649
650
651
652
653 } // namespace Math
654
655} // namespace ROOT
656
657
658#endif /* ROOT_Math_GenVector_PositionVector3D */
#define c(i)
Definition: RSha256.hxx:101
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t dest
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 Float_t Float_t b
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 Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t src
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 Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Class describing a 3D cartesian coordinate system (x, y, z coordinates)
Definition: Cartesian3D.h:46
Class describing a generic displacement vector in 3 dimensions.
Class describing a generic position vector (point) in 3 dimensions.
PositionVector3D & operator+=(const DisplacementVector3D< OtherCoords, Tag > &v)
Self Addition with a displacement vector.
PositionVector3D(const PositionVector3D< OtherCoords, OtherTag > &)
PositionVector3D< CoordSystem, Tag > & SetZ(Scalar zz)
Change Z - Cartesian3D coordinates only.
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
PositionVector3D(const DisplacementVector3D< OtherCoords, OtherTag > &)
PositionVector3D(const ForeignVector &v)
Construct from a foreign 3D vector type, for example, Hep3Vector Precondition: v must implement metho...
Scalar Z() const
Cartesian Z, converting if necessary from internal coordinate system.
PositionVector3D< CoordSystem, Tag > & SetR(Scalar rr)
Change R - Polar3D coordinates only.
bool operator!=(const PositionVector3D &rhs) const
void GetCoordinates(Scalar dest[]) const
get internal data into a C-style array of 3 Scalar numbers
PositionVector3D< CoordSystem, Tag > & SetEta(Scalar etaval)
Change Eta - CylindricalEta3D coordinates only.
void GetCoordinates(IT begin, IT end) const
get internal data into 3 Scalars at *begin to *end (3 past begin)
PositionVector3D & operator-=(const DisplacementVector3D< OtherCoords, OtherTag > &)
PositionVector3D< CoordSystem, Tag > & SetPhi(Scalar ang)
Change Phi - Polar3D or CylindricalEta3D coordinates.
Scalar X() const
Cartesian X, converting if necessary from internal coordinate system.
PositionVector3D & operator-=(const DisplacementVector3D< OtherCoords, Tag > &v)
Self Difference with a displacement vector.
PositionVector3D< CoordSystem, Tag > & SetRho(Scalar rr)
Change Rho - CylindricalEta3D coordinates only.
PositionVector3D operator*(Scalar a) const
Multiply a vector by a real number.
PositionVector3D & operator=(const DisplacementVector3D< OtherCoords, OtherTag > &)
PositionVector3D & operator=(const PositionVector3D< OtherCoords, Tag > &v)
Assignment operator from a position vector of arbitrary type.
PositionVector3D< CoordSystem, Tag > & SetCoordinates(const Scalar src[])
Set internal data based on a C-style array of 3 Scalar numbers.
PositionVector3D & operator+=(const DisplacementVector3D< OtherCoords, OtherTag > &)
PositionVector3D< CoordSystem, Tag > & SetY(Scalar yy)
Change Y - Cartesian3D coordinates only.
PositionVector3D & operator/=(Scalar a)
divide this vector by a scalar quantity
Scalar Theta() const
Polar theta, converting if necessary from internal coordinate system.
CoordSystem::Scalar Scalar
PositionVector3D< 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...
PositionVector3D operator/(Scalar a) const
Division of a vector with a real number.
bool operator==(const PositionVector3D &rhs) const
Exact equality.
Scalar Phi() const
Polar phi, converting if necessary from internal coordinate system.
void GetCoordinates(Scalar &a, Scalar &b, Scalar &c) const
get internal data into 3 Scalar numbers
PositionVector3D< CoordSystem, Tag > & SetCoordinates(Scalar a, Scalar b, Scalar c)
Set internal data based on 3 Scalar numbers.
PositionVector3D(const DisplacementVector3D< T, Tag > &p)
Construct from an arbitrary displacement vector.
Scalar Rho() const
Cylindrical transverse component rho.
PositionVector3D Cross(const DisplacementVector3D< OtherCoords, Tag > &v) const
Return vector (Cross) product of this point with a displacement, as a point vector in this coordinate...
PositionVector3D & operator=(const PositionVector3D< OtherCoords, OtherTag > &)
Scalar Perp2() const
Transverse component squared (rho^2 in cylindrical coordinates.
Scalar Mag2() const
Magnitute squared ( r^2 in spherical coordinate)
PositionVector3D< CoordSystem, Tag > & SetTheta(Scalar ang)
Change Theta - Polar3D coordinates only.
PositionVector3D & operator*=(Scalar a)
multiply this vector by a scalar quantity
PositionVector3D()
Default constructor.
Scalar Eta() const
Polar eta, converting if necessary from internal coordinate system.
Scalar Dot(const DisplacementVector3D< OtherCoords, Tag > &v) const
Return the scalar (Dot) product of this with a displacement vector in any coordinate system,...
PositionVector3D< CoordSystem, Tag > & SetCoordinates(IT begin, IT end)
Set internal data based on 3 Scalars at *begin to *end.
PositionVector3D(const Scalar &a, const Scalar &b, const Scalar &c)
Construct from three values of type Scalar.
PositionVector3D< CoordSystem, Tag > & SetX(Scalar xx)
Change X - Cartesian3D coordinates only.
void GetCoordinates(IT begin) const
get internal data into 3 Scalars at *begin
PositionVector3D(const PositionVector3D< T, Tag > &v)
Construct from a position vector expressed in different coordinates, or using a different Scalar type...
const CoordSystem & Coordinates() const
Retrieve a copy of the coordinates object.
Scalar R() const
Polar R, converting if necessary from internal coordinate system.
Namespace for new Math classes and functions.
void(off) SmallVectorTemplateBase< T
double T(double x)
Definition: ChebyshevPol.h:34
char_t get_manip(std::basic_ios< char_t, traits_t > &ios, manip_t m)
Definition: GenVectorIO.h:54
std::basic_istream< char_t, traits_t > & require_delim(std::basic_istream< char_t, traits_t > &is, manip_t m)
Definition: GenVectorIO.h:113
void set_manip(std::basic_ios< char_t, traits_t > &ios, manip_t m, char_t ch)
Definition: GenVectorIO.h:74
std::ostream & operator<<(std::ostream &os, const AxisAngle &a)
Stream Output and Input.
Definition: AxisAngle.cxx:91
std::basic_istream< char_t, traits_t > & operator>>(std::basic_istream< char_t, traits_t > &is, DisplacementVector2D< T, U > &v)
DisplacementVector2D< CoordSystem1, U > operator+(DisplacementVector2D< CoordSystem1, U > v1, const DisplacementVector2D< CoordSystem2, U > &v2)