Using const char * instead of char *

[u/mrichter/AliRoot.git] / TRD / AliTRDtrapAlu.cxx

#include "AliTRDtrapAlu.h"\r
\r
ClassImp(AliTRDtrapAlu)\r
\r
//usage of the class: \r
//declaration of class instances:   AliTRDtrapAlu a,b,c;\r
//initialization:                  a.Init(2,11); b.Init(4,4); c.Init(5,4);\r
//assigning values:                a.AssignDouble(5.7); b.AssignInt(3);(you can also do b.AssignDouble(3) with same effect);\r
//calculation:                     c = a*b;  \r
//test if c has right value:       c.WriteWord();\r
//don't declare pointers; operators not overridden for pointer types; you have to dereference yourself;\r
//use operators +,-,*,/ only with instances of the class; don't do things like c=a*2 but rather b.AssignInt(2); c=a*b;\r
\r
\r
\r
  \r
AliTRDtrapAlu::AliTRDtrapAlu():TObject()\r
\r
  ,fValue(0)\r
  ,fPreCom(0)\r
  ,fPostCom(0)\r
  ,fuRestriction(0)\r
  ,flRestriction(0)\r
  ,fSigned(kFALSE)\r
\r
{\r
  \r
 // default constructor\r
 \r
 \r
}\r
\r
\r
AliTRDtrapAlu::~AliTRDtrapAlu(){\r
  //destructor\r
}\r
\r
\r
\r
void AliTRDtrapAlu::Init(const Int_t& precom, const Int_t& postcom, const Int_t& lRestriction, const Int_t& uRestriction){\r
   // initialization: characterizes the bit-word (nr of pre- and post-comma bits, boundaries)\r
   fPostCom = postcom;\r
   fPreCom  = precom;\r
   fValue   = 0;       //currently, re-initialization kills the value\r
   fSigned  = kFALSE;\r
\r
   if (fPreCom + fPostCom > 32 || fPreCom > 31) {fPreCom = 1; fPostCom = 0;return;} // prevent pre-comma part exceeding 31 spaces\r
   if (fPreCom  <= 0) {fPreCom  = 1;}\r
   if (fPostCom <  0) {fPostCom = 0;}\r
   \r
   Int_t lut = LUT(fPreCom + fPostCom)-1;\r
   if (uRestriction <= -1 || uRestriction > lut) {fuRestriction = lut;}\r
   else {fuRestriction = uRestriction;}\r
   if (lRestriction <= -1 || lRestriction > fuRestriction) {flRestriction = -lut;}\r
   else {flRestriction = lRestriction;}\r
   // up to now you can only choose a non-negative lower restriction (e.g. if you want your values to be >=0) ; can't deal with asymmetric borders; have to be implemented if needed\r
}\r
\r
\r
Double_t AliTRDtrapAlu::GetValueWhole() const { \r
   // get the actual value (respecting pre- and post-comma parts) in integer-description\r
   Double_t valPre = (Double_t)(fValue>>fPostCom);\r
   Double_t valPost = 0.0;\r
   for(Int_t i = 0; i<=fPostCom-1; i++){\r
     Double_t num = (fValue>>i)&1;\r
     Double_t denom = LUT(fPostCom-i);\r
     valPost = valPost + num/denom;\r
   }\r
   Double_t val = valPre + valPost;\r
   return val;\r
 }\r
