ROOT logo
// @(#)root/mathcore:$Id$
// Author: L. Moneta Wed Aug 30 11:15:23 2006

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2006  LCG ROOT Math Team, CERN/PH-SFT                *
 *                                                                    *
 *                                                                    *
 **********************************************************************/

// Header file for class BinData

#ifndef ROOT_Fit_BinData
#define ROOT_Fit_BinData

#ifndef ROOT_Fit_DataVector
#include "Fit/DataVector.h"
#endif


#ifdef USE_BINPOINT_CLASS

#ifndef ROOT_Fit_BinPoint
#include "Fit/BinPoint.h"
#endif

#endif


namespace ROOT { 

   namespace Fit { 



//___________________________________________________________________________________
/** 
   Class describing the binned data sets : 
              vectors of  x coordinates, y values and optionally error on y values and error on coordinates 
              The dimension of the coordinate is free
              There are 4 different options: 
              - only coordinates and values  (for binned likelihood fits)  : kNoError 
              - coordinate, values and error on  values (for normal least square fits)  : kValueError
              - coordinate, values, error on values and coordinates (for effective least square fits) : kCoordError
              - corrdinate, values, error on coordinates and asymmettric error on valyes : kAsymError

              In addition there is the option to construct Bindata copying the data in (using the DataVector class) 
              or using pointer to external data (DataWrapper) class. 
              In general is found to be more efficient to copy the data. 
              In case of really large data sets for limiting memory consumption then the other option can be used
              Specialized constructor exists for data up to 3 dimensions. 

              When the data are copying in the number of points can be set later (or re-set) using Initialize and 
              the data are inserted one by one using the Add method. 
              It is mandatory to set the size before using the Add method.  

             @ingroup  FitData  
*/ 


class BinData  : public FitData  { 

public : 

   enum ErrorType { kNoError, kValueError, kCoordError, kAsymError };

   static unsigned int GetPointSize(ErrorType err, unsigned int dim) { 
      if (dim == 0 || dim > MaxSize() ) return 0;
      if (err == kNoError) return dim + 1;   // no errors
      if (err == kValueError) return dim + 2;  // error only on the value
      if (err == kCoordError) return 2 * dim + 2 ;  // error on value and coordinate
      return 2 * dim + 3;   // error on value (low and high)  and error on coordinate
    }

   ErrorType GetErrorType() const { 
      if (fPointSize == fDim + 1) return kNoError; 
      if (fPointSize == fDim + 2) return kValueError; 
      if (fPointSize == 2 * fDim + 2) return kCoordError; 
      assert( fPointSize == 2 * fDim + 3 ) ; 
      return kAsymError; 
   }

      

   /**
      constructor from dimension of point  and max number of points (to pre-allocate vector)
      Give a zero value and then use Initialize later one if the size is not known
    */

   explicit BinData(unsigned int maxpoints = 0, unsigned int dim = 1, ErrorType err = kValueError); 

   /**
      constructor from option and default range
    */
   explicit BinData (const DataOptions & opt, unsigned int maxpoints = 0, unsigned int dim = 1, ErrorType err = kValueError);

   /**
      constructor from options and range
      efault is 1D and value errors
    */
   BinData (const DataOptions & opt, const DataRange & range, unsigned int maxpoints = 0, unsigned int dim = 1, ErrorType err = kValueError ); 

   /** constructurs using external data */
   
   /**
      constructor from external data for 1D with errors on  coordinate and value
    */
   BinData(unsigned int n, const double * dataX, const double * val, const double * ex , const double * eval ); 
   
   /**
      constructor from external data for 2D with errors on  coordinate and value
    */
   BinData(unsigned int n, const double * dataX, const double * dataY, const double * val, const double * ex , const double * ey, const double * eval  ); 

   /**
      constructor from external data for 3D with errors on  coordinate and value
    */
   BinData(unsigned int n, const double * dataX, const double * dataY, const double * dataZ, const double * val, const double * ex , const double * ey , const double * ez , const double * eval   );

   /**
      copy constructors  
   */
   BinData(const BinData &);

   /** 
       assignment operator 
   */ 
   BinData & operator= (const BinData &);


   /**
      destructor
   */
   virtual ~BinData(); 

