ROOT   Reference Guide
DisplacementVector3D.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 and *
7 * FNAL LCG ROOT MathLib Team *
8 * *
9 * *
10 **********************************************************************/
11
12// Header source file for class DisplacementVector3D
13//
14// Created by: Lorenzo Moneta at Mon May 30 12:21:43 2005
15// Major rewrite: M. FIschler at Wed Jun 8 2005
16//
17// Last update: $Id$
18//
19
20#ifndef ROOT_Math_GenVector_DisplacementVector3D
21#define ROOT_Math_GenVector_DisplacementVector3D 1
22
24
26
28
30
32
33#include <cassert>
34
35//doxygen tag
36/**
37 @defgroup GenVector GenVector
38 Generic 2D, 3D and 4D vectors classes and their transformations (rotations). More information is available at the
40
41 @ingroup Math
42 */
43
44
45
46
47namespace ROOT {
48
49 namespace Math {
50
51
52//__________________________________________________________________________________________
53 /**
54 Class describing a generic displacement vector in 3 dimensions.
55 This class is templated on the type of Coordinate system.
56 One example is the XYZVector which is a vector based on
57 double precision x,y,z data members by using the
58 ROOT::Math::Cartesian3D<double> Coordinate system.
59 The class is having also an extra template parameter, the coordinate system tag,
60 to be able to identify (tag) vector described in different reference coordinate system,
61 like global or local coordinate systems.
62
63 @ingroup GenVector
64 */
65
66 template <class CoordSystem, class Tag = DefaultCoordinateSystemTag >
68
69 public:
70
71 typedef typename CoordSystem::Scalar Scalar;
72 typedef CoordSystem CoordinateType;
74
75 // ------ ctors ------
76
77 /**
78 Default constructor. Construct an empty object with zero values
79 */
81
82
83 /**
84 Construct from three values of type <em>Scalar</em>.
85 In the case of a XYZVector the values are x,y,z
86 In the case of a polar vector they are r,theta, phi
87 */
89 fCoordinates ( a , b, c ) { }
90
91 /**
92 Construct from a displacement vector expressed in different
93 coordinates, or using a different Scalar type, but with same coordinate system tag
94 */
95 template <class OtherCoords>
97 fCoordinates ( v.Coordinates() ) { }
98
99
100 /**
101 Construct from a position vector expressed in different coordinates
102 but with the same coordinate system tag
103 */
104 template <class OtherCoords>
106 fCoordinates ( p.Coordinates() ) { }
107
108
109 /**
110 Construct from a foreign 3D vector type, for example, Hep3Vector
111 Precondition: v must implement methods x(), y() and z()
112 */
113 template <class ForeignVector>
114 explicit DisplacementVector3D( const ForeignVector & v) :
115 fCoordinates ( Cartesian3D<Scalar>( v.x(), v.y(), v.z() ) ) { }
116
117
118#ifdef LATER
119 /**
120 construct from a generic linear algebra vector of at least size 3
121 implementing operator [].
122 \par v LAVector
123 \par index0 index where coordinates starts (typically zero)
124 It works for all Coordinates types,
125 ( x= v[index0] for Cartesian and r=v[index0] for Polar )
126 */
127 template <class LAVector>
128 DisplacementVector3D(const LAVector & v, size_t index0 ) {
129 fCoordinates = CoordSystem ( v[index0], v[index0+1], v[index0+2] );
130 }
131#endif
132
133 // compiler-generated copy ctor and dtor are fine.
134
135 // ------ assignment ------
136
137 /**
138 Assignment operator from a displacement vector of arbitrary type
139 */
140 template <class OtherCoords>
143 fCoordinates = v.Coordinates();
144 return *this;
145 }
146
147 /**
148 Assignment operator from a position vector
149 (not necessarily efficient unless one or the other is Cartesian)
150 */
151 template <class OtherCoords>
153 ( const PositionVector3D<OtherCoords,Tag> & rhs) {
154 SetXYZ(rhs.x(), rhs.y(), rhs.z());
155 return *this;
156 }
157
158
159 /**
160 Assignment from a foreign 3D vector type, for example, Hep3Vector
161 Precondition: v must implement methods x(), y() and z()
162 */
163 template <class ForeignVector>
164 DisplacementVector3D & operator= ( const ForeignVector & v) {
165 SetXYZ( v.x(), v.y(), v.z() );
166 return *this;
167 }
168
169
170#ifdef LATER
171 /**
172 assign from a generic linear algebra vector of at least size 3
173 implementing operator []. This could be also a C array
174 \par v LAVector
175 \par index0 index where coordinates starts (typically zero)
176 It works for all Coordinates types,
177 ( x= v[index0] for Cartesian and r=v[index0] for Polar )
178 */
179 template <class LAVector>
180 DisplacementVector3D & assignFrom(const LAVector & v, size_t index0 = 0) {
181 fCoordinates = CoordSystem ( v[index0], v[index0+1], v[index0+2] );
182 return *this;
183 }
184#endif
185
186 // ------ Set, Get, and access coordinate data ------
187
188 /**
189 Retrieve a copy of the coordinates object
190 */
191 CoordSystem Coordinates() const {
192 return fCoordinates;
193 }
194
195 /**
196 Set internal data based on a C-style array of 3 Scalar numbers
197 */
199 { fCoordinates.SetCoordinates(src); return *this; }
200
201 /**
202 Set internal data based on 3 Scalar numbers
203 */
205 { fCoordinates.SetCoordinates(a, b, c); return *this; }
206
207 /**
208 Set internal data based on 3 Scalars at *begin to *end
209 */
210 template <class IT>
212 { IT a = begin; IT b = ++begin; IT c = ++begin;
213 (void)end;
214 assert (++begin==end);
215 SetCoordinates (*a,*b,*c);
216 return *this;
217 }
218
219 /**
220 get internal data into 3 Scalar numbers
221 */
222 void GetCoordinates( Scalar& a, Scalar& b, Scalar& c ) const
223 { fCoordinates.GetCoordinates(a, b, c); }
224
225 /**
226 get internal data into a C-style array of 3 Scalar numbers
227 */
228 void GetCoordinates( Scalar dest[] ) const
229 { fCoordinates.GetCoordinates(dest); }
230
231 /**
232 get internal data into 3 Scalars at *begin to *end (3 past begin)
233 */
234 template <class IT>
235 void GetCoordinates( IT begin, IT end ) const
236 { IT a = begin; IT b = ++begin; IT c = ++begin;
237 (void)end;
238 assert (++begin==end);
239 GetCoordinates (*a,*b,*c);
240 }
241 /**
242 get internal data into 3 Scalars starting at *begin
243 */
244 template <class IT>
245 void GetCoordinates( IT begin) const {
246 Scalar a = Scalar(0);
247 Scalar b = Scalar(0);
248 Scalar c = Scalar(0);
249 GetCoordinates(a, b, c);
250 *begin++ = a;
251 *begin++ = b;
252 *begin = c;
253 }
254
255 /**
256 set the values of the vector from the cartesian components (x,y,z)
257 (if the vector is held in polar or cylindrical eta coordinates,
258 then (x, y, z) are converted to that form)
259 */
261 fCoordinates.SetXYZ(a, b, c);
262 return *this;
263 }
264
265 // ------------------- Equality -----------------
266
267 /**
268 Exact equality
269 */
270 bool operator==(const DisplacementVector3D & rhs) const {
271 return fCoordinates==rhs.fCoordinates;
272 }
273 bool operator!= (const DisplacementVector3D & rhs) const {
274 return !(operator==(rhs));
275 }
276
277 // ------ Individual element access, in various coordinate systems ------
278
279 /**
280 Cartesian X, converting if necessary from internal coordinate system.
281 */
282 Scalar X() const { return fCoordinates.X(); }
283
284 /**
285 Cartesian Y, converting if necessary from internal coordinate system.
286 */
287 Scalar Y() const { return fCoordinates.Y(); }
288
289 /**
290 Cartesian Z, converting if necessary from internal coordinate system.
291 */
292 Scalar Z() const { return fCoordinates.Z(); }
293
294 /**
295 Polar R, converting if necessary from internal coordinate system.
296 */
297 Scalar R() const { return fCoordinates.R(); }
298
299 /**
300 Polar theta, converting if necessary from internal coordinate system.
301 */
302 Scalar Theta() const { return fCoordinates.Theta(); }
303
304 /**
305 Polar phi, converting if necessary from internal coordinate system.
306 */
307 Scalar Phi() const { return fCoordinates.Phi(); }
308
309 /**
310 Polar eta, converting if necessary from internal coordinate system.
311 */
312 Scalar Eta() const { return fCoordinates.Eta(); }
313
314 /**
315 Cylindrical transverse component rho
316 */
317 Scalar Rho() const { return fCoordinates.Rho(); }
318
319 // ----- Other fundamental properties -----
320
321 /**
322 Magnitute squared ( r^2 in spherical coordinate)
323 */
324 Scalar Mag2() const { return fCoordinates.Mag2();}
325
326 /**
327 Transverse component squared (rho^2 in cylindrical coordinates.
328 */
329 Scalar Perp2() const { return fCoordinates.Perp2();}
330
331 /**
332 return unit vector parallel to this (scalar)
333 */
334 template <typename SCALAR = Scalar, typename std::enable_if<std::is_arithmetic<SCALAR>::value>::type * = nullptr>
336 {
337 const auto tot = R();
339 }
340
341 /**
342 return unit vector parallel to this (vector)
343 */
344 template <typename SCALAR = Scalar, typename std::enable_if<!std::is_arithmetic<SCALAR>::value>::type * = nullptr>
346 {
347 SCALAR tot = R();
348 tot(tot == SCALAR(0)) = SCALAR(1);
349 return DisplacementVector3D(*this) / tot;
350 }
351
352 // ------ Setting of individual elements present in coordinate system ------
353
354 /**
355 Change X - Cartesian3D coordinates only
356 */
358
359 /**
360 Change Y - Cartesian3D coordinates only
361 */
363
364 /**
365 Change Z - Cartesian3D coordinates only
366 */
368
369 /**
370 Change R - Polar3D coordinates only
371 */
373
374 /**
375 Change Theta - Polar3D coordinates only
376 */
378
379 /**
380 Change Phi - Polar3D or CylindricalEta3D coordinates
381 */
383
384 /**
385 Change Rho - CylindricalEta3D coordinates only
386 */
388
389 /**
390 Change Eta - CylindricalEta3D coordinates only
391 */
392 DisplacementVector3D<CoordSystem, Tag>& SetEta (Scalar etaval) { fCoordinates.SetEta(etaval); return *this;}
393
394
395 // ------ Operations combining two vectors ------
396 // -- need to have the specialized version in order to avoid
397
398 /**
399 Return the scalar (dot) product of two displacement vectors.
400 It is possible to perform the product for any type of vector coordinates,
401 but they must have the same coordinate system tag
402 */
403 template< class OtherCoords >
405 return X()*v.X() + Y()*v.Y() + Z()*v.Z();
406 }
407 /**
408 Return the scalar (dot) product of two vectors.
409 It is possible to perform the product for any classes
410 implementing x(), y() and z() member functions
411 */
412 template< class OtherVector >
413 Scalar Dot( const OtherVector & v) const {
414 return X()*v.x() + Y()*v.y() + Z()*v.z();
415 }
416
417 /**
418 Return vector (cross) product of two displacement vectors,
419 as a vector in the coordinate system of this class.
420 It is possible to perform the product for any type of vector coordinates,
421 but they must have the same coordinate system tag
422 */
423 template <class OtherCoords>
426 result.SetXYZ ( Y()*v.Z() - v.Y()*Z(),
427 Z()*v.X() - v.Z()*X(),
428 X()*v.Y() - v.X()*Y() );
429 return result;
430 }
431 /**
432 Return vector (cross) product of two vectors,
433 as a vector in the coordinate system of this class.
434 It is possible to perform the product for any classes
435 implementing X(), Y() and Z() member functions
436 */
437 template <class OtherVector>
438 DisplacementVector3D Cross( const OtherVector & v) const {
440 result.SetXYZ ( Y()*v.z() - v.y()*Z(),
441 Z()*v.x() - v.z()*X(),
442 X()*v.y() - v.x()*Y() );
443 return result;
444 }
445
446
447
448 /**
449 Self Addition with a displacement vector.
450 */
451 template <class OtherCoords>
454 SetXYZ( X() + v.X(), Y() + v.Y(), Z() + v.Z() );
455 return *this;
456 }
457
458 /**
459 Self Difference with a displacement vector.
460 */
461 template <class OtherCoords>
464 SetXYZ( x() - v.x(), y() - v.y(), z() - v.z() );
465 return *this;
466 }
467
468
469 /**
470 multiply this vector by a scalar quantity
471 */
473 fCoordinates.Scale(a);
474 return *this;
475 }
476
477 /**
478 divide this vector by a scalar quantity
479 */
481 fCoordinates.Scale(1/a);
482 return *this;
483 }
484
485 // The following methods (v*a and v/a) could instead be free functions.
486 // They were moved into the class to solve a problem on AIX.
487
488 /**
489 Multiply a vector by a real number
490 */
492 DisplacementVector3D tmp(*this);
493 tmp *= a;
494 return tmp;
495 }
496
497 /**
498 Negative of the vector
499 */
501 return operator*( Scalar(-1) );
502 }
503
504 /**
505 Positive of the vector, return itself
506 */
507 DisplacementVector3D operator + ( ) const {return *this;}
508
509 /**
510 Division of a vector with a real number
511 */
513 DisplacementVector3D tmp(*this);
514 tmp /= a;
515 return tmp;
516 }
517
518
519 // Methods providing limited backward name compatibility with CLHEP
520
521 Scalar x() const { return fCoordinates.X(); }
522 Scalar y() const { return fCoordinates.Y(); }
523 Scalar z() const { return fCoordinates.Z(); }
524 Scalar r() const { return fCoordinates.R(); }
525 Scalar theta() const { return fCoordinates.Theta(); }
526 Scalar phi() const { return fCoordinates.Phi(); }
527 Scalar eta() const { return fCoordinates.Eta(); }
528 Scalar rho() const { return fCoordinates.Rho(); }
529 Scalar mag2() const { return fCoordinates.Mag2(); }
530 Scalar perp2() const { return fCoordinates.Perp2(); }
531 DisplacementVector3D unit() const {return Unit();}
532
533
534 private:
535
536 CoordSystem fCoordinates; // internal coordinate system
537
538#ifdef NOT_SURE_THIS_SHOULD_BE_FORBIDDEN
539 /**
540 Cross product involving a position vector is inappropriate
541 */
542 template <class T2>
544#endif
545
546 // the following methods should not compile
547
548 // this should not compile (if from a vector or points with different tag
549 template <class OtherCoords, class OtherTag>
551
552 template <class OtherCoords, class OtherTag>
554
555 template <class OtherCoords, class OtherTag>
557
558
559 template <class OtherCoords, class OtherTag>
561
562 template <class OtherCoords, class OtherTag>
564
565 template <class OtherCoords, class OtherTag>
567
568 template<class OtherCoords, class OtherTag >
570
571 template<class OtherCoords, class OtherTag >
573
574
575 };
576
577// ---------- DisplacementVector3D class template ends here ------------
578// ---------------------------------------------------------------------
579
580
581
582 /**
584 The (coordinate system) type of the returned vector is defined to
585 be identical to that of the first vector, which is passed by value
586 */
587 template <class CoordSystem1, class CoordSystem2, class U>
588 inline
592 return v1 += v2;
593 }
594
595 /**
596 Difference between two DisplacementVector3D vectors.
597 The (coordinate system) type of the returned vector is defined to
598 be identical to that of the first vector.
599 */
600 template <class CoordSystem1, class CoordSystem2, class U>
601 inline
602 DisplacementVector3D<CoordSystem1,U>
605 return v1 -= v2;
606 }
607
608 //#endif // not __CINT__
609
610 /**
611 Multiplication of a displacement vector by real number a*v
612 */
613 template <class CoordSystem, class U>
614 inline
615 DisplacementVector3D<CoordSystem,U>
618 return v *= a;
619 // Note - passing v by value and using operator *= may save one
620 // copy relative to passing v by const ref and creating a temporary.
621 }
622
623
624 // v1*v2 notation for Cross product of two vectors is omitted,
625 // since it is always confusing as to whether dot product is meant.
626
627
628
629 // ------------- I/O to/from streams -------------
630
631 template <class char_t, class traits_t, class T, class U,
633 nullptr>
634 std::basic_ostream<char_t, traits_t> &operator<<(std::basic_ostream<char_t, traits_t> &os,
635 DisplacementVector3D<T, U> const &v)
636 {
637 if (os) {
638
639 typename T::Scalar a, b, c;
640 v.GetCoordinates(a, b, c);
641
644 typedef GenVector_detail::BitReproducible BR;
645 BR::Output(os, a);
646 BR::Output(os, b);
647 BR::Output(os, c);
648 } else {
651 }
652 }
653 return os;
654 } // op<< <>()
655
656 template <class char_t, class traits_t, class T, class U,
658 nullptr>
659 std::basic_ostream<char_t, traits_t> &operator<<(std::basic_ostream<char_t, traits_t> &os,
660 DisplacementVector3D<T, U> const &v)
661 {
662 if (os) {
663 os << "{ ";
664 for (std::size_t i = 0; i < PositionVector3D<T, U>::Scalar::Size; ++i) {
665 os << "(" << v.x()[i] << "," << v.y()[i] << "," << v.z()[i] << ") ";
666 }
667 os << "}";
668 }
669 return os;
670 } // op<< <>()
671
672 template< class char_t, class traits_t, class T, class U >
673 inline
674 std::basic_istream<char_t,traits_t> &
675 operator >> ( std::basic_istream<char_t,traits_t> & is
677 )
678 {
679 if( !is ) return is;
680
681 typename T::Scalar a, b, c;
682
686 BR::Input(is, a);
687 BR::Input(is, b);
688 BR::Input(is, c);
689 }
690 else {
692 detail::require_delim( is, detail::sep ); is >> b;
693 detail::require_delim( is, detail::sep ); is >> c;
695 }
696
697 if( is )
698 v.SetCoordinates(a, b, c);
699 return is;
700
701 } // op>> <>()
702
703
704
705 } // namespace Math
706
707} // namespace ROOT
708
709
710#endif /* ROOT_Math_GenVector_DisplacementVector3D */
711
#define b(i)
Definition: RSha256.hxx:100
#define c(i)
Definition: RSha256.hxx:101
int type
Definition: TGX11.cxx:120
typedef void((*Func_t)())
Class describing a 3D cartesian coordinate system (x, y, z coordinates)
Definition: Cartesian3D.h:44
Class describing a generic displacement vector in 3 dimensions.
DisplacementVector3D< CoordSystem, Tag > & SetCoordinates(IT begin, IT end)
Set internal data based on 3 Scalars at *begin to *end.
Scalar Theta() const
Polar theta, converting if necessary from internal coordinate system.
DisplacementVector3D & operator-=(const DisplacementVector3D< OtherCoords, OtherTag > &)
CoordSystem Coordinates() const
Retrieve a copy of the coordinates object.
DisplacementVector3D< CoordSystem, Tag > & SetRho(Scalar rr)
Change Rho - CylindricalEta3D coordinates only.
DisplacementVector3D & operator=(const DisplacementVector3D< OtherCoords, Tag > &v)
Assignment operator from a displacement vector of arbitrary type.
DisplacementVector3D & operator+=(const DisplacementVector3D< OtherCoords, OtherTag > &)
DisplacementVector3D< CoordSystem, Tag > & SetEta(Scalar etaval)
Change Eta - CylindricalEta3D coordinates only.
Scalar R() const
Polar R, converting if necessary from internal coordinate system.
DisplacementVector3D & operator/=(Scalar a)
divide this vector by a scalar quantity
DisplacementVector3D< CoordSystem, Tag > & SetPhi(Scalar ang)
Change Phi - Polar3D or CylindricalEta3D coordinates.
DisplacementVector3D< CoordSystem, Tag > & SetR(Scalar rr)
Change R - Polar3D coordinates only.
DisplacementVector3D Cross(const OtherVector &v) const
Return vector (cross) product of two vectors, as a vector in the coordinate system of this class.
DisplacementVector3D Unit() const
return unit vector parallel to this (scalar)
DisplacementVector3D operator+() const
Positive of the vector, return itself.
DisplacementVector3D operator-() const
Negative of the vector.
DisplacementVector3D< CoordSystem, Tag > & SetCoordinates(Scalar a, Scalar b, Scalar c)
Set internal data based on 3 Scalar numbers.
DisplacementVector3D< CoordSystem, Tag > & SetY(Scalar yy)
Change Y - Cartesian3D coordinates only.
Scalar X() const
Cartesian X, converting if necessary from internal coordinate system.
DisplacementVector3D< CoordSystem, Tag > & SetZ(Scalar zz)
Change Z - Cartesian3D coordinates only.
void GetCoordinates(Scalar dest[]) const
get internal data into a C-style array of 3 Scalar numbers
DisplacementVector3D(const PositionVector3D< OtherCoords, OtherTag > &)
void GetCoordinates(Scalar &a, Scalar &b, Scalar &c) const
get internal data into 3 Scalar numbers
void GetCoordinates(IT begin) const
get internal data into 3 Scalars starting at *begin
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
DisplacementVector3D(const PositionVector3D< OtherCoords, Tag > &p)
Construct from a position vector expressed in different coordinates but with the same coordinate syst...
Scalar Dot(const OtherVector &v) const
Return the scalar (dot) product of two vectors.
DisplacementVector3D Cross(const DisplacementVector3D< OtherCoords, Tag > &v) const
Return vector (cross) product of two displacement vectors, as a vector in the coordinate system of th...
DisplacementVector3D< CoordSystem, Tag > & SetTheta(Scalar ang)
Change Theta - Polar3D coordinates only.
DisplacementVector3D operator*(Scalar a) const
Multiply a vector by a real number.
bool operator==(const DisplacementVector3D &rhs) const
Exact equality.
Scalar Rho() const
Cylindrical transverse component rho.
DisplacementVector3D Cross(const DisplacementVector3D< OtherCoords, OtherTag > &) const
bool operator!=(const DisplacementVector3D &rhs) const
DisplacementVector3D unit() const
DisplacementVector3D()
Default constructor.
DisplacementVector3D< CoordSystem, Tag > & SetCoordinates(const Scalar src[])
Set internal data based on a C-style array of 3 Scalar numbers.
DisplacementVector3D(Scalar a, Scalar b, Scalar c)
Construct from three values of type Scalar.
DisplacementVector3D(const ForeignVector &v)
Construct from a foreign 3D vector type, for example, Hep3Vector Precondition: v must implement metho...
DisplacementVector3D & operator=(const PositionVector3D< OtherCoords, OtherTag > &)
Scalar Dot(const DisplacementVector3D< OtherCoords, OtherTag > &) const
Scalar Phi() const
Polar phi, converting if necessary from internal coordinate system.
DisplacementVector3D< CoordSystem, Tag > & SetX(Scalar xx)
Change X - Cartesian3D coordinates only.
Scalar Mag2() const
Magnitute squared ( r^2 in spherical coordinate)
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 Perp2() const
Transverse component squared (rho^2 in cylindrical coordinates.
DisplacementVector3D & operator*=(Scalar a)
multiply this vector by a scalar quantity
DisplacementVector3D operator/(Scalar a) const
Division of a vector with a real number.
Scalar Eta() const
Polar eta, converting if necessary from internal coordinate system.
Scalar Z() const
Cartesian Z, converting if necessary from internal coordinate system.
DisplacementVector3D(const DisplacementVector3D< OtherCoords, Tag > &v)
Construct from a displacement vector expressed in different coordinates, or using a different Scalar ...
void GetCoordinates(IT begin, IT end) const
get internal data into 3 Scalars at *begin to *end (3 past begin)
DisplacementVector3D(const DisplacementVector3D< OtherCoords, OtherTag > &)
Scalar Dot(const DisplacementVector3D< OtherCoords, Tag > &v) const
Return the scalar (dot) product of two displacement vectors.
DisplacementVector3D & operator=(const DisplacementVector3D< OtherCoords, OtherTag > &)
Class describing a generic position vector (point) in 3 dimensions.
Namespace for new Math classes and functions.
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)