\r
\r
void AliTRDtrapAlu::WriteWord(){\r
  // for debugging purposes\r
  printf("bit-word: ");\r
  if (fSigned == true) printf("-");\r
  for(Int_t i = fPostCom + fPreCom - 1; i >= fPostCom; i--){  //read from behind in order to write the word from left to right\r
    printf("%d",(fValue>>i) & 1);\r
  }\r
  printf(".");\r
  for (Int_t j = fPostCom - 1; j >= 0; j--){\r
    printf("%d",(fValue>>j) & 1);\r
  }\r
  printf("\n");\r
         \r
}\r
\r
\r
\r
\r
\r
AliTRDtrapAlu& AliTRDtrapAlu::AssignInt(const Int_t& first){  \r
  // assign an integer\r
\r
  // parameter "first" is an integer for the pre-comma part (not UInt in order to match the error case first<0)\r
  fSigned = kFALSE;\r
  Int_t exponent = fPreCom + fPostCom;\r
\r
    \r
  if (first<0) {\r
    fValue  = 0;                      //setting fValue to 0; first should not be negative\r
    fValue  = fValue & 0;\r
    return *this;\r
  }\r
\r
  if (CheckUSize(first<<fPostCom) == kFALSE){\r
    \r
    //setting fValue to maximum; first was to big\r
    fValue  = fuRestriction;\r
    fValue  = fValue & LUT(exponent)-1;\r
    return *this;\r
  }\r
\r
  if (CheckLSize(first<<fPostCom) == kFALSE){\r
    \r
    //setting fValue to minimum; first was to small\r
    fValue  = flRestriction;\r
    fValue  = fValue & LUT(exponent)-1;\r
    return *this;\r
  }\r
\r
  \r
  fValue  = first;\r
  fValue  = fValue<<fPostCom; \r
  fValue  = fValue & LUT(exponent)-1;\r
 \r
  return *this;\r
    \r
}\r
\r
AliTRDtrapAlu& AliTRDtrapAlu::AssignDouble(const  Double_t& first){\r
  // assign a double\r
 \r
  fSigned = kFALSE;\r
  Int_t exponent           = fPreCom + fPostCom;\r
  Int_t firstPre          = 0;  //integer part of first\r
  Int_t firstPost         = 0;  //comma part of first (cut off with enough accuracy\r
  Int_t c                  = 0;\r
  Double_t firstPreFloat = 0;\r
  \r
  \r
  Int_t power1 = LUT(exponent);\r
  \r
  firstPre       = (Int_t)first;\r
  firstPreFloat = firstPre;\r
  \r
  if(firstPre < 0){\r
    fValue  = 0;\r
    fValue = fValue & 0;\r
    return *this;\r
  }\r
  \r
  if(CheckUSize((Int_t)(first*LUT(fPostCom))) == kFALSE){\r
    \r
    //fValue  = MakePower(2,fPreCom) - 1;\r
    fValue  = fuRestriction;\r
    fValue  = fValue & (power1 - 1);\r
    return *this;\r
  }\r
  \r
  if(CheckLSize((Int_t)(first*LUT(fPostCom))) == kFALSE){\r
    \r
    //fValue  = MakePower(2,fPreCom) - 1;\r
    fValue  = flRestriction;\r
    fValue  = fValue & (power1 - 1);\r
    return *this;\r
  }\r
  \r
\r
  fValue = firstPre;\r
  \r
  //get post comma part with adequate accuracy\r
  firstPost = (Int_t)((first - firstPreFloat)*LUT(fPostCom));\r
  for(Int_t i = 1; i <= fPostCom; i++) {\r
    c = (firstPost>>(fPostCom - i)) & 1;\r
    fValue  = fValue<<1;\r
    fValue  = fValue | c;\r
  }\r
\r
  fValue = fValue & (power1 - 1);\r
  return *this;\r
}\r
\r
\r
AliTRDtrapAlu& AliTRDtrapAlu::operator=(const AliTRDtrapAlu& binary){\r
  // assign an object of type AliTRDtrapAlu\r
\r
  Int_t c    = 0;\r
  //Int_t exponent = fPreCom + fPostCom;\r
  \r
  \r
  Int_t power1 = LUT(fPreCom + fPostCom);\r
\r
  fValue          = binary.GetValue();         // in case this==&binary : binary's values are overwritten\r
  Int_t diffPost = binary.GetPost()-fPostCom;\r
  Int_t check     = 0;\r
  if(diffPost<0) check = fValue<<(-diffPost);\r
  else check = fValue>>(diffPost);\r
  if (CheckUSize(check)==kFALSE){    //checking size of pre-comma part\r
    \r
    //setting fValue to maximum\r
      \r
           \r
    fValue  = fuRestriction;         // fuRestriction >= 0 \r
    fValue  = fValue & (power1 - 1);\r
    fSigned = kFALSE;\r
    return *this;\r
  }\r
\r
  Int_t val = (binary.GetSign()==kFALSE) ? check : -check; \r
  if (CheckLSize(val)==kFALSE){    //checking size of pre-comma part\r
    \r
    //setting fValue to minimum\r
      \r
           \r
    if (flRestriction < 0) {\r
      fValue  = -flRestriction;\r
      fSigned = kTRUE;\r
    }\r
    else {\r
      fValue  = flRestriction;\r
      fSigned = kFALSE;\r
    }\r
    fValue  = fValue & (power1 - 1);\r
    return *this;\r
  }\r
  \r
  if (this == & binary) return *this;\r
  \r
  fSigned = kFALSE;\r
  Int_t iValue = fValue;\r
  fValue = fValue>>(binary.GetPost());           //only keep the valid pre-comma bits\r
  \r
  //append existing post-comma bits to fValue; cut off or add 0 if post-comma numbers don`t match\r
  for(Int_t i = 1; i <= fPostCom; i++){\r
    if(i <= (binary.GetPost())){\r
      c = ((iValue)>>(binary.GetPost()-i)) & 1;\r
    }\r
    else{\r
      c = 0;\r
    }\r
    fValue  = fValue<<1;\r
    fValue  = fValue | c;\r
  }\r
  \r
  fValue = fValue & (power1 - 1);\r
  fSigned = binary.GetSign();\r
  return *this;\r
}\r
\r
\r
\r
AliTRDtrapAlu& AliTRDtrapAlu::operator+(AliTRDtrapAlu& binary){ \r
  // + operator\r
\r
  //no const parameter because referenced object will be changed\r
     \r
  \r
  Int_t binPre     = binary.GetPre();\r
  Int_t binPost    = binary.GetPost();\r
  Int_t binVal     = binary.GetValue();\r
  \r
  Int_t min         = Min(binPost,fPostCom);\r
  Int_t max         = Max(binPre,fPreCom);\r
  \r
  Int_t shift       = binPost - min;\r
  Int_t add1        = (binVal)>>(shift);    //for addition: cut off at minimum accuracy\r
  shift             = fPostCom - min;\r
  Int_t add2        = fValue>>(shift);\r
  if(binary.GetSign() == kTRUE) add1 = -add1;\r
  if(fSigned == kTRUE) add2 = -add2;\r
  Int_t add = add1 + add2;\r
  \r
  \r
  //because the parameter "binary" could be a reference to the object to which Mem() is a reference, do not change Mem() until you have extracted all information from "binary"; otherwise you change the information you would like to read\r
  Mem().Init(max + 1,min);      //buffer: enough space for pre-comma,post-comma according to accuracy\r
  Mem().AssignFormatted(Max(add,-add));\r
  Mem().SetSign(add);\r
  \r
\r
  //Mem().FastInit(max+1,min,add);\r
  return Mem();\r
}\r
\r
\r
AliTRDtrapAlu& AliTRDtrapAlu::operator-(AliTRDtrapAlu& binary){\r
  // - operator    \r
\r
  Int_t binPre    = binary.GetPre();\r
  Int_t binPost   = binary.GetPost();\r
  Int_t binVal    = binary.GetValue();\r
\r
\r
  Int_t min      = Min(binPost,fPostCom);\r
  Int_t max      = Max(binPre,fPreCom);\r
\r
  Int_t shift    = binPost - min;\r
  Int_t sub1 = (binVal)>>(shift); //for addition: cut off at minimum accuracy\r
  shift = fPostCom - min;\r
  Int_t sub2 = fValue>>(shift);\r
  if(binary.GetSign() == kTRUE) sub1 = -sub1;\r
  if(fSigned  == kTRUE) sub2 = -sub2;\r
  Int_t sub = sub2 - sub1;     // order of subtraction is important\r
 \r
\r
  Mem().Init(max + 1,min);      //buffer: enough space for pre-comma, post-comma according to accuracy\r
  Mem().AssignFormatted(Max(sub,-sub)); \r
  Mem().SetSign(sub);\r
  //Mem().FastInit(max+1,min,sub);\r
  return Mem();\r
} \r
\r
\r
AliTRDtrapAlu& AliTRDtrapAlu::operator*(AliTRDtrapAlu& binary){\r
  // * operator\r
  \r
\r
  Int_t binPre   = binary.GetPre();\r
  Int_t binPost  = binary.GetPost();\r
\r
\r
  Int_t min      = Min(binPost,fPostCom);\r
  Int_t max      = Max(binPre,fPreCom);\r
\r
  \r
  Int_t mult1 = binary.GetValue();\r
  Int_t mult2 = fValue;\r
  Int_t shift  = (Int_t)(fPostCom + binPost - min);\r
  Double_t fmult1 = (Double_t)mult1;\r
  Double_t fmult2 = (Double_t)mult2;\r
  (fmult1 > fmult2) ? fmult1 = fmult1/LUT(shift) : fmult2 = fmult2/LUT(shift);\r
  \r
    \r
  if (binary.GetSign() == kTRUE) fmult1 = -fmult1;\r
  if (fSigned  == kTRUE) fmult2 = -fmult2;\r
  Double_t fmult  = fmult1*fmult2;\r
  Int_t mult = (Int_t)fmult;\r
  Int_t sign = 1;\r
  if(mult<0) sign = -1;\r
  mult = Max(mult,-mult);\r
  //Int_t shift = fPostCom + binPost - min;\r
  //mult = mult>>(shift);\r
  Mem().Init(2 * max + 1, min); // +1 to consider the borrow from the past-comma part; accuracy of past-comma part is determined by the minimum; therefore, for the result not more accuracy is guaranteed\r
  // be aware that this only works if 2*max+1+min <= 32!! adjusting the pre-comma place to the value would consume too much time\r
\r
  Mem().AssignFormatted(mult);\r
  Mem().SetSign(sign);\r
  //mult = sign*mult;\r
  //Mem().FastInit(2*max+1,min,mult);\r
  return Mem();\r
}\r
  \r
