ATOOLS/Math/Lorentz_Ten2.H

0001 #ifndef ATOOLS_Math_Lorentz_Ten2_H
0002 #define ATOOLS_Math_Lorentz_Ten2_H
0003
0004 #include "ATOOLS/Math/MathTools.H"
0005
0006 using namespace ATOOLS;
0007
0008 namespace ATOOLS {
0009   template<typename Scalar> class Vec4;
0010
0011   template<typename Scalar>
0012   class Lorentz_Ten2 {
0013     Scalar m_x[4][4];
0014   public:
0015     inline Lorentz_Ten2() {
0016       m_x[0][0]=m_x[1][0]=m_x[2][0]=m_x[3][0]=
0017       m_x[0][1]=m_x[1][1]=m_x[2][1]=m_x[3][1]=
0018       m_x[0][2]=m_x[1][2]=m_x[2][2]=m_x[3][2]=
0019       m_x[0][3]=m_x[1][3]=m_x[2][3]=m_x[3][3]=Scalar(0.0);
0020     }
0021     template<typename Scalar2>
0022     inline Lorentz_Ten2(const Lorentz_Ten2<Scalar2>& ten) {
0023       m_x[0][0]=ten.at(0,0); m_x[1][0]=ten.at(1,0); m_x[2][0]=ten.at(2,0); m_x[3][0]=ten.at(3,0);
0024       m_x[0][1]=ten.at(0,1); m_x[1][1]=ten.at(1,1); m_x[2][1]=ten.at(2,1); m_x[3][1]=ten.at(3,1);
0025       m_x[0][2]=ten.at(0,2); m_x[1][2]=ten.at(1,2); m_x[2][2]=ten.at(2,2); m_x[3][2]=ten.at(3,2);
0026       m_x[0][3]=ten.at(0,3); m_x[1][3]=ten.at(1,3); m_x[2][3]=ten.at(2,3); m_x[3][3]=ten.at(3,3);
0027     }
0028     inline Lorentz_Ten2(const Scalar& x00, const Scalar& x10, const Scalar& x20, const Scalar& x30,
0029                 const Scalar& x01, const Scalar& x11, const Scalar& x21, const Scalar& x31,
0030                 const Scalar& x02, const Scalar& x12, const Scalar& x22, const Scalar& x32,
0031                 const Scalar& x03, const Scalar& x13, const Scalar& x23, const Scalar& x33) {
0032       m_x[0][0] = x00; m_x[1][0] = x10; m_x[2][0] = x20; m_x[3][0] = x30;
0033       m_x[0][1] = x01; m_x[1][1] = x11; m_x[2][1] = x21; m_x[3][1] = x31;
0034       m_x[0][2] = x02; m_x[1][2] = x12; m_x[2][2] = x22; m_x[3][2] = x32;
0035       m_x[0][3] = x03; m_x[1][3] = x13; m_x[2][3] = x23; m_x[3][3] = x33;
0036     }
0037     inline Lorentz_Ten2(const Scalar ten[4][4]) {
0038       for (unsigned short int i=0; i<4; ++i)
0039         for (unsigned short int j=0; j<4; ++j)
0040           m_x[i][j] = ten[i][j];
0041     }
0042
0043     // element extraction
0044     inline const Scalar at(unsigned short int i, unsigned short int j) const {
0045       return m_x[i][j];
0046     }
0047
0048     inline Scalar at(unsigned short int i, unsigned short int j) {
0049       return m_x[i][j];
0050     }
0051
0052     // sign flip
0053     inline Lorentz_Ten2<Scalar> operator-() const {
0054       return Lorentz_Ten2<Scalar>(-m_x[0][0],-m_x[1][0],-m_x[2][0],-m_x[3][0],
0055                           -m_x[0][1],-m_x[1][1],-m_x[2][1],-m_x[3][1],
0056                           -m_x[0][2],-m_x[1][2],-m_x[2][2],-m_x[3][2],
0057                           -m_x[0][3],-m_x[1][3],-m_x[2][3],-m_x[3][3]);
0058     }
0059
0060     // transpose
0061     inline Lorentz_Ten2<Scalar> Transpose() const {
0062       return Lorentz_Ten2<Scalar>(m_x[0][0],m_x[0][1],m_x[0][2],m_x[0][3],
0063                                   m_x[1][0],m_x[1][1],m_x[1][2],m_x[1][3],
0064                                   m_x[2][0],m_x[2][1],m_x[2][2],m_x[2][3],
0065                                   m_x[3][0],m_x[3][1],m_x[3][2],m_x[3][3]);
0066     }
0067
0068     // addition/subtraction operators
0069     inline Lorentz_Ten2<Scalar>& operator+=(const Lorentz_Ten2<Scalar>& t) {
0070       for (unsigned short int i=0; i<4; ++i)
0071         for (unsigned short int j=0; j<4; ++j)
0072           m_x[i][j] += t.at(i,j);
0073       return *this;
0074     }
0075
0076     inline Lorentz_Ten2<Scalar>& operator-=(const Lorentz_Ten2<Scalar>& t) {
0077       for (unsigned short int i=0; i<4; ++i)
0078         for (unsigned short int j=0; j<4; ++j)
0079           m_x[i][j] -= t.at(i,j);
0080       return *this;
0081     }
0082
0083     template<typename Scalar2> inline Lorentz_Ten2<PROMOTE(Scalar,Scalar2)>
0084     operator+ (const Lorentz_Ten2<Scalar2>& t) const {
0085       return Lorentz_Ten2<PROMOTE(Scalar,Scalar2)>
0086                 (m_x[0][0]+t.at(0,0),m_x[1][0]+t.at(1,0),
0087                                       m_x[2][0]+t.at(2,0),m_x[3][0]+t.at(3,0),
0088                  m_x[0][1]+t.at(0,1),m_x[1][1]+t.at(1,1),
0089                                       m_x[2][1]+t.at(2,1),m_x[3][1]+t.at(3,1),
0090                  m_x[0][2]+t.at(0,2),m_x[1][2]+t.at(1,2),
0091                                       m_x[2][2]+t.at(2,2),m_x[3][2]+t.at(3,2),
0092                  m_x[0][3]+t.at(0,3),m_x[1][3]+t.at(1,3),
0093                                       m_x[2][3]+t.at(2,3),m_x[3][3]+t.at(3,3));
0094     }
0095
0096     template<typename Scalar2> inline Lorentz_Ten2<PROMOTE(Scalar,Scalar2)>
0097     operator- (const Lorentz_Ten2<Scalar2>& t2) const {
0098       return Lorentz_Ten2<PROMOTE(Scalar,Scalar2)>
0099                 (m_x[0][0]-t2.at(0,0),m_x[1][0]-t2.at(1,0),
0100                                       m_x[2][0]-t2.at(2,0),m_x[3][0]-t2.at(3,0),
0101                  m_x[0][1]-t2.at(0,1),m_x[1][1]-t2.at(1,1),
0102                                       m_x[2][1]-t2.at(2,1),m_x[3][1]-t2.at(3,1),
0103                  m_x[0][2]-t2.at(0,2),m_x[1][2]-t2.at(1,2),
0104                                       m_x[2][2]-t2.at(2,2),m_x[3][2]-t2.at(3,2),
0105                  m_x[0][3]-t2.at(0,3),m_x[1][3]-t2.at(1,3),
0106                                       m_x[2][3]-t2.at(2,3),m_x[3][3]-t2.at(3,3));
0107     }
0108
0109     // multiplication operators
0110     inline Lorentz_Ten2<Scalar>& operator*= (const Scalar& scal) {
0111       for (unsigned short int i=0; i<4; ++i)
0112         for (unsigned short int j=0; j<4; ++j)
0113           m_x[i][j] *= scal;
0114       return *this;
0115     }
0116
0117     template<typename Scalar2> inline Lorentz_Ten2<PROMOTE(Scalar,Scalar2)>
0118     operator* (const Scalar2 scal) const {
0119       return Lorentz_Ten2<PROMOTE(Scalar,Scalar2)>
0120         (scal*m_x[0][0],scal*m_x[1][0],scal*m_x[2][0],scal*m_x[3][0],
0121          scal*m_x[0][1],scal*m_x[1][1],scal*m_x[2][1],scal*m_x[3][1],
0122          scal*m_x[0][2],scal*m_x[1][2],scal*m_x[2][2],scal*m_x[3][2],
0123          scal*m_x[0][3],scal*m_x[1][3],scal*m_x[2][3],scal*m_x[3][3]);
0124     }
0125
0126     template<typename Scalar2> inline Lorentz_Ten2<PROMOTE(Scalar,Scalar2)>
0127     operator/ (const Scalar2 scal) const {
0128       return (*this)*(1./scal);
0129     }
0130
0131     inline bool Nan() const {
0132       for (unsigned short int i=0; i<4; ++i)
0133         for (unsigned short int j=0; j<4; ++j)
0134           if (ATOOLS::IsNan<Scalar>(m_x[i][j])) return true;
0135       return false;
0136     }
0137
0138     inline bool IsZero() const {
0139       for (unsigned short int i=0; i<4; ++i)
0140         for (unsigned short int j=0; j<4; ++j)
0141           if (!ATOOLS::IsZero<Scalar>(m_x[i][j])) return false;
0142       return true;
0143     }
0144   };
0145
0146   template<typename Scalar,typename Scal2> inline Lorentz_Ten2<PROMOTE(Scalar,Scal2)>
0147   operator* (const Scal2 s, const Lorentz_Ten2<Scalar>& t) {
0148     return Lorentz_Ten2<PROMOTE(Scalar,Scal2)>(t*s);
0149   }
0150
0151   template<typename Scalar>
0152   std::ostream& operator<<(std::ostream& s, const Lorentz_Ten2<Scalar>& ten) {
0153     return s<<'('<<ten.at(0,0)<<','<<ten.at(1,0)<<','<<ten.at(2,0)<<','<<ten.at(3,0)<<' '<<std::endl
0154             <<' '<<ten.at(0,1)<<','<<ten.at(1,1)<<','<<ten.at(2,1)<<','<<ten.at(3,1)<<' '<<std::endl
0155             <<' '<<ten.at(0,2)<<','<<ten.at(1,2)<<','<<ten.at(2,2)<<','<<ten.at(3,2)<<' '<<std::endl
0156             <<' '<<ten.at(0,3)<<','<<ten.at(1,3)<<','<<ten.at(2,3)<<','<<ten.at(3,3)<<')'<<std::endl;
0157   }
0158 }
0159
0160 /*!
0161  \file
0162  \brief   contains class Lorentz_Ten2
0163 */
0164
0165 /*!
0166  \class Lorentz_Ten2<Scalar>
0167  \brief implementation of a 4 dimensional Minkowski 2nd rank tensor and its algebraic
0168  operations
0169
0170  This class can be used as Minkowski 2nd rank tensor with arbitrary scalar types.
0171  All necessary operations, e.g. addition, scalar multiplication, contractions
0172  with other 2nd rank tensor or vectors, etc. are available.
0173  If you want to use this 2nd rank tensor for a new scalar type, you might have to
0174  implement specific functions for this type in MathTools.H.
0175  "Fallback" types for operations with two 2nd rank tensors of different types, e. g.
0176  "complex and double become complex" have to be specified in MathTools.H as
0177  well, see the DECLARE_PROMOTE macro.
0178 */
0179
0180 /*!
0181  \fn Lorentz_Ten2::Lorentz_Ten2()
0182  \brief Standard Constructor
0183 */
0184
0185 /*!
0186  \fn Lorentz_Ten2::Lorentz_Ten2(
0187    const Scalar& x00, const Scalar& x10, const Scalar& x20, const Scalar& x30,
0188    const Scalar& x01, const Scalar& x11, const Scalar& x21, const Scalar& x31,
0189    const Scalar& x02, const Scalar& x12, const Scalar& x22, const Scalar& x32,
0190    const Scalar& x03, const Scalar& x13, const Scalar& x23, const Scalar& x33){
0191  \brief Special Constructor, templated in Scalar, taking 16 single components.
0192 */
0193
0194 #endif