   /**
      preallocate a data set with given size ,  dimension and error type (to get the full point size)
      If the data set already exists and it is having the compatible point size space for the new points 
      is created in the data sets, while if not compatible the old data are erased and new space of 
      new size is allocated. 
      (i.e if exists initialize is equivalent to a resize( NPoints() + maxpoints) 
    */
   void Initialize(unsigned int maxpoints, unsigned int dim = 1, ErrorType err = kValueError ); 


   /**
      return the size of a fit point (is the coordinate dimension + 1 for the value and eventually 
      the number of all errors
    */
   unsigned int PointSize() const { 
      return fPointSize; 
   }

   /**
      return the size of internal data  (number of fit points)
      if data are not copied in but used externally the size is 0
    */
   unsigned int DataSize() const { 
      if (fDataVector) return fDataVector->Size(); 
      return 0; 
   }

   /**
      flag to control if data provides error on the coordinates
    */
   bool HaveCoordErrors() const { 
      if (fPointSize > fDim +2) return true; 
      return false;
   }

   /**
      flag to control if data provides asymmetric errors on the value
    */
   bool HaveAsymErrors() const { 
      if (fPointSize > 2 * fDim +2) return true; 
      return false;
   }


   /**
      add one dim data with only coordinate and values
   */
   void Add(double x, double y ); 

   /**
      add one dim data with no error in the coordinate (x)
      in this case store the inverse of the error in the value (y)
   */
   void Add(double x, double y, double ey);

   /**
      add one dim data with  error in the coordinate (x)
      in this case store the value (y)  error and not the inverse 
   */
   void Add(double x, double y, double ex, double ey);

   /**
      add one dim data with  error in the coordinate (x) and asymmetric errors in the value (y)
      in this case store the y errors and not the inverse 
   */
   void Add(double x, double y, double ex, double eyl , double eyh);

   /**
      add multi-dim coordinate data with only value (no errors)
   */
   void Add(const double *x, double val); 

   /**
      add multi-dim coordinate data with only error in value 
   */
   void Add(const double *x, double val, double  eval); 

   /**
      add multi-dim coordinate data with both error in coordinates and value 
   */
   void Add(const double *x, double val, const double * ex, double  eval); 

   /**
      add multi-dim coordinate data with both error in coordinates and value 
   */
   void Add(const double *x, double val, const double * ex, double  elval, double  ehval); 

   /**
      return a pointer to the coordinates data for the given fit point 
    */
   const double * Coords(unsigned int ipoint) const { 
      if (fDataVector) 
         return &((fDataVector->Data())[ ipoint*fPointSize ] );
      
      return fDataWrapper->Coords(ipoint);
   }

   /**
      return the value for the given fit point
    */
   double Value(unsigned int ipoint) const { 
      if (fDataVector)       
         return (fDataVector->Data())[ ipoint*fPointSize + fDim ];
     
      return fDataWrapper->Value(ipoint);
   }


   /**
      return error on the value for the given fit point
      Safe (but slower) method returning correctly the error on the value 
      in case of asymm errors return the average 0.5(eu + el)
    */ 
   double Error(unsigned int ipoint) const { 
      if (fDataVector) { 
         ErrorType type = GetErrorType(); 
         if (type == kNoError ) return 1; 
         // error on the value is the last element in the point structure
         double eval =  (fDataVector->Data())[ (ipoint+1)*fPointSize - 1];
         if (type == kValueError ) // need to invert (inverror is stored) 
            return eval != 0 ? 1.0/eval : 0; 
         else if (type == kAsymError) {  // return 1/2(el + eh) 
            double el = (fDataVector->Data())[ (ipoint+1)*fPointSize - 2];
            return 0.5 * (el+eval); 
         }
         return eval; // case of coord errors
      }

      return fDataWrapper->Error(ipoint);
   } 

   /**
      Return the inverse of error on the value for the given fit point
      useful when error in the coordinates are not stored and then this is used directly this as the weight in 
      the least square function
    */
   double InvError(unsigned int ipoint) const {
      if (fDataVector) { 
         // error on the value is the last element in the point structure
         double eval =  (fDataVector->Data())[ (ipoint+1)*fPointSize - 1];
         return eval; 
//          if (!fWithCoordError) return eval; 
//          // when error in the coordinate is stored, need to invert it 
//          return eval != 0 ? 1.0/eval : 0; 
      }
      //case data wrapper 

      double eval = fDataWrapper->Error(ipoint);
      return eval != 0 ? 1.0/eval : 0; 
   }


