ROOT_528-00b_version: include/TMathBase.h Source File

00001 // @(#)root/base:$Id: TMathBase.h 20877 2007-11-19 11:17:07Z rdm $
00002 // Authors: Rene Brun, Fons Rademakers   29/07/95
00003 
00004 /*************************************************************************
00005  * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
00006  * All rights reserved.                                                  *
00007  *                                                                       *
00008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
00009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
00010  *************************************************************************/
00011 
00012 #ifndef ROOT_TMathBase
00013 #define ROOT_TMathBase
00014 
00015 
00016 //////////////////////////////////////////////////////////////////////////
00017 //                                                                      //
00018 // TMath Base functions                                                 //
00019 //                                                                      //
00020 // Define the functions Min, Max, Abs, Sign, Range for all types.       //
00021 // NB: These functions are unfortunately not available in a portable    //
00022 // way in std::.                                                        //
00023 //                                                                      //
00024 // More functions are defined in TMath.h. TMathBase.h is designed to be //
00025 // a stable file and used in place of TMath.h in the ROOT miniCore.     //
00026 //                                                                      //
00027 //////////////////////////////////////////////////////////////////////////
00028 
00029 #ifndef ROOT_Rtypes
00030 #include "Rtypes.h"
00031 #endif
00032 
00033 namespace TMath {
00034 
00035    // Abs
00036    inline Short_t  Abs(Short_t d);
00037    inline Int_t    Abs(Int_t d);
00038    inline Long_t   Abs(Long_t d);
00039    inline Long64_t Abs(Long64_t d);
00040    inline Float_t  Abs(Float_t d);
00041    inline Double_t Abs(Double_t d);
00042 
00043    // Even/Odd
00044    inline Bool_t   Even(Long_t a);
00045    inline Bool_t   Odd(Long_t a);
00046 
00047    // Sign
00048    inline Short_t  Sign(Short_t a, Short_t b);
00049    inline Int_t    Sign(Int_t a, Int_t b);
00050    inline Long_t   Sign(Long_t a, Long_t b);
00051    inline Long64_t Sign(Long64_t a, Long64_t b);
00052    inline Float_t  Sign(Float_t a, Float_t b);
00053    inline Double_t Sign(Double_t a, Double_t b);
00054 
00055    // Min, Max of two scalars
00056    inline Short_t   Min(Short_t a, Short_t b);
00057    inline UShort_t  Min(UShort_t a, UShort_t b);
00058    inline Int_t     Min(Int_t a, Int_t b);
00059    inline UInt_t    Min(UInt_t a, UInt_t b);
00060    inline Long_t    Min(Long_t a, Long_t b);
00061    inline ULong_t   Min(ULong_t a, ULong_t b);
00062    inline Long64_t  Min(Long64_t a, Long64_t b);
00063    inline ULong64_t Min(ULong64_t a, ULong64_t b);
00064    inline Float_t   Min(Float_t a, Float_t b);
00065    inline Double_t  Min(Double_t a, Double_t b);
00066 
00067    inline Short_t   Max(Short_t a, Short_t b);
00068    inline UShort_t  Max(UShort_t a, UShort_t b);
00069    inline Int_t     Max(Int_t a, Int_t b);
00070    inline UInt_t    Max(UInt_t a, UInt_t b);
00071    inline Long_t    Max(Long_t a, Long_t b);
00072    inline ULong_t   Max(ULong_t a, ULong_t b);
00073    inline Long64_t  Max(Long64_t a, Long64_t b);
00074    inline ULong64_t Max(ULong64_t a, ULong64_t b);
00075    inline Float_t   Max(Float_t a, Float_t b);
00076    inline Double_t  Max(Double_t a, Double_t b);
00077 
00078    // Range
00079    inline Short_t   Range(Short_t lb, Short_t ub, Short_t x);
00080    inline Int_t     Range(Int_t lb, Int_t ub, Int_t x);
00081    inline Long_t    Range(Long_t lb, Long_t ub, Long_t x);
00082    inline ULong_t   Range(ULong_t lb, ULong_t ub, ULong_t x);
00083    inline Double_t  Range(Double_t lb, Double_t ub, Double_t x);
00084 
00085    //NextPrime is used by the Core classes.
00086    Long_t   NextPrime(Long_t x);   // Least prime number greater than x
00087 }
00088 
00089 
00090 //---- Even/odd ----------------------------------------------------------------
00091 
00092 inline Bool_t TMath::Even(Long_t a)
00093    { return ! (a & 1); }
00094 
00095 inline Bool_t TMath::Odd(Long_t a)
00096    { return (a & 1); }
00097 
00098 //---- Abs ---------------------------------------------------------------------
00099 
00100 inline Short_t TMath::Abs(Short_t d)
00101    { return (d >= 0) ? d : -d; }
00102 
00103 inline Int_t TMath::Abs(Int_t d)
00104    { return (d >= 0) ? d : -d; }
00105 
00106 inline Long_t TMath::Abs(Long_t d)
00107    { return (d >= 0) ? d : -d; }
00108 
00109 inline Long64_t TMath::Abs(Long64_t d)
00110    { return (d >= 0) ? d : -d; }
00111 
00112 inline Float_t TMath::Abs(Float_t d)
00113    { return (d >= 0) ? d : -d; }
00114 
00115 inline Double_t TMath::Abs(Double_t d)
00116    { return (d >= 0) ? d : -d; }
00117 
00118 //---- Sign --------------------------------------------------------------------
00119 
00120 inline Short_t TMath::Sign(Short_t a, Short_t b)
00121    { return (b >= 0) ? Abs(a) : -Abs(a); }
00122 
00123 inline Int_t TMath::Sign(Int_t a, Int_t b)
00124    { return (b >= 0) ? Abs(a) : -Abs(a); }
00125 
00126 inline Long_t TMath::Sign(Long_t a, Long_t b)
00127    { return (b >= 0) ? Abs(a) : -Abs(a); }
00128 
00129 inline Long64_t TMath::Sign(Long64_t a, Long64_t b)
00130    { return (b >= 0) ? Abs(a) : -Abs(a); }
00131 
00132 inline Float_t TMath::Sign(Float_t a, Float_t b)
00133    { return (b >= 0) ? Abs(a) : -Abs(a); }
00134 
00135 inline Double_t TMath::Sign(Double_t a, Double_t b)
00136    { return (b >= 0) ? Abs(a) : -Abs(a); }
00137 
00138 //---- Min ---------------------------------------------------------------------
00139 
00140 inline Short_t TMath::Min(Short_t a, Short_t b)
00141    { return a <= b ? a : b; }
00142 
00143 inline UShort_t TMath::Min(UShort_t a, UShort_t b)
00144    { return a <= b ? a : b; }
00145 
00146 inline Int_t TMath::Min(Int_t a, Int_t b)
00147    { return a <= b ? a : b; }
00148 
00149 inline UInt_t TMath::Min(UInt_t a, UInt_t b)
00150    { return a <= b ? a : b; }
00151 
00152 inline Long_t TMath::Min(Long_t a, Long_t b)
00153    { return a <= b ? a : b; }
00154 
00155 inline ULong_t TMath::Min(ULong_t a, ULong_t b)
00156    { return a <= b ? a : b; }
00157 
00158 inline Long64_t TMath::Min(Long64_t a, Long64_t b)
00159    { return a <= b ? a : b; }
00160 
00161 inline ULong64_t TMath::Min(ULong64_t a, ULong64_t b)
00162    { return a <= b ? a : b; }
00163 
00164 inline Float_t TMath::Min(Float_t a, Float_t b)
00165    { return a <= b ? a : b; }
00166 
00167 inline Double_t TMath::Min(Double_t a, Double_t b)
00168    { return a <= b ? a : b; }
00169 
00170 //---- Max ---------------------------------------------------------------------
00171 
00172 inline Short_t TMath::Max(Short_t a, Short_t b)
00173    { return a >= b ? a : b; }
00174 
00175 inline UShort_t TMath::Max(UShort_t a, UShort_t b)
00176    { return a >= b ? a : b; }
00177 
00178 inline Int_t TMath::Max(Int_t a, Int_t b)
00179    { return a >= b ? a : b; }
00180 
00181 inline UInt_t TMath::Max(UInt_t a, UInt_t b)
00182    { return a >= b ? a : b; }
00183 
00184 inline Long_t TMath::Max(Long_t a, Long_t b)
00185    { return a >= b ? a : b; }
00186 
00187 inline ULong_t TMath::Max(ULong_t a, ULong_t b)
00188    { return a >= b ? a : b; }
00189 
00190 inline Long64_t TMath::Max(Long64_t a, Long64_t b)
00191    { return a >= b ? a : b; }
00192 
00193 inline ULong64_t TMath::Max(ULong64_t a, ULong64_t b)
00194    { return a >= b ? a : b; }
00195 
00196 inline Float_t TMath::Max(Float_t a, Float_t b)
00197    { return a >= b ? a : b; }
00198 
00199 inline Double_t TMath::Max(Double_t a, Double_t b)
00200    { return a >= b ? a : b; }
00201 
00202 //---- Range -------------------------------------------------------------------
00203 
00204 inline Short_t TMath::Range(Short_t lb, Short_t ub, Short_t x)
00205    { return x < lb ? lb : (x > ub ? ub : x); }
00206 
00207 inline Int_t TMath::Range(Int_t lb, Int_t ub, Int_t x)
00208    { return x < lb ? lb : (x > ub ? ub : x); }
00209 
00210 inline Long_t TMath::Range(Long_t lb, Long_t ub, Long_t x)
00211    { return x < lb ? lb : (x > ub ? ub : x); }
00212 
00213 inline ULong_t TMath::Range(ULong_t lb, ULong_t ub, ULong_t x)
00214    { return x < lb ? lb : (x > ub ? ub : x); }
00215 
00216 inline Double_t TMath::Range(Double_t lb, Double_t ub, Double_t x)
00217    { return x < lb ? lb : (x > ub ? ub : x); }
00218 
00219 
00220 #endif