ThePEG: PhysicalQtyOps.h Source File

00001 // -*- C++ -*-
00002 //
00003 // PhysicalQtyOps.h is a part of ThePEG - Toolkit for HEP Event Generation
00004 // Copyright (C) 2006-2007 David Grellscheid, Leif Lonnblad
00005 //
00006 // ThePEG is licenced under version 2 of the GPL, see COPYING for details.
00007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
00008 //
00009 #ifndef Physical_Qty_Ops_H
00010 #define Physical_Qty_Ops_H
00011 #include <cmath>
00012 
00017 namespace ThePEG {
00019 
00020 // qty = qty * qty
00021 template<int L1, int L2, int E1, int E2, int Q1, int Q2,
00022   int DL1, int DL2, int DE1, int DE2, int DQ1, int DQ2>
00023 inline Qty<L1*DL2+L2*DL1,E1*DE2+E2*DE1,Q1*DQ2+Q2*DQ1,DL1*DL2,DE1*DE2,DQ1*DQ2> 
00024 operator*(Qty<L1,E1,Q1,DL1,DE1,DQ1> q1, Qty<L2,E2,Q2,DL2,DE2,DQ2> q2) {
00025   typedef
00026     Qty<L1*DL2+L2*DL1,E1*DE2+E2*DE1,Q1*DQ2+Q2*DQ1,DL1*DL2,DE1*DE2,DQ1*DQ2> RetT;
00027   return RetT(q1.rawValue()*q2.rawValue()*RetT::baseunit());
00028 }
00029 
00030 
00031 // qty = qty / qty
00032 template<int L1, int L2, int E1, int E2, int Q1, int Q2,
00033   int DL1, int DL2, int DE1, int DE2, int DQ1, int DQ2>
00034 inline Qty<L1*DL2-L2*DL1,E1*DE2-E2*DE1,Q1*DQ2-Q2*DQ1,DL1*DL2,DE1*DE2,DQ1*DQ2> 
00035 operator/(Qty<L1,E1,Q1,DL1,DE1,DQ1> q1, Qty<L2,E2,Q2,DL2,DE2,DQ2> q2) {
00036   typedef
00037     Qty<L1*DL2-L2*DL1,E1*DE2-E2*DE1,Q1*DQ2-Q2*DQ1,DL1*DL2,DE1*DE2,DQ1*DQ2> RetT;
00038   return RetT((q1.rawValue()/q2.rawValue())*RetT::baseunit());
00039 }
00040 
00041 // qty = qty + qty
00042 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00043 inline Qty<L,E,Q,DL,DE,DQ> 
00044 operator+(Qty<L,E,Q,DL,DE,DQ> q1, 
00045           Qty<QtyInt<L,DL,DL2>::I,
00046               QtyInt<E,DE,DE2>::I,
00047               QtyInt<Q,DQ,DQ2>::I, 
00048           DL2,DE2,DQ2> q2) {
00049   Qty<L,E,Q,DL,DE,DQ> q = q1;
00050   q += q2;
00051   return q;
00052 }
00053 
00054 // qty = qty - qty
00055 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00056 inline Qty<L,E,Q,DL,DE,DQ> 
00057 operator-(Qty<L,E,Q,DL,DE,DQ> q1, 
00058           Qty<QtyInt<L,DL,DL2>::I,
00059               QtyInt<E,DE,DE2>::I,
00060               QtyInt<Q,DQ,DQ2>::I, 
00061           DL2,DE2,DQ2> q2) {
00062   Qty<L,E,Q,DL,DE,DQ> q = q1;
00063   q -= q2;
00064   return q;
00065 }
00066 
00067 // qty == qty
00068 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00069 inline bool
00070 operator==(Qty<L,E,Q,DL,DE,DQ> q1,
00071            Qty<QtyInt<L,DL,DL2>::I,
00072                QtyInt<E,DE,DE2>::I,
00073                QtyInt<Q,DQ,DQ2>::I, 
00074                DL2,DE2,DQ2> q2) {
00075   return q1.rawValue()==q2.rawValue();
00076 }
00077 
00078 // qty != qty
00079 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00080 inline bool
00081 operator!=(Qty<L,E,Q,DL,DE,DQ> q1,
00082            Qty<QtyInt<L,DL,DL2>::I,
00083                QtyInt<E,DE,DE2>::I,
00084                QtyInt<Q,DQ,DQ2>::I, 
00085                DL2,DE2,DQ2> q2) {
00086   return q1.rawValue()!=q2.rawValue();
00087 }
00088 
00089 // qty < qty
00090 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00091 inline bool
00092 operator<(Qty<L,E,Q,DL,DE,DQ> q1,
00093           Qty<QtyInt<L,DL,DL2>::I,
00094               QtyInt<E,DE,DE2>::I,
00095               QtyInt<Q,DQ,DQ2>::I, 
00096               DL2,DE2,DQ2> q2) {
00097   return q1.rawValue()<q2.rawValue();
00098 }
00099 
00100 // qty <= qty
00101 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00102 inline bool
00103 operator<=(Qty<L,E,Q,DL,DE,DQ> q1,
00104            Qty<QtyInt<L,DL,DL2>::I,
00105                QtyInt<E,DE,DE2>::I,
00106                QtyInt<Q,DQ,DQ2>::I, 
00107                DL2,DE2,DQ2> q2) {
00108   return q1.rawValue()<=q2.rawValue();
00109 }
00110 
00111 // qty > qty
00112 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00113 inline bool
00114 operator>(Qty<L,E,Q,DL,DE,DQ> q1,
00115           Qty<QtyInt<L,DL,DL2>::I,
00116               QtyInt<E,DE,DE2>::I,
00117               QtyInt<Q,DQ,DQ2>::I, 
00118               DL2,DE2,DQ2> q2) {
00119   return q1.rawValue()>q2.rawValue();
00120 }
00121 
00122 // qty >= qty
00123 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00124 inline bool
00125 operator>=(Qty<L,E,Q,DL,DE,DQ> q1,
00126            Qty<QtyInt<L,DL,DL2>::I,
00127                QtyInt<E,DE,DE2>::I,
00128                QtyInt<Q,DQ,DQ2>::I, 
00129                DL2,DE2,DQ2> q2) {
00130   return q1.rawValue()>=q2.rawValue();
00131 }
00132 
00133 // comparisons with ZERO
00134 template<int L, int E, int Q, int DL, int DE, int DQ>
00135 inline bool
00136 operator==(Qty<L,E,Q,DL,DE,DQ> q1, ZeroUnit) {
00137   return q1.rawValue() == 0.0;
00138 }
00139 template<int L, int E, int Q, int DL, int DE, int DQ>
00140 inline bool
00141 operator!=(Qty<L,E,Q,DL,DE,DQ> q1, ZeroUnit) {
00142   return q1.rawValue() != 0.0;
00143 }
00144 template<int L, int E, int Q, int DL, int DE, int DQ>
00145 inline bool
00146 operator<(Qty<L,E,Q,DL,DE,DQ> q1, ZeroUnit) {
00147   return q1.rawValue() < 0.0;
00148 }
00149 template<int L, int E, int Q, int DL, int DE, int DQ>
00150 inline bool
00151 operator>(Qty<L,E,Q,DL,DE,DQ> q1, ZeroUnit) {
00152   return q1.rawValue() > 0.0;
00153 }
00154 template<int L, int E, int Q, int DL, int DE, int DQ>
00155 inline bool
00156 operator<=(Qty<L,E,Q,DL,DE,DQ> q1, ZeroUnit) {
00157   return q1.rawValue() <= 0.0;
00158 }
00159 template<int L, int E, int Q, int DL, int DE, int DQ>
00160 inline bool
00161 operator>=(Qty<L,E,Q,DL,DE,DQ> q1, ZeroUnit) {
00162   return q1.rawValue() >= 0.0;
00163 }
00164 
00165 // qty = qty * double
00166 template<int L, int E, int Q, int DL, int DE, int DQ>
00167 inline Qty<L,E,Q,DL,DE,DQ>
00168 operator*(Qty<L,E,Q,DL,DE,DQ> q,double x) {
00169   return q*=x;
00170 }
00171 
00172 // qty = double * qty
00173 template<int L, int E, int Q, int DL, int DE, int DQ>
00174 inline Qty<L,E,Q,DL,DE,DQ>
00175 operator*(double x,Qty<L,E,Q,DL,DE,DQ> q) {
00176   return q*=x;
00177 }
00178 
00179 // qty = qty / double
00180 template<int L, int E, int Q, int DL, int DE, int DQ>
00181 inline Qty<L,E,Q,DL,DE,DQ>
00182 operator/(Qty<L,E,Q,DL,DE,DQ> q,double x) {
00183   return q/=x;
00184 }
00185 
00186 // qty = double / qty
00187 template<int L, int E, int Q, int DL, int DE, int DQ>
00188 inline Qty<-L,-E,-Q,DL,DE,DQ>
00189 operator/(double x, Qty<L,E,Q,DL,DE,DQ> q) {
00190   typedef Qty<-L,-E,-Q,DL,DE,DQ> RetT;
00191   return RetT((x/q.rawValue())*RetT::baseunit());
00192 }
00193 
00194 // qty = -qty
00195 template<int L, int E, int Q, int DL, int DE, int DQ>
00196 inline Qty<L,E,Q,DL,DE,DQ>
00197 operator-(Qty<L,E,Q,DL,DE,DQ> q) {
00198   return Qty<L,E,Q,DL,DE,DQ>(-q.rawValue()*Qty<L,E,Q,DL,DE,DQ>::baseunit());
00199 }
00200 
00201 // qty = sqr(qty)
00202 template<int L, int E, int Q, int DL, int DE, int DQ>
00203 inline Qty<2*L,2*E,2*Q,DL,DE,DQ>
00204 sqr(Qty<L,E,Q,DL,DE,DQ> q) {
00205   return q*q;
00206 }
00207 
00208 // qty = sqrt(qty)
00209 template<int L, int E, int Q, int DL, int DE, int DQ>
00210 inline Qty<L,E,Q,DL*2,DE*2,DQ*2>
00211 sqrt(Qty<L,E,Q,DL,DE,DQ> q) {
00212   typedef Qty<L,E,Q,DL*2,DE*2,DQ*2> RetT;
00213   return RetT(std::sqrt(q.rawValue())*RetT::baseunit());
00214 }
00215 
00216 // double = atan2(y,x)
00217 template<int L, int E, int Q, int DL, int DE, int DQ>
00218 inline double
00219 atan2(Qty<L,E,Q,DL,DE,DQ> y, Qty<L,E,Q,DL,DE,DQ> x) {
00220   return std::atan2(y.rawValue(), x.rawValue());
00221 }
00222 
00223 // qty = abs(qty)
00224 template<int L, int E, int Q, int DL, int DE, int DQ>
00225 inline Qty<L,E,Q,DL,DE,DQ>
00226 abs(Qty<L,E,Q,DL,DE,DQ> q) {
00227   typedef Qty<L,E,Q,DL,DE,DQ> RetT;
00228   return RetT(std::abs(q.rawValue())*RetT::baseunit());
00229 }
00230 
00231 // qty = pow<P,R>(qty)
00232 template<int P, int R, int L, int E, int Q, int DL, int DE, int DQ>
00233 Qty<P*L,P*E,P*Q,R*DL,R*DE,R*DQ> pow(Qty<L,E,Q,DL,DE,DQ> q) {
00234   typedef Qty<P*L,P*E,P*Q,R*DL,R*DE,R*DQ> RetT;
00235   return RetT(std::pow(q.rawValue(),double(P)/double(R))*RetT::baseunit());
00236 }
00237   
00238 
00239 // max(qty,qty)
00240 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00241 inline Qty<L,E,Q,DL,DE,DQ> 
00242 max(Qty<L,E,Q,DL,DE,DQ> q1, 
00243     Qty<QtyInt<L,DL,DL2>::I,
00244     QtyInt<E,DE,DE2>::I,
00245     QtyInt<Q,DQ,DQ2>::I, 
00246     DL2,DE2,DQ2> q2) {
00247   return q1.rawValue() < q2.rawValue() ? Qty<L,E,Q,DL,DE,DQ>(q2) : q1;
00248 }
00249 template<int L, int E, int Q, int DL, int DE, int DQ>
00250 inline Qty<L,E,Q,DL,DE,DQ> 
00251 max(Qty<L,E,Q,DL,DE,DQ> q1, 
00252     Qty<L,E,Q,DL,DE,DQ> q2) { 
00253   return q1.rawValue() < q2.rawValue() ? q2 : q1;
00254 }
00255 template<int L, int E, int Q, int DL, int DE, int DQ>
00256 inline Qty<L,E,Q,DL,DE,DQ> 
00257 max(Qty<L,E,Q,DL,DE,DQ> q1, ZeroUnit) {
00258   return q1.rawValue() < 0.0 ? ZERO : q1;
00259 }
00260 template<int L, int E, int Q, int DL, int DE, int DQ>
00261 inline Qty<L,E,Q,DL,DE,DQ> 
00262 max(ZeroUnit, Qty<L,E,Q,DL,DE,DQ> q1) {
00263   return q1.rawValue() < 0.0 ? ZERO : q1;
00264 }
00265 template<int DL, int DE, int DQ>
00266 inline double
00267 max(double q1, 
00268     Qty<0,0,0,DL,DE,DQ> q2) { 
00269   return q1 < q2.rawValue() ? double(q2) : q1;
00270 }
00271 template<int DL, int DE, int DQ>
00272 inline double
00273 max(Qty<0,0,0,DL,DE,DQ> q1, 
00274     double q2) { 
00275   return q1.rawValue() < q2 ? q2 : double(q1);
00276 }
00277 
00278 // min(qty,qty)
00279 template<int L, int E, int Q, int DL, int DE, int DQ, int DL2, int DE2, int DQ2>
00280 inline Qty<L,E,Q,DL,DE,DQ> 
00281 min(Qty<L,E,Q,DL,DE,DQ> q1, 
00282     Qty<QtyInt<L,DL,DL2>::I,
00283     QtyInt<E,DE,DE2>::I,
00284     QtyInt<Q,DQ,DQ2>::I, 
00285     DL2,DE2,DQ2> q2) {
00286   return q1.rawValue() < q2.rawValue() ? q1 : Qty<L,E,Q,DL,DE,DQ>(q2);
00287 }
00288 template<int L, int E, int Q, int DL, int DE, int DQ>
00289 inline Qty<L,E,Q,DL,DE,DQ> 
00290 min(Qty<L,E,Q,DL,DE,DQ> q1, 
00291     Qty<L,E,Q,DL,DE,DQ> q2) { 
00292   return q1.rawValue() < q2.rawValue() ? q1 : q2;
00293 }
00294 template<int L, int E, int Q, int DL, int DE, int DQ>
00295 inline Qty<L,E,Q,DL,DE,DQ> 
00296 min(Qty<L,E,Q,DL,DE,DQ> q1, ZeroUnit) {
00297   return q1.rawValue() > 0.0 ? ZERO : q1;
00298 }
00299 template<int L, int E, int Q, int DL, int DE, int DQ>
00300 inline Qty<L,E,Q,DL,DE,DQ> 
00301 min(ZeroUnit, Qty<L,E,Q,DL,DE,DQ> q1) {
00302   return q1.rawValue() > 0.0 ? ZERO : q1;
00303 }
00304 template<int DL, int DE, int DQ>
00305 inline double
00306 min(double q1, 
00307     Qty<0,0,0,DL,DE,DQ> q2) { 
00308   return q1 < q2.rawValue() ? q1 : double(q2);
00309 }
00310 template<int DL, int DE, int DQ>
00311 inline double
00312 min(Qty<0,0,0,DL,DE,DQ> q1, 
00313     double q2) { 
00314   return q1.rawValue() < q2 ? double(q1) : q2;
00315 }
00317 }
00318 
00319 #endif