   /**
      Return a pointer to the errors in the coordinates for the given fit point
    */
   const double * CoordErrors(unsigned int ipoint) const {
      if (fDataVector) { 
         // error on the value is the last element in the point structure
         return  &(fDataVector->Data())[ (ipoint)*fPointSize + fDim + 1];
      }

      return fDataWrapper->CoordErrors(ipoint);
   }

   /**
      retrieve at the same time a  pointer to the coordinate data and the fit value
      More efficient than calling Coords(i) and Value(i)
    */
   const double * GetPoint(unsigned int ipoint, double & value) const {
      if (fDataVector) { 
         unsigned int j = ipoint*fPointSize;
         const std::vector<double> & v = (fDataVector->Data());
         const double * x = &v[j];
         value = v[j+fDim];
         return x;
      } 
      value = fDataWrapper->Value(ipoint);
      return fDataWrapper->Coords(ipoint);
   }

   /**
      retrieve in a single call a pointer to the coordinate data, value and inverse error for 
      the given fit point. 
      To be used only when type is kValueError or kNoError. In the last case the value 1 is returned 
      for the error. 
   */
   const double * GetPoint(unsigned int ipoint, double & value, double & invError) const {
      if (fDataVector) { 
         const std::vector<double> & v = (fDataVector->Data());
         unsigned int j = ipoint*fPointSize;
         const double * x = &v[j];
         j += fDim;
         value = v[j];
         if (fPointSize == fDim +1) // value error (type=kNoError)
            invError = 1;
         else if (fPointSize == fDim +2) // value error (type=kNoError)
            invError = v[j+1];
         else 
            assert(0); // cannot be here

         return x;
      } 
      value = fDataWrapper->Value(ipoint);
      double e = fDataWrapper->Error(ipoint);
      invError = ( e > 0 ) ? 1.0/e : 1.0; 
      return fDataWrapper->Coords(ipoint);
   }

   /**
      Retrieve the errors on the point (coordinate and value) for the given fit point
      It must be called only when the coordinate errors are stored otherwise it will produce an 
      assert.
   */
   const double * GetPointError(unsigned int ipoint, double & errvalue) const {
      if (fDataVector) { 
         assert(fPointSize > fDim + 2); 
         unsigned int j = ipoint*fPointSize;
         const std::vector<double> & v = (fDataVector->Data());
         const double * ex = &v[j+fDim+1];
         errvalue = v[j + 2*fDim +1];
         return ex;
      } 
      errvalue = fDataWrapper->Error(ipoint);
      return fDataWrapper->CoordErrors(ipoint);
   }

   /**
      Get errors on the point (coordinate errors and asymmetric value errors) for the 
      given fit point. 
      It must be called only when the coordinate errors and asymmetric errors are stored 
      otherwise it will produce an assert.
   */
   const double * GetPointError(unsigned int ipoint, double & errlow, double & errhigh) const {
      // external data is not supported for asymmetric errors
      assert(fDataVector); 

      assert(fPointSize > 2 * fDim + 2); 
      unsigned int j = ipoint*fPointSize;
      const std::vector<double> & v = (fDataVector->Data());
      const double * ex = &v[j+fDim+1];
      errlow  = v[j + 2*fDim +1];
      errhigh = v[j + 2*fDim +2];
      return ex;
   }


#ifdef USE_BINPOINT_CLASS
   const BinPoint & GetPoint(unsigned int ipoint) const { 
      if (fDataVector) { 
         unsigned int j = ipoint*fPointSize;
         const std::vector<double> & v = (fDataVector->Data());
         const double * x = &v[j];
         double value = v[j+fDim];
         if (fPointSize > fDim + 2) {
            const double * ex = &v[j+fDim+1];
            double err = v[j + 2*fDim +1];
            fPoint.Set(x,value,ex,err);
         } 
         else {
            double invError = v[j+fDim+1];
            fPoint.Set(x,value,invError);
         }

      } 
      else { 
         double value = fDataWrapper->Value(ipoint);
         double e = fDataWrapper->Error(ipoint);
         if (fPointSize > fDim + 2) {
            fPoint.Set(fDataWrapper->Coords(ipoint), value, fDataWrapper->CoordErrors(ipoint), e);
         } else { 
            double invError = ( e != 0 ) ? 1.0/e : 0; 
            fPoint.Set(fDataWrapper->Coords(ipoint), value, invError);
         }
      }
      return fPoint; 
   }      