\r
\r
AliTRDtrapAlu& AliTRDtrapAlu::operator/(AliTRDtrapAlu& binary){\r
  // / operator\r
 \r
\r
  Int_t binPre  = binary.GetPre();\r
  Int_t binPost = binary.GetPost();\r
  Int_t min              = Min(binPost,fPostCom);\r
  Int_t max              = Max(binPre,fPreCom);\r
  \r
  Int_t div1             = binary.GetValue(); //value in integer format\r
  Int_t div2             = fValue;\r
  \r
  // this approach does not always work because it can exceed the range of integers\r
  //Int_t numerator     = div2 * LUT(min);\r
  Int_t numerator     = div2;\r
  if (fSigned == kTRUE) numerator = numerator*(-1);\r
  Int_t denominator   = div1;\r
  if (binary.GetSign() == kTRUE) denominator = denominator*(-1);\r
  Double_t fdiv       = 0.0;\r
  Double_t fLUT       = 0.0;\r
  Int_t div           = 0;\r
  \r
\r
  if (div1 == 0){\r
    Mem().Init(max + 1,min);\r
    Mem().AssignFormatted(LUT(max+min+1)-1); // division by 0: set to max value\r
    //Mem().FastInit(max+1,min,div1);\r
    return Mem();\r
  }\r
      \r
  fdiv = (Double_t)numerator/denominator;\r
  \r
  Int_t shift = fPostCom - binPost;\r
  \r
  if(shift>0){\r
      //denominator = denominator * LUT(shift);\r
      fLUT = (Double_t)LUT(min)/LUT(shift);\r
  }\r
  else {\r
      if(shift<0) {\r
	  shift = -shift;\r
	  //numerator =  numerator * LUT(shift);\r
	  fLUT = (Double_t)LUT(min)*LUT(shift);\r
      }\r
      else {\r
	  fLUT = (Double_t)LUT(min);\r
      }\r
  }\r
\r
  fdiv = fdiv*fLUT;\r
  div = (Int_t)fdiv;\r
  \r
  Int_t sign = (div>=0) ? 1 : -1;\r
  div = Max(div,-div);\r
  \r
  // chose min as past-comma part because from a division of integers you can't get only an integer\r
  Mem().Init(max + 1,min); // max+1+min must <= 32!!\r
  Mem().SetSign(sign);\r
  Mem().AssignFormatted(div);\r
  \r
  return Mem();\r
  \r
}\r
\r
\r
\r
Int_t AliTRDtrapAlu::MakePower(const Int_t& base,const  Int_t& exponent)const{\r
// calculate "base" to the power of "exponent"\r
  Int_t result = 1;\r
  \r
    for(Int_t i = 1; i <= exponent; i++){\r
    result = result * base;\r
  }\r
  return result;\r
}\r
\r
\r
\r
\r
Int_t AliTRDtrapAlu::LUT(const Int_t& index){   \r
  // simple look-up table for base=2\r
  \r
  static Bool_t fLUT = kFALSE;\r
  static Int_t gLUT[30];\r
  if (fLUT == kFALSE) {\r
    gLUT[0] = 1;\r
    for(Int_t i = 1; i<30; i++) {\r
      gLUT[i] = gLUT[i-1] * 2;\r
    }\r
  fLUT = kTRUE;\r
  } \r
  if (index >=0 && index < 30){\r
    return gLUT[index];\r
  }\r
  else {\r
    \r
    return Mem().MakePower(2,index);\r
  }\r
}\r