   const BinPoint & GetPointError(unsigned int ipoint) const { 
      if (fDataVector) { 
         unsigned int j = ipoint*fPointSize;
         const std::vector<double> & v = (fDataVector->Data());
         const double * x = &v[j];
         double value = v[j+fDim];
         double invError = v[j+fDim+1];
         fPoint.Set(x,value,invError);
      } 
      else { 
         double value = fDataWrapper->Value(ipoint);
         double e = fDataWrapper->Error(ipoint);
         double invError = ( e != 0 ) ? 1.0/e : 0; 
         fPoint.Set(fDataWrapper->Coords(ipoint), value, invError);
      }
      return fPoint; 
   }      
#endif

   /**
      resize the vector to the new given npoints
      if vector does not exists is created using existing point size
    */
   void Resize (unsigned int npoints);  

   /**
      return number of fit points
    */
   unsigned int NPoints() const { return fNPoints; } 

   /**
      return number of fit points 
    */ 
   unsigned int Size() const { return fNPoints; }

   /**
      return coordinate data dimension
    */
   unsigned int NDim() const { return fDim; } 

   /**
      apply a Log transformation of the data values 
      can be used for example when fitting an exponential or gaussian
      Transform the data in place need to copy if want to preserve original data
      The data sets must not contain negative values. IN case it does, 
      an empty data set is returned
    */
   BinData & LogTransform();


   /** 
       return an array containing the upper edge of the bin for coordinate i
       In case of empty bin they could be merged in a single larger bin
       Return a NULL pointer  if the bin width  is not stored 
   */
   const double * BinUpEdge(unsigned int icoord) const { 
      if (fBinEdge.size() == 0 || icoord*fDim > fBinEdge.size() ) return 0; 
      return &fBinEdge[ icoord * fDim];
   }
   
   /**
      query if the data store the bin edges instead of the center
   */
   bool HasBinEdges() const {
      return fBinEdge.size() > 0 && fBinEdge.size() == fDim*fNPoints;
   }

   /** 
       add the bin width data, a pointer to an array with the bin upper edge information.
       This is needed when fitting with integral options
       The information is added for the previously inserted point. 
       BinData::Add  must be called before
   */
   void AddBinUpEdge(const double * xup); 

   /** 
       retrieve the reference volume used to normalize the data when the option bin volume is set
    */ 
   double RefVolume() const { return fRefVolume; }

   /**
      set the reference volume used to normalize the data when the option bin volume is set
    */
   void SetRefVolume(double value) { fRefVolume = value; }


   /**
      compute the total sum of the data content
      (sum of weights in cse of weighted data set)
   */
   double SumOfContent() const { return fSumContent; } 

   /**
      compute the total sum of the error square
      (sum of weight square in case of a weighted data set)
   */
   double SumOfError2() const { return fSumError2;}
   

protected: 

   void SetNPoints(unsigned int n) { fNPoints = n; }

private: 


   unsigned int fDim;       // coordinate dimension
   unsigned int fPointSize; // total point size including value and errors (= fDim + 2 for error in only Y ) 
   unsigned int fNPoints;   // number of contained points in the data set (can be different than size of vector)
   double fSumContent;  // total sum of the bin data content 
   double fSumError2;  // total sum square of the errors
   double fRefVolume;  // reference bin volume - used to normalize the bins in case of variable bins data

   DataVector * fDataVector;  // pointer to the copied in data vector
   DataWrapper * fDataWrapper;  // pointer to the external data wrapper structure

   std::vector<double> fBinEdge;  // vector containing the bin upper edge (coordinate will contain low edge) 


#ifdef USE_BINPOINT_CLASS
   mutable BinPoint fPoint; 
#endif

}; 

  
   } // end namespace Fit

} // end namespace ROOT



#endif /* ROOT_Fit_BinData */


 BinData.h:1
 BinData.h:2
 BinData.h:3
 BinData.h:4
 BinData.h:5
 BinData.h:6
 BinData.h:7
 BinData.h:8
 BinData.h:9
 BinData.h:10
 BinData.h:11
 BinData.h:12
 BinData.h:13
 BinData.h:14
 BinData.h:15
 BinData.h:16
 BinData.h:17
 BinData.h:18
 BinData.h:19
 BinData.h:20
 BinData.h:21
 BinData.h:22
 BinData.h:23
 BinData.h:24
 BinData.h:25
 BinData.h:26
 BinData.h:27
 BinData.h:28
 BinData.h:29
 BinData.h:30
 BinData.h:31
 BinData.h:32
 BinData.h:33
 BinData.h:34
 BinData.h:35
 BinData.h:36
 BinData.h:37
 BinData.h:38
 BinData.h:39
 BinData.h:40
 BinData.h:41
 BinData.h:42
 BinData.h:43
 BinData.h:44
 BinData.h:45
 BinData.h:46
 BinData.h:47
 BinData.h:48
 BinData.h:49
 BinData.h:50
 BinData.h:51
 BinData.h:52
 BinData.h:53
 BinData.h:54
 BinData.h:55
 BinData.h:56
 BinData.h:57
 BinData.h:58
 BinData.h:59
 BinData.h:60
 BinData.h:61
 BinData.h:62
 BinData.h:63
 BinData.h:64
 BinData.h:65
 BinData.h:66
 BinData.h:67
 BinData.h:68
 BinData.h:69
 BinData.h:70
 BinData.h:71
 BinData.h:72
 BinData.h:73
 BinData.h:74
 BinData.h:75
 BinData.h:76
 BinData.h:77
 BinData.h:78
 BinData.h:79
 BinData.h:80
 BinData.h:81
 BinData.h:82
 BinData.h:83
 BinData.h:84
 BinData.h:85
 BinData.h:86
 BinData.h:87
 BinData.h:88
 BinData.h:89
 BinData.h:90
 BinData.h:91
 BinData.h:92
 BinData.h:93
 BinData.h:94
 BinData.h:95
 BinData.h:96
 BinData.h:97
 BinData.h:98
 BinData.h:99
 BinData.h:100
 BinData.h:101
 BinData.h:102
 BinData.h:103
 BinData.h:104
 BinData.h:105
 BinData.h:106
 BinData.h:107
 BinData.h:108
 BinData.h:109
 BinData.h:110
 BinData.h:111
 BinData.h:112
 BinData.h:113
 BinData.h:114
 BinData.h:115
 BinData.h:116
 BinData.h:117
 BinData.h:118
 BinData.h:119
 BinData.h:120
 BinData.h:121
 BinData.h:122
 BinData.h:123
 BinData.h:124
 BinData.h:125
 BinData.h:126
 BinData.h:127
 BinData.h:128
 BinData.h:129
 BinData.h:130
 BinData.h:131
 BinData.h:132
 BinData.h:133
 BinData.h:134
 BinData.h:135
 BinData.h:136
 BinData.h:137
 BinData.h:138
 BinData.h:139
 BinData.h:140
 BinData.h:141
 BinData.h:142
 BinData.h:143
 BinData.h:144
 BinData.h:145
 BinData.h:146
 BinData.h:147
 BinData.h:148
 BinData.h:149
 BinData.h:150
 BinData.h:151
 BinData.h:152
 BinData.h:153
 BinData.h:154
 BinData.h:155
 BinData.h:156
 BinData.h:157
 BinData.h:158
 BinData.h:159
 BinData.h:160
 BinData.h:161
 BinData.h:162
 BinData.h:163
 BinData.h:164
 BinData.h:165
 BinData.h:166
 BinData.h:167
 BinData.h:168
 BinData.h:169
 BinData.h:170
 BinData.h:171
 BinData.h:172
 BinData.h:173
 BinData.h:174
 BinData.h:175
 BinData.h:176
 BinData.h:177
 BinData.h:178
 BinData.h:179
 BinData.h:180
 BinData.h:181
 BinData.h:182
 BinData.h:183
 BinData.h:184
 BinData.h:185
 BinData.h:186
 BinData.h:187
 BinData.h:188
 BinData.h:189
 BinData.h:190
 BinData.h:191
 BinData.h:192
 BinData.h:193
 BinData.h:194
 BinData.h:195
 BinData.h:196
 BinData.h:197
 BinData.h:198
 BinData.h:199
 BinData.h:200
 BinData.h:201
 BinData.h:202
 BinData.h:203
 BinData.h:204
 BinData.h:205
 BinData.h:206
 BinData.h:207
 BinData.h:208
 BinData.h:209
 BinData.h:210
 BinData.h:211
 BinData.h:212
 BinData.h:213
 BinData.h:214
 BinData.h:215
 BinData.h:216
 BinData.h:217
 BinData.h:218
 BinData.h:219
 BinData.h:220
 BinData.h:221
 BinData.h:222
 BinData.h:223
 BinData.h:224
 BinData.h:225
 BinData.h:226
 BinData.h:227
 BinData.h:228
 BinData.h:229
 BinData.h:230
 BinData.h:231
 BinData.h:232
 BinData.h:233
 BinData.h:234
 BinData.h:235
 BinData.h:236
 BinData.h:237
 BinData.h:238
 BinData.h:239
 BinData.h:240
 BinData.h:241
 BinData.h:242
 BinData.h:243
 BinData.h:244
 BinData.h:245
 BinData.h:246
 BinData.h:247
 BinData.h:248
 BinData.h:249
 BinData.h:250
 BinData.h:251
 BinData.h:252
 BinData.h:253
 BinData.h:254
 BinData.h:255
 BinData.h:256
 BinData.h:257
 BinData.h:258
 BinData.h:259
 BinData.h:260
 BinData.h:261
 BinData.h:262
 BinData.h:263
 BinData.h:264
 BinData.h:265
 BinData.h:266
 BinData.h:267
 BinData.h:268
 BinData.h:269
 BinData.h:270
 BinData.h:271
 BinData.h:272
 BinData.h:273
 BinData.h:274
 BinData.h:275
 BinData.h:276
 BinData.h:277
 BinData.h:278
 BinData.h:279
 BinData.h:280
 BinData.h:281
 BinData.h:282
 BinData.h:283
 BinData.h:284
 BinData.h:285
 BinData.h:286
 BinData.h:287
 BinData.h:288
 BinData.h:289
 BinData.h:290
 BinData.h:291
 BinData.h:292
 BinData.h:293
 BinData.h:294
 BinData.h:295
 BinData.h:296
 BinData.h:297
 BinData.h:298
 BinData.h:299
 BinData.h:300
 BinData.h:301
 BinData.h:302
 BinData.h:303
 BinData.h:304
 BinData.h:305
 BinData.h:306
 BinData.h:307
 BinData.h:308
 BinData.h:309
 BinData.h:310
 BinData.h:311
 BinData.h:312
 BinData.h:313
 BinData.h:314
 BinData.h:315
 BinData.h:316
 BinData.h:317
 BinData.h:318
 BinData.h:319
 BinData.h:320
 BinData.h:321
 BinData.h:322
 BinData.h:323
 BinData.h:324
 BinData.h:325
 BinData.h:326
 BinData.h:327
 BinData.h:328
 BinData.h:329
 BinData.h:330
 BinData.h:331
 BinData.h:332
 BinData.h:333
 BinData.h:334
 BinData.h:335
 BinData.h:336
 BinData.h:337
 BinData.h:338
 BinData.h:339
 BinData.h:340
 BinData.h:341
 BinData.h:342
 BinData.h:343
 BinData.h:344
 BinData.h:345
 BinData.h:346
 BinData.h:347
 BinData.h:348
 BinData.h:349
 BinData.h:350
 BinData.h:351
 BinData.h:352
 BinData.h:353
 BinData.h:354
 BinData.h:355
 BinData.h:356
 BinData.h:357
 BinData.h:358
 BinData.h:359
 BinData.h:360
 BinData.h:361
 BinData.h:362
 BinData.h:363
 BinData.h:364
 BinData.h:365
 BinData.h:366
 BinData.h:367
 BinData.h:368
 BinData.h:369
 BinData.h:370
 BinData.h:371
 BinData.h:372
 BinData.h:373
 BinData.h:374
 BinData.h:375
 BinData.h:376
 BinData.h:377
 BinData.h:378
 BinData.h:379
 BinData.h:380
 BinData.h:381
 BinData.h:382
 BinData.h:383
 BinData.h:384
 BinData.h:385
 BinData.h:386
 BinData.h:387
 BinData.h:388
 BinData.h:389
 BinData.h:390
 BinData.h:391
 BinData.h:392
 BinData.h:393
 BinData.h:394
 BinData.h:395
 BinData.h:396
 BinData.h:397
 BinData.h:398
 BinData.h:399
 BinData.h:400
 BinData.h:401
 BinData.h:402
 BinData.h:403
 BinData.h:404
 BinData.h:405
 BinData.h:406
 BinData.h:407
 BinData.h:408
 BinData.h:409
 BinData.h:410
 BinData.h:411
 BinData.h:412
 BinData.h:413
 BinData.h:414
 BinData.h:415
 BinData.h:416
 BinData.h:417
 BinData.h:418
 BinData.h:419
 BinData.h:420
 BinData.h:421
 BinData.h:422
 BinData.h:423
 BinData.h:424
 BinData.h:425
 BinData.h:426
 BinData.h:427
 BinData.h:428
 BinData.h:429
 BinData.h:430
 BinData.h:431
 BinData.h:432
 BinData.h:433
 BinData.h:434
 BinData.h:435
 BinData.h:436
 BinData.h:437
 BinData.h:438
 BinData.h:439
 BinData.h:440
 BinData.h:441
 BinData.h:442
 BinData.h:443
 BinData.h:444
 BinData.h:445
 BinData.h:446
 BinData.h:447
 BinData.h:448
 BinData.h:449
 BinData.h:450
 BinData.h:451
 BinData.h:452
 BinData.h:453
 BinData.h:454
 BinData.h:455
 BinData.h:456
 BinData.h:457
 BinData.h:458
 BinData.h:459
 BinData.h:460
 BinData.h:461
 BinData.h:462
 BinData.h:463
 BinData.h:464
 BinData.h:465
 BinData.h:466
 BinData.h:467
 BinData.h:468
 BinData.h:469
 BinData.h:470
 BinData.h:471
 BinData.h:472
 BinData.h:473
 BinData.h:474
 BinData.h:475
 BinData.h:476
 BinData.h:477
 BinData.h:478
 BinData.h:479
 BinData.h:480
 BinData.h:481
 BinData.h:482
 BinData.h:483
 BinData.h:484
 BinData.h:485
 BinData.h:486
 BinData.h:487
 BinData.h:488
 BinData.h:489
 BinData.h:490
 BinData.h:491
 BinData.h:492
 BinData.h:493
 BinData.h:494
 BinData.h:495
 BinData.h:496
 BinData.h:497
 BinData.h:498
 BinData.h:499
 BinData.h:500
 BinData.h:501
 BinData.h:502
 BinData.h:503
 BinData.h:504
 BinData.h:505
 BinData.h:506
 BinData.h:507
 BinData.h:508
 BinData.h:509
 BinData.h:510
 BinData.h:511
 BinData.h:512
 BinData.h:513
 BinData.h:514
 BinData.h:515
 BinData.h:516
 BinData.h:517
 BinData.h:518
 BinData.h:519
 BinData.h:520
 BinData.h:521
 BinData.h:522
 BinData.h:523
 BinData.h:524
 BinData.h:525
 BinData.h:526
 BinData.h:527
 BinData.h:528
 BinData.h:529
 BinData.h:530
 BinData.h:531
 BinData.h:532
 BinData.h:533
 BinData.h:534
 BinData.h:535
 BinData.h:536
 BinData.h:537
 BinData.h:538
 BinData.h:539
 BinData.h:540
 BinData.h:541
 BinData.h:542
 BinData.h:543
 BinData.h:544
 BinData.h:545
 BinData.h:546
 BinData.h:547
 BinData.h:548