ibin.h
Go to the documentation of this file.
00001 //File: $Id$
00002 // Author: John Wu <John.Wu at ACM.org>
00003 //         Lawrence Berkeley National Laboratory
00004 // Copyright 2000-2012 the Regents of the University of California
00005 #ifndef IBIS_IBIN_H
00006 #define IBIS_IBIN_H
00007 
00008 
00009 
00010 
00011 
00012 
00013 #include "index.h"
00014 #if defined(_WIN32) && defined(_MSC_VER)
00015 #pragma warning(disable:4786)   // some identifier longer than 256 characters
00016 #undef min
00017 #undef max
00018 #endif
00019 
00027 class ibis::bin : public ibis::index {
00028 public:
00029 
00030     virtual ~bin() {clear();};
00031     bin(const ibis::bin& rhs);
00032     bin(const ibis::column* c=0, const char* f=0);
00033     bin(const ibis::column* c, ibis::fileManager::storage* st,
00034         size_t offset = 8);
00035     bin(const ibis::column* c, const char* f, const array_t<double>& bd);
00036     bin(const ibis::column* c, const char* f, const std::vector<double>& bd);
00037 
00038     virtual void print(std::ostream& out) const;
00039     virtual int write(const char* dt) const; // write to the named file
00040     virtual int read(const char* idxfile);
00041     virtual int read(ibis::fileManager::storage* st);
00042     virtual long append(const char* dt, const char* df, uint32_t nnew);
00043 
00044     using ibis::index::evaluate;
00045     using ibis::index::estimate;
00046     using ibis::index::estimateCost;
00047     virtual long evaluate(const ibis::qContinuousRange& expr,
00048                           ibis::bitvector& hits) const;
00049     virtual long evaluate(const ibis::qDiscreteRange& expr,
00050                           ibis::bitvector& hits) const {
00051         return ibis::index::evaluate(expr, hits);
00052     }
00053 
00054     virtual long select(const ibis::qContinuousRange&, void*) const;
00055     virtual long select(const ibis::qContinuousRange&, void*,
00056                         ibis::bitvector&) const;
00057 
00058     virtual void estimate(const ibis::qContinuousRange& expr,
00059                           ibis::bitvector& lower,
00060                           ibis::bitvector& upper) const;
00061     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00062     using ibis::index::undecidable;
00063     virtual float undecidable(const ibis::qContinuousRange& expr,
00064                               ibis::bitvector& iffy) const;
00065 
00067     virtual void estimate(const ibis::deprecatedJoin& expr,
00068                           ibis::bitvector64& lower,
00069                           ibis::bitvector64& upper) const;
00070     virtual void estimate(const ibis::deprecatedJoin& expr,
00071                           const ibis::bitvector& mask,
00072                           ibis::bitvector64& lower,
00073                           ibis::bitvector64& upper) const;
00074     virtual void estimate(const ibis::deprecatedJoin& expr,
00075                           const ibis::bitvector& mask,
00076                           const ibis::qRange* const range1,
00077                           const ibis::qRange* const range2,
00078                           ibis::bitvector64& lower,
00079                           ibis::bitvector64& upper) const;
00080     virtual int64_t estimate(const ibis::deprecatedJoin& expr,
00081                              const ibis::bitvector& mask,
00082                              const ibis::qRange* const range1,
00083                              const ibis::qRange* const range2) const;
00084 
00086     virtual void estimate(const ibis::bin& idx2,
00087                           const ibis::deprecatedJoin& expr,
00088                           ibis::bitvector64& lower,
00089                           ibis::bitvector64& upper) const;
00090     virtual void estimate(const ibis::bin& idx2,
00091                           const ibis::deprecatedJoin& expr,
00092                           const ibis::bitvector& mask,
00093                           ibis::bitvector64& lower,
00094                           ibis::bitvector64& upper) const;
00095     virtual void estimate(const ibis::bin& idx2,
00096                           const ibis::deprecatedJoin& expr,
00097                           const ibis::bitvector& mask,
00098                           const ibis::qRange* const range1,
00099                           const ibis::qRange* const range2,
00100                           ibis::bitvector64& lower,
00101                           ibis::bitvector64& upper) const;
00102     virtual int64_t estimate(const ibis::bin& idx2,
00103                              const ibis::deprecatedJoin& expr) const;
00104     virtual int64_t estimate(const ibis::bin& idx2,
00105                              const ibis::deprecatedJoin& expr,
00106                              const ibis::bitvector& mask) const;
00107     virtual int64_t estimate(const ibis::bin& idx2,
00108                              const ibis::deprecatedJoin& expr,
00109                              const ibis::bitvector& mask,
00110                              const ibis::qRange* const range1,
00111                              const ibis::qRange* const range2) const;
00112 
00113     virtual INDEX_TYPE type() const {return BINNING;}
00114     virtual const char* name() const {return "bin";}
00115     virtual uint32_t numBins() const {return (nobs>2?nobs-2:0);}
00116     // bin boundaries and counts of each bin
00117     virtual void binBoundaries(std::vector<double>&) const;
00118     virtual void binWeights(std::vector<uint32_t>&) const;
00119     // expand/contract the boundaries of a range condition
00120     virtual int  expandRange(ibis::qContinuousRange& rng) const;
00121     virtual int  contractRange(ibis::qContinuousRange& rng) const;
00122     virtual void speedTest(std::ostream& out) const;
00123     virtual double estimateCost(const ibis::qContinuousRange& expr) const;
00124     virtual double estimateCost(const ibis::qDiscreteRange& expr) const;
00125 
00126     virtual long getCumulativeDistribution(std::vector<double>& bds,
00127                                            std::vector<uint32_t>& cts) const;
00128     virtual long getDistribution(std::vector<double>& bbs,
00129                                  std::vector<uint32_t>& cts) const;
00130     virtual double getMin() const;
00131     virtual double getMax() const;
00132     virtual double getSum() const;
00133 
00135     int read(int fdes, size_t offset, const char *fname, const char *header);
00137     long append(const ibis::bin& tail);
00139     long append(const array_t<uint32_t>& ind);
00140     array_t<uint32_t>* indices(const ibis::bitvector& mask) const;
00143     long checkBin(const ibis::qRange& cmp, uint32_t jbin,
00144                   ibis::bitvector& res) const;
00148     long checkBin(const ibis::qRange& cmp, uint32_t jbin,
00149                   const ibis::bitvector& mask, ibis::bitvector& res) const;
00150 
00167     struct granule {
00168         double minm, maxm; // min and max of values less than the target
00169         double minp, maxp; // min and max of values greater than the target
00170         ibis::bitvector* loce; 
00171         ibis::bitvector* locm; 
00172         ibis::bitvector* locp; 
00173 
00175         granule() : minm(DBL_MAX), maxm(-DBL_MAX), minp(DBL_MAX),
00176                     maxp(-DBL_MAX), loce(0), locm(0), locp(0) {};
00178         ~granule() {delete loce; delete locm; delete locp;};
00179     private:
00180         granule(const granule&); // no copy constructor
00181         granule& operator=(const granule&); // no assignment
00182     };
00183     // key = target value
00184     typedef std::map< double, granule* > granuleMap;
00185 
00187     template <typename T>
00188     struct valpos {
00190         const T *vals;
00192         ibis::bitvector::indexSet ind;
00194         ibis::bitvector::word_t jv;
00196         ibis::bitvector::word_t ji;
00197 
00199         valpos<T>() : vals(0), jv(0), ji(0) {}
00201         valpos<T>(const array_t<T>& v, const bitvector& b)
00202         : vals(v.begin()), ind(b.firstIndexSet()), jv(0), ji(0) {
00203             if (ind.nIndices() > 0 && ind.isRange())
00204                 ji = *(ind.indices());
00205         }
00206 
00208         bitvector::word_t position() const {
00209             if (ind.isRange())
00210                 return ji;
00211             else
00212                 return ind.indices()[ji];
00213         }
00214 
00216         T value() const {
00217             return vals[jv];
00218         }
00219 
00221         void next() {
00222             ++ jv;
00223             ++ ji;
00224             if (ind.isRange()) {
00225                 if (ji >= ind.indices()[1]) {
00226                     ++ ind;
00227                     if (ind.nIndices() > 0 && ind.isRange())
00228                         ji = ind.indices()[0];
00229                     else
00230                         ji = 0;
00231                 }
00232             }
00233             else if (ji >= ind.nIndices()) {
00234                 ++ ind;
00235                 if (ind.nIndices() > 0 && ind.isRange())
00236                     ji = ind.indices()[0];
00237                 else
00238                     ji = 0;
00239             }
00240         }
00241     }; // valpos
00242 
00244     template<typename T>
00245     struct comparevalpos {
00246         bool operator()(const valpos<T>* x, const valpos<T>* y) {
00247             return (x->position() > y->position());
00248         }
00249     }; // comparevalpos
00250 
00251 protected:
00252     // member variables shared by all derived classes -- the derived classes
00253     // are allowed to interpret the actual content differently.
00254     uint32_t nobs;              
00255     array_t<double> bounds;     
00256     array_t<double> maxval;     
00257     array_t<double> minval;     
00258 
00260     bin(const ibis::column* c, const uint32_t nbits,
00261         ibis::fileManager::storage* st, size_t offset = 8);
00262 
00264     void construct(const char*);
00266     void binning(const char* f, const std::vector<double>& bd);
00267     void binning(const char* f, const array_t<double>& bd);
00270     void binning(const char* f);
00273     template <typename E>
00274     void binningT(const char* fname);
00275     template <typename E>
00276     long checkBin0(const ibis::qRange& cmp, uint32_t jbin,
00277                    ibis::bitvector& res) const;
00278     template <typename E>
00279     long checkBin1(const ibis::qRange& cmp, uint32_t jbin,
00280                    const ibis::bitvector& mask, ibis::bitvector& res) const;
00281     template <typename E>
00282     long binOrderT(const char* fname) const;
00283     long binOrder(const char* fname) const;
00284 
00286     void setBoundaries(const char* f);
00287     void setBoundaries(array_t<double>& bnds,
00288                        const ibis::bin& bin0) const;
00289     void setBoundaries(array_t<double>& bnds,
00290                        const ibis::bin& idx1,
00291                        const array_t<uint32_t> cnt1,
00292                        const array_t<uint32_t> cnt0) const;
00293     // functions to deal with in-memory arrays
00294     template <typename E>
00295     void construct(const array_t<E>& varr);
00296     template <typename E>
00297     void binning(const array_t<E>& varr);
00298     template <typename E>
00299     void binning(const array_t<E>& varr, const array_t<double>& bd);
00300     template <typename E>
00301     void setBoundaries(const array_t<E>& varr);
00302     template <typename E>
00303     void scanAndPartition(const array_t<E>&, unsigned);
00304     template <typename E>
00305     void mapGranules(const array_t<E>&, granuleMap& gmap) const;
00306     void printGranules(std::ostream& out, const granuleMap& gmap) const;
00307     void convertGranules(granuleMap& gmap);
00308 
00310     void readBinBoundaries(const char* name, uint32_t nb);
00312     void scanAndPartition(const char*, unsigned, uint32_t nbins=0);
00314     void addBounds(double lbd, double rbd, uint32_t nbins, uint32_t eqw);
00316     uint32_t parseNbins() const;
00318     unsigned parseScale() const;
00320     unsigned parsePrec() const;
00321 
00322     virtual size_t getSerialSize() const throw();
00325     void divideBitmaps(const array_t<bitvector*>& bms,
00326                        std::vector<unsigned>& parts) const;
00327 
00329     virtual double computeSum() const;
00331     virtual void adjustLength(uint32_t nrows);
00333     virtual uint32_t locate(const double& val) const;
00335     virtual void locate(const ibis::qContinuousRange& expr,
00336                         uint32_t& cand0, uint32_t& cand1) const;
00338     virtual void locate(const ibis::qContinuousRange& expr,
00339                         uint32_t& cand0, uint32_t& cand1,
00340                         uint32_t& hit0, uint32_t& hit1) const;
00342     void swap(bin& rhs) {
00343         const ibis::column* c = col;
00344         col = rhs.col;
00345         rhs.col = c;
00346         uint32_t tmp = nobs;
00347         nobs = rhs.nobs;
00348         rhs.nobs = tmp;
00349         tmp = nrows;
00350         nrows = rhs.nrows;
00351         rhs.nrows = tmp;
00352         bounds.swap(rhs.bounds);
00353         maxval.swap(rhs.maxval);
00354         minval.swap(rhs.minval);
00355         bits.swap(rhs.bits);
00356     } // swap
00357 
00358     virtual void clear();
00359     int write32(int fptr) const;
00360     int write64(int fptr) const;
00361 
00362     template <typename T> long
00363     mergeValues(const ibis::qContinuousRange&, ibis::array_t<T>&) const;
00364     template <typename T> long
00365     mergeValues(const ibis::qContinuousRange&, ibis::array_t<T>&,
00366                 ibis::bitvector&) const;
00367 
00368 private:
00369     // private member functions
00370     bin& operator=(const bin&);
00371 
00372     unsigned parseScale(const char*) const;
00373 
00374     void print(std::ostream& out, const uint32_t tot,
00375                const double& lbound, const double& rbound) const;
00376 
00378     void equiJoin(ibis::bitvector64& lower,
00379                   ibis::bitvector64& iffy) const;
00380     void equiJoin(const ibis::bin& idx2,
00381                   ibis::bitvector64& lower,
00382                   ibis::bitvector64& iffy) const;
00383     void deprecatedJoin(const double& delta,
00384                    ibis::bitvector64& lower,
00385                    ibis::bitvector64& iffy) const;
00386     void deprecatedJoin(const ibis::bin& idx2,
00387                    const double& delta,
00388                    ibis::bitvector64& lower,
00389                    ibis::bitvector64& iffy) const;
00390     void compJoin(const ibis::math::term *expr,
00391                   ibis::bitvector64& lower,
00392                   ibis::bitvector64& iffy) const;
00393     void compJoin(const ibis::bin& idx2,
00394                   const ibis::math::term *expr,
00395                   ibis::bitvector64& lower,
00396                   ibis::bitvector64& iffy) const;
00397     void equiJoin(const ibis::bitvector& mask,
00398                   ibis::bitvector64& lower,
00399                   ibis::bitvector64& iffy) const;
00400     void equiJoin(const ibis::bin& idx2,
00401                   const ibis::bitvector& mask,
00402                   ibis::bitvector64& lower,
00403                   ibis::bitvector64& iffy) const;
00404     void deprecatedJoin(const double& delta,
00405                    const ibis::bitvector& mask,
00406                    ibis::bitvector64& lower,
00407                    ibis::bitvector64& iffy) const;
00408     void deprecatedJoin(const ibis::bin& idx2,
00409                    const double& delta,
00410                    const ibis::bitvector& mask,
00411                    ibis::bitvector64& lower,
00412                    ibis::bitvector64& iffy) const;
00413     void compJoin(const ibis::math::term *expr,
00414                   const ibis::bitvector& mask,
00415                   ibis::bitvector64& lower,
00416                   ibis::bitvector64& iffy) const;
00417     void compJoin(const ibis::bin& idx2,
00418                   const ibis::math::term *expr,
00419                   const ibis::bitvector& mask,
00420                   ibis::bitvector64& lower,
00421                   ibis::bitvector64& iffy) const;
00422 
00423     void equiJoin(const ibis::bitvector& mask,
00424                   const ibis::qRange* const range1,
00425                   const ibis::qRange* const range2,
00426                   ibis::bitvector64& sure,
00427                   ibis::bitvector64& iffy) const;
00428     void deprecatedJoin(const double& delta,
00429                    const ibis::bitvector& mask,
00430                    const ibis::qRange* const range1,
00431                    const ibis::qRange* const range2,
00432                    ibis::bitvector64& sure,
00433                    ibis::bitvector64& iffy) const;
00434     void compJoin(const ibis::math::term *delta,
00435                   const ibis::bitvector& mask,
00436                   const ibis::qRange* const range1,
00437                   const ibis::qRange* const range2,
00438                   ibis::bitvector64& sure,
00439                   ibis::bitvector64& iffy) const;
00440 
00441     int64_t equiJoin(const ibis::bitvector& mask,
00442                      const ibis::qRange* const range1,
00443                      const ibis::qRange* const range2) const;
00444     int64_t deprecatedJoin(const double& delta,
00445                       const ibis::bitvector& mask,
00446                       const ibis::qRange* const range1,
00447                       const ibis::qRange* const range2) const;
00448     int64_t compJoin(const ibis::math::term *delta,
00449                      const ibis::bitvector& mask,
00450                      const ibis::qRange* const range1,
00451                      const ibis::qRange* const range2) const;
00452 
00453     void equiJoin(const ibis::bin& idx2,
00454                   const ibis::bitvector& mask,
00455                   const ibis::qRange* const range1,
00456                   const ibis::qRange* const range2,
00457                   ibis::bitvector64& sure,
00458                   ibis::bitvector64& iffy) const;
00459     void deprecatedJoin(const ibis::bin& idx2,
00460                    const double& delta,
00461                    const ibis::bitvector& mask,
00462                    const ibis::qRange* const range1,
00463                    const ibis::qRange* const range2,
00464                    ibis::bitvector64& sure,
00465                    ibis::bitvector64& iffy) const;
00466     void compJoin(const ibis::bin& idx2,
00467                   const ibis::math::term *delta,
00468                   const ibis::bitvector& mask,
00469                   const ibis::qRange* const range1,
00470                   const ibis::qRange* const range2,
00471                   ibis::bitvector64& sure,
00472                   ibis::bitvector64& iffy) const;
00473 
00474     int64_t equiJoin(const ibis::bin& idx2,
00475                      const ibis::bitvector& mask,
00476                      const ibis::qRange* const range1,
00477                      const ibis::qRange* const range2) const;
00478     int64_t deprecatedJoin(const ibis::bin& idx2,
00479                       const double& delta,
00480                       const ibis::bitvector& mask,
00481                       const ibis::qRange* const range1,
00482                       const ibis::qRange* const range2) const;
00483     int64_t compJoin(const ibis::bin& idx2,
00484                      const ibis::math::term *delta,
00485                      const ibis::bitvector& mask,
00486                      const ibis::qRange* const range1,
00487                      const ibis::qRange* const range2) const;
00488 
00489     // need these friendships to access the protected member variables
00490     friend class ibis::mesa;
00491     friend class ibis::range;
00492     friend class ibis::ambit;
00493     friend class ibis::pack;
00494     friend class ibis::pale;
00495     friend class ibis::zone;
00496     friend class ibis::mesh;
00497     friend class ibis::band;
00498 }; // ibis::bin
00499 
00503 class ibis::range : public ibis::bin {
00504 public:
00505 
00506     virtual ~range() {};
00507     range(const ibis::column* c=0, const char* f=0);
00508     range(const ibis::column* c, ibis::fileManager::storage* st,
00509           size_t offset = 8);
00510     explicit range(const ibis::bin& rhs); // convert a bin to a range
00511 
00512     virtual int read(const char* idxfile);
00513     virtual int read(ibis::fileManager::storage* st);
00514     virtual int write(const char* dt) const; // write to the named file
00515     virtual void print(std::ostream& out) const;
00516     virtual long append(const char* dt, const char* df, uint32_t nnew);
00517 
00518     virtual long select(const ibis::qContinuousRange&, void*) const {
00519         return -1;}
00520     virtual long select(const ibis::qContinuousRange&, void*,
00521                         ibis::bitvector&) const {
00522         return -1;}
00523 
00524     virtual long evaluate(const ibis::qContinuousRange& expr,
00525                           ibis::bitvector& hits) const;
00526     virtual long evaluate(const ibis::qDiscreteRange& expr,
00527                           ibis::bitvector& hits) const {
00528         return ibis::index::evaluate(expr, hits);
00529     }
00530 
00531     using ibis::bin::estimate;
00532     using ibis::bin::estimateCost;
00533     virtual void estimate(const ibis::qContinuousRange& expr,
00534                           ibis::bitvector& lower,
00535                           ibis::bitvector& upper) const;
00536     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00537     using ibis::bin::undecidable;
00538     virtual float undecidable(const ibis::qContinuousRange& expr,
00539                               ibis::bitvector& iffy) const;
00540 
00541     virtual INDEX_TYPE type() const {return RANGE;}
00542     virtual const char* name() const {return "range";}
00543     virtual uint32_t numBins() const {return (nobs>1?nobs-1:0);}
00544     // bin boundaries and counts of each bin
00545     virtual void binBoundaries(std::vector<double>&) const;
00546     virtual void binWeights(std::vector<uint32_t>&) const;
00547     // expand/contract the boundaries of a range condition
00548     virtual int  expandRange(ibis::qContinuousRange& range) const;
00549     virtual int  contractRange(ibis::qContinuousRange& range) const;
00550     virtual double getMax() const;
00551     virtual double getSum() const;
00552 
00553     int read(int fdes, size_t offset, const char *fname, const char *);
00554     long append(const ibis::range& tail);
00555     virtual void speedTest(std::ostream& out) const;
00556 
00557 protected:
00558     // protected member variables
00559     double max1, min1; // the min and max of the bin not explicitly tracked
00560 
00561     // have to have its own locate functions because a bin is not explicitly
00562     // stored
00563     virtual uint32_t locate(const double& val) const {
00564         return ibis::bin::locate(val);
00565     }
00566     virtual void locate(const ibis::qContinuousRange& expr,
00567                         uint32_t& cand0, uint32_t& cand1) const;
00568     virtual void locate(const ibis::qContinuousRange& expr,
00569                         uint32_t& cand0, uint32_t& cand1,
00570                         uint32_t& hit0, uint32_t& hit1) const;
00571     virtual double computeSum() const;
00573     void construct(const char*);
00575     void construct(const char* f, const array_t<double>& bd);
00576     virtual size_t getSerialSize() const throw();
00577 
00578 private:
00579     // private member functions
00580     int write32(int fptr) const; // write to the given stream
00581     int write64(int fptr) const; // write to the given stream
00582     void print(std::ostream& out, const uint32_t tot, const double& lbound,
00583                const double& rbound) const;
00584 
00585     friend class ibis::pale; // pale uses ibis::range
00586 }; // ibis::range
00587 
00590 class ibis::mesa : public ibis::bin {
00591 public:
00592     virtual ~mesa() {};
00593     mesa(const ibis::column* c=0, const char* f=0);
00594     mesa(const ibis::column* c, ibis::fileManager::storage* st,
00595          size_t offset = 8);
00596     explicit mesa(const ibis::bin& rhs); // convert a bin to a mesa
00597 
00598     virtual void print(std::ostream& out) const;
00599     virtual int write(const char* dt) const; // write to the named file
00600     virtual long append(const char* dt, const char* df, uint32_t nnew);
00601 
00602     virtual long select(const ibis::qContinuousRange&, void*) const {
00603         return -1;}
00604     virtual long select(const ibis::qContinuousRange&, void*,
00605                         ibis::bitvector&) const {
00606         return -1;}
00607 
00608     virtual long evaluate(const ibis::qContinuousRange& expr,
00609                           ibis::bitvector& hits) const;
00610     virtual long evaluate(const ibis::qDiscreteRange& expr,
00611                           ibis::bitvector& hits) const {
00612         return ibis::index::evaluate(expr, hits);
00613     }
00614 
00615     using ibis::bin::estimate;
00616     using ibis::bin::estimateCost;
00617     virtual void estimate(const ibis::qContinuousRange& expr,
00618                           ibis::bitvector& lower,
00619                           ibis::bitvector& upper) const;
00620     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00621     using ibis::bin::undecidable;
00622     virtual float undecidable(const ibis::qContinuousRange& expr,
00623                               ibis::bitvector& iffy) const;
00624 
00625     virtual INDEX_TYPE type() const {return MESA;}
00626     virtual const char* name() const {return "interval";}
00627     virtual uint32_t numBins() const {return (nobs>2?nobs-2:0);}
00628     // bin boundaries and counts of each bin
00629     virtual void binBoundaries(std::vector<double>&) const;
00630     virtual void binWeights(std::vector<uint32_t>&) const;
00631     virtual double getSum() const;
00632 
00633     virtual void speedTest(std::ostream& out) const;
00634     long append(const ibis::mesa& tail);
00635 
00636 protected:
00637     virtual double computeSum() const;
00639     void construct(const char*);
00640     virtual size_t getSerialSize() const throw();
00641 
00642 private:
00643     // private member functions
00644 
00645     mesa(const mesa&);
00646     mesa& operator=(const mesa&);
00647 }; // ibis::mesa
00648 
00651 class ibis::ambit : public ibis::bin {
00652 public:
00653     virtual ~ambit() {clear();};
00654     ambit(const ibis::column* c=0, const char* f=0);
00655     ambit(const ibis::column* c, ibis::fileManager::storage* st,
00656           size_t offset = 8);
00657     explicit ambit(const ibis::bin& rhs); // convert from a ibis::bin
00658 
00659     virtual int read(const char* idxfile);
00660     virtual int read(ibis::fileManager::storage* st);
00661     virtual int write(const char* dt) const;
00662     virtual void print(std::ostream& out) const;
00663     virtual long append(const char* dt, const char* df, uint32_t nnew);
00664 
00665     virtual long select(const ibis::qContinuousRange&, void*) const {
00666         return -1;}
00667     virtual long select(const ibis::qContinuousRange&, void*,
00668                         ibis::bitvector&) const {
00669         return -1;}
00670 
00671     virtual long evaluate(const ibis::qContinuousRange& expr,
00672                           ibis::bitvector& hits) const;
00673     virtual long evaluate(const ibis::qDiscreteRange& expr,
00674                           ibis::bitvector& hits) const {
00675         return ibis::index::evaluate(expr, hits);
00676     }
00677 
00678     using ibis::bin::estimate;
00679     using ibis::bin::estimateCost;
00680     virtual void estimate(const ibis::qContinuousRange& expr,
00681                           ibis::bitvector& lower,
00682                           ibis::bitvector& upper) const;
00683     using ibis::bin::undecidable;
00684     virtual float undecidable(const ibis::qContinuousRange& expr,
00685                               ibis::bitvector& iffy) const;
00686 
00687     virtual INDEX_TYPE type() const {return AMBIT;}
00688     virtual const char* name() const {return "range-range";}
00689     virtual uint32_t numBins() const {return (nobs>1?nobs-1:0);}
00690     // bin boundaries and counts of each bin
00691     virtual void binBoundaries(std::vector<double>&) const;
00692     virtual void binWeights(std::vector<uint32_t>&) const;
00693     virtual void adjustLength(uint32_t nrows);
00694     virtual double getSum() const;
00695 
00696     virtual void speedTest(std::ostream& out) const;
00697     long append(const ibis::ambit& tail);
00698 
00699 protected:
00700     virtual double computeSum() const;
00701     virtual void clear();
00703     void construct(const char* f, const array_t<double>& bd);
00704     virtual size_t getSerialSize() const throw();
00705 
00706 private:
00707     // min and max of range nobs (the one that is not explicitly recorded)
00708     double max1, min1;
00709     std::vector<ibis::ambit*> sub;
00710 
00711     // private member functions
00712     int write32(int fptr) const;
00713     int write64(int fptr) const;
00714     int read(int fdes, size_t offset, const char *fn, const char *header);
00715     void print(std::ostream& out, const uint32_t tot, const double& lbound,
00716                const double& rbound) const;
00717 
00718     ambit(const ambit&);
00719     ambit& operator=(const ambit&);
00720 }; // ibis::ambit
00721 
00724 class ibis::pale : public ibis::bin {
00725 public:
00726     virtual ~pale() {clear();};
00727     pale(const ibis::column* c, ibis::fileManager::storage* st,
00728          size_t offset = 8);
00729     explicit pale(const ibis::bin& rhs); // convert from a ibis::bin
00730 
00731     virtual int read(const char* idxfile);
00732     virtual int read(ibis::fileManager::storage* st);
00733     virtual int write(const char* dt) const;
00734     virtual void print(std::ostream& out) const;
00735     virtual long append(const char* dt, const char* df, uint32_t nnew);
00736 
00737     virtual long select(const ibis::qContinuousRange&, void*) const {
00738         return -1;}
00739     virtual long select(const ibis::qContinuousRange&, void*,
00740                         ibis::bitvector&) const {
00741         return -1;}
00742 
00743     virtual long evaluate(const ibis::qContinuousRange& expr,
00744                           ibis::bitvector& hits) const;
00745     virtual long evaluate(const ibis::qDiscreteRange& expr,
00746                           ibis::bitvector& hits) const {
00747         return ibis::index::evaluate(expr, hits);
00748     }
00749 
00750     using ibis::bin::estimate;
00751     virtual void estimate(const ibis::qContinuousRange& expr,
00752                           ibis::bitvector& lower,
00753                           ibis::bitvector& upper) const;
00754     using ibis::bin::undecidable;
00755     virtual float undecidable(const ibis::qContinuousRange& expr,
00756                               ibis::bitvector& iffy) const;
00757 
00758     virtual INDEX_TYPE type() const {return PALE;}
00759     virtual const char* name() const {return "equality-range";}
00760     virtual uint32_t numBins() const {return (nobs>1?nobs-1:0);}
00761     // bin boundaries and counts of each bin
00762     virtual void binBoundaries(std::vector<double>&) const;
00763     virtual void binWeights(std::vector<uint32_t>&) const;
00764     virtual void adjustLength(uint32_t nrows);
00765 
00766     virtual void speedTest(std::ostream& out) const;
00767     long append(const ibis::pale& tail);
00768 
00769 protected:
00770     virtual void clear();
00771     virtual size_t getSerialSize() const throw();
00772 
00773 private:
00774     // private member variables
00775     std::vector<ibis::range*> sub;
00776 
00777     // private member functions
00778     int write32(int fptr) const;
00779     int write64(int fptr) const;
00780 
00781     pale(const pale&);
00782     pale& operator=(const pale&);
00783 }; // ibis::pale
00784 
00787 class ibis::pack : public ibis::bin {
00788 public:
00789     virtual ~pack() {clear();};
00790     pack(const ibis::column* c, ibis::fileManager::storage* st,
00791           size_t offset = 8);
00792     explicit pack(const ibis::bin& rhs); // convert from a ibis::bin
00793 
00794     virtual int read(const char* idxfile);
00795     virtual int read(ibis::fileManager::storage* st);
00796     virtual int write(const char* dt) const;
00797     virtual void print(std::ostream& out) const;
00798     virtual long append(const char* dt, const char* df, uint32_t nnew);
00799 
00800     virtual long select(const ibis::qContinuousRange&, void*) const {
00801         return -1;}
00802     virtual long select(const ibis::qContinuousRange&, void*,
00803                         ibis::bitvector&) const {
00804         return -1;}
00805 
00806     virtual long evaluate(const ibis::qContinuousRange& expr,
00807                           ibis::bitvector& hits) const;
00808     virtual long evaluate(const ibis::qDiscreteRange& expr,
00809                           ibis::bitvector& hits) const {
00810         return ibis::index::evaluate(expr, hits);}
00811 
00812     using ibis::bin::estimate;
00813     virtual void estimate(const ibis::qContinuousRange& expr,
00814                           ibis::bitvector& lower,
00815                           ibis::bitvector& upper) const;
00816     using ibis::bin::undecidable;
00817     virtual float undecidable(const ibis::qContinuousRange& expr,
00818                               ibis::bitvector& iffy) const;
00819 
00820     virtual INDEX_TYPE type() const {return PACK;}
00821     virtual const char* name() const {return "range-equality";}
00822     virtual uint32_t numBins() const {return (nobs>1?nobs-1:0);}
00823     // bin boundaries and counts of each bin
00824     virtual void binBoundaries(std::vector<double>&) const;
00825     virtual void binWeights(std::vector<uint32_t>&) const;
00826     virtual void adjustLength(uint32_t nrows);
00827     virtual double getSum() const;
00828 
00829     virtual void speedTest(std::ostream& out) const;
00830     long append(const ibis::pack& tail);
00831 
00832 protected:
00833     virtual double computeSum() const;
00834     virtual void clear();
00835     virtual size_t getSerialSize() const throw();
00836 
00837 private:
00838     // private member variables
00839     // min and max of range nobs (the one that is not explicitly recorded)
00840     double max1, min1;
00841     std::vector<ibis::bin*> sub;
00842 
00843     // private member functions
00844     int write32(int fptr) const;
00845     int write64(int fptr) const;
00846 
00847     pack(const pack&);
00848     pack& operator=(const pack&);
00849 }; // ibis::pack
00850 
00853 class ibis::zone : public ibis::bin {
00854 public:
00855     virtual ~zone() {clear();};
00856     zone(const ibis::column* c, ibis::fileManager::storage* st,
00857          size_t offset = 8);
00858     explicit zone(const ibis::bin& rhs); // convert from a ibis::bin
00859 
00860     virtual int read(const char* idxfile);
00861     virtual int read(ibis::fileManager::storage* st);
00862     virtual int write(const char* dt) const;
00863     virtual void print(std::ostream& out) const;
00864     virtual long append(const char* dt, const char* df, uint32_t nnew);
00865 
00866     virtual long evaluate(const ibis::qContinuousRange& expr,
00867                           ibis::bitvector& hits) const;
00868     virtual long evaluate(const ibis::qDiscreteRange& expr,
00869                           ibis::bitvector& hits) const {
00870         return ibis::index::evaluate(expr, hits);
00871     }
00872 
00873     using ibis::bin::estimate;
00874     virtual void estimate(const ibis::qContinuousRange& expr,
00875                           ibis::bitvector& lower,
00876                           ibis::bitvector& upper) const;
00877     using ibis::bin::undecidable;
00878     virtual float undecidable(const ibis::qContinuousRange& expr,
00879                               ibis::bitvector& iffy) const;
00880 
00881     virtual INDEX_TYPE type() const {return ZONE;}
00882     virtual const char* name() const {return "equality-equality";}
00883     virtual uint32_t numBins() const {return (nobs>1?nobs-1:0);}
00884     // bin boundaries and counts of each bin
00885     virtual void binBoundaries(std::vector<double>&) const;
00886     virtual void binWeights(std::vector<uint32_t>&) const;
00887     virtual void adjustLength(uint32_t nrows);
00888 
00889     virtual void speedTest(std::ostream& out) const;
00890     long append(const ibis::zone& tail);
00891 
00892 protected:
00893     virtual void clear();
00894     virtual size_t getSerialSize() const throw();
00895 
00896 private:
00897     // private member variable
00898     std::vector<ibis::bin*> sub;
00899 
00900     // private member functions
00901     int write32(int fptr) const;
00902     int write64(int fptr) const;
00903 
00904     zone(const zone&);
00905     zone& operator=(const zone&);
00906 }; // ibis::zone
00907 
00913 class ibis::fuge : public ibis::bin {
00914 public:
00915     virtual ~fuge() {clear();};
00916     fuge(const ibis::column* c, ibis::fileManager::storage* st,
00917          size_t offset = 8);
00918     fuge(const ibis::column*, const char*);
00919     explicit fuge(const ibis::bin& rhs); // convert from a ibis::bin
00920 
00921     virtual int read(const char* idxfile);
00922     virtual int read(ibis::fileManager::storage* st);
00923     virtual void print(std::ostream& out) const;
00924     virtual int write(const char* dt) const;
00925     virtual long append(const char* dt, const char* df, uint32_t nnew);
00926 
00927     virtual long evaluate(const ibis::qContinuousRange& expr,
00928                           ibis::bitvector& hits) const;
00929     virtual long evaluate(const ibis::qDiscreteRange& expr,
00930                           ibis::bitvector& hits) const {
00931         return ibis::index::evaluate(expr, hits);
00932     }
00933 
00934     using ibis::bin::estimate;
00935     virtual void estimate(const ibis::qContinuousRange& expr,
00936                           ibis::bitvector& lower,
00937                           ibis::bitvector& upper) const;
00938 
00939     virtual INDEX_TYPE type() const {return FUGE;}
00940     virtual const char* name() const {return "interval-equality";}
00941     virtual void adjustLength(uint32_t nrows);
00942 
00943     long append(const ibis::fuge& tail);
00944 
00945 protected:
00946     virtual void clear() {clearCoarse(); ibis::bin::clear();}
00947     virtual size_t getSerialSize() const throw();
00948 
00949 private:
00950     // private member variable
00951     mutable array_t<bitvector*> cbits;
00952     array_t<uint32_t> cbounds;
00953     mutable array_t<int32_t> coffset32;
00954     mutable array_t<int64_t> coffset64;
00955 
00956     void coarsen(); // given fine level, add coarse level
00957     void activateCoarse() const; // activate all coarse level bitmaps
00958     void activateCoarse(uint32_t i) const; // activate one bitmap
00959     void activateCoarse(uint32_t i, uint32_t j) const;
00960 
00961     int writeCoarse32(int fdes) const;
00962     int writeCoarse64(int fdes) const;
00963     int readCoarse(const char *fn);
00964     void clearCoarse();
00965 
00967     long coarseEstimate(uint32_t lo, uint32_t hi) const;
00969     long coarseEvaluate(uint32_t lo, uint32_t hi, ibis::bitvector& res) const;
00970 
00971     fuge(const fuge&);
00972     fuge& operator=(const fuge&);
00973 }; // ibis::fuge
00974 
00978 class ibis::egale : public ibis::bin {
00979 public:
00980     virtual ~egale() {clear();};
00981     egale(const ibis::column* c = 0, const char* f = 0,
00982           const uint32_t nbase = 2);
00983     egale(const ibis::column* c, ibis::fileManager::storage* st,
00984           size_t offset = 8);
00985     egale(const ibis::bin& rhs, const uint32_t nbase = 2);
00986 
00987     virtual int read(const char* idxfile);
00988     virtual int read(ibis::fileManager::storage* st);
00989     virtual int write(const char* dt) const;
00990     virtual void print(std::ostream& out) const;
00991     virtual long append(const char* dt, const char* df, uint32_t nnew);
00992 
00993     virtual long evaluate(const ibis::qContinuousRange& expr,
00994                           ibis::bitvector& hits) const;
00995     virtual long evaluate(const ibis::qDiscreteRange& expr,
00996                           ibis::bitvector& hits) const {
00997         return ibis::index::evaluate(expr, hits);
00998     }
00999 
01000     using ibis::bin::estimate;
01001     virtual void estimate(const ibis::qContinuousRange& expr,
01002                           ibis::bitvector& lower,
01003                           ibis::bitvector& upper) const;
01004     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
01005     using ibis::bin::undecidable;
01006     virtual float undecidable(const ibis::qContinuousRange& expr,
01007                               ibis::bitvector& iffy) const;
01008 
01009     virtual INDEX_TYPE type() const {return EGALE;}
01010     virtual const char* name() const {return "MCBin";}
01011     // bin boundaries and counts of each bin
01012     virtual void binBoundaries(std::vector<double>& b) const;
01013     virtual void binWeights(std::vector<uint32_t>& b) const;
01014     virtual double getSum() const;
01015 
01016     virtual void speedTest(std::ostream& out) const;
01017     long append(const ibis::egale& tail);
01018     long append(const array_t<uint32_t>& ind);
01019 
01020 protected:
01021     // protected member variables
01022     uint32_t nbits;             // number of bitvectors, (size of bits)
01023     uint32_t nbases;            // size of array bases
01024     array_t<uint32_t> cnts;     // number of records in each bin
01025     array_t<uint32_t> bases;    // the size of the bases used
01026 
01027     // protected member functions
01028     egale(const ibis::column* c, const char* f, const array_t<double>& bd,
01029           const array_t<uint32_t> bs);
01030     void addBits_(uint32_t ib, uint32_t ie, ibis::bitvector& res) const;
01031     virtual double computeSum() const;
01032     virtual void clear() {
01033         cnts.clear(); bases.clear();
01034         ibis::bin::clear();
01035     }
01036 
01037     int write32(int fdes) const;
01038     int write64(int fdes) const;
01039     void construct(const char* f);
01040     virtual size_t getSerialSize() const throw();
01041 
01042 private:
01043     // private member functions
01044     void setBit(const uint32_t i, const double val);
01045     void convert();
01046 
01047     void evalEQ(ibis::bitvector& res, uint32_t b) const;
01048     void evalLE(ibis::bitvector& res, uint32_t b) const;
01049     void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const;
01050 
01051     egale(const egale&);
01052     egale& operator=(const egale&);
01053 }; // ibis::egale
01054 
01058 class ibis::moins : public ibis::egale {
01059 public:
01060     virtual int write(const char* dt) const;
01061     virtual void print(std::ostream& out) const;
01062     virtual long append(const char* dt, const char* df, uint32_t nnew);
01063 
01064     virtual long select(const ibis::qContinuousRange&, void*) const {
01065         return -1;}
01066     virtual long select(const ibis::qContinuousRange&, void*,
01067                         ibis::bitvector&) const {
01068         return -1;}
01069 
01070     virtual long evaluate(const ibis::qContinuousRange& expr,
01071                           ibis::bitvector& hits) const;
01072     virtual long evaluate(const ibis::qDiscreteRange& expr,
01073                           ibis::bitvector& hits) const {
01074         return ibis::index::evaluate(expr, hits);}
01075 
01076     using ibis::egale::estimate;
01077     virtual void estimate(const ibis::qContinuousRange& expr,
01078                           ibis::bitvector& lower,
01079                           ibis::bitvector& upper) const;
01080     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
01081     virtual INDEX_TYPE type() const {return MOINS;}
01082     virtual const char* name() const {return "MCBRange";}
01083 
01084     virtual ~moins() {clear();};
01085     moins(const ibis::column* c = 0, const char* f = 0,
01086           const uint32_t nbase = 2);
01087     moins(const ibis::column* c, ibis::fileManager::storage* st,
01088           size_t offset = 8);
01089     moins(const ibis::bin& rhs, const uint32_t nbase = 2);
01090 
01091     virtual void speedTest(std::ostream& out) const;
01092     virtual double getSum() const;
01093 
01094     long append(const ibis::moins& tail);
01095     long append(const array_t<uint32_t>& ind);
01096 
01097 protected:
01098     virtual double computeSum() const;
01099 
01100 private:
01101     // private member functions
01102     moins(const ibis::column* c, const char* f, const array_t<double>& bd,
01103           const array_t<uint32_t> bs);
01104     void convert();
01105 
01106     void evalEQ(ibis::bitvector& res, uint32_t b) const;
01107     void evalLE(ibis::bitvector& res, uint32_t b) const;
01108     void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const;
01109 
01110     moins(const moins&);
01111     moins& operator=(const moins&);
01112 }; // ibis::moins
01113 
01117 class ibis::entre : public ibis::egale {
01118 public:
01119     virtual ~entre() {clear();};
01120     entre(const ibis::column* c = 0, const char* f = 0,
01121           const uint32_t nbase = 2);
01122     entre(const ibis::column* c, ibis::fileManager::storage* st,
01123           size_t offset = 8);
01124     entre(const ibis::bin& rhs, const uint32_t nbase = 2);
01125 
01126     virtual int write(const char* dt) const;
01127     virtual void print(std::ostream& out) const;
01128     virtual long append(const char* dt, const char* df, uint32_t nnew);
01129 
01130     virtual long select(const ibis::qContinuousRange&, void*) const {
01131         return -1;}
01132     virtual long select(const ibis::qContinuousRange&, void*,
01133                         ibis::bitvector&) const {
01134         return -1;}
01135 
01136     virtual long evaluate(const ibis::qContinuousRange& expr,
01137                           ibis::bitvector& hits) const;
01138     virtual long evaluate(const ibis::qDiscreteRange& expr,
01139                           ibis::bitvector& hits) const {
01140         return ibis::index::evaluate(expr, hits);}
01141 
01142     using ibis::egale::estimate;
01143     virtual void estimate(const ibis::qContinuousRange& expr,
01144                           ibis::bitvector& lower,
01145                           ibis::bitvector& upper) const;
01146     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
01147     virtual INDEX_TYPE type() const {return ENTRE;}
01148     virtual const char* name() const {return "MCBInterval";}
01149 
01150     virtual void speedTest(std::ostream& out) const;
01151     virtual double getSum() const;
01152 
01153     long append(const ibis::entre& tail);
01154     long append(const array_t<uint32_t>& ind);
01155 
01156 protected:
01157     virtual double computeSum() const;
01158 
01159 private:
01160     // private member functions
01161     entre(const ibis::column* c, const char* f, const array_t<double>& bd,
01162           const array_t<uint32_t> bs);
01163     void convert();
01164 
01165     void evalEQ(ibis::bitvector& res, uint32_t b) const;
01166     void evalLE(ibis::bitvector& res, uint32_t b) const;
01167     void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const;
01168 
01169     entre(const entre&);
01170     entre& operator=(const entre&);
01171 }; // ibis::entre
01172 
01179 class ibis::bak : public ibis::bin {
01180 public:
01181     virtual ~bak() {clear();};
01182     bak(const ibis::column* c=0, const char* f=0);
01183     bak(const ibis::column* c, ibis::fileManager::storage* st,
01184         size_t offset = 8) : ibis::bin(c, st, offset) {};
01185 
01186     virtual void print(std::ostream& out) const;
01187     virtual int write(const char* dt) const; // write to the named file
01188     using ibis::bin::read;
01189     virtual int read(const char* idxfile);
01190     virtual long append(const char* dt, const char* df, uint32_t nnew);
01191     virtual INDEX_TYPE type() const {return BAK;}
01192     virtual const char* name() const
01193     {return "equality code on mapped values";}
01194     // bin boundaries and counts of each bin
01195     virtual void binBoundaries(std::vector<double>&) const;
01196     virtual void binWeights(std::vector<uint32_t>&) const;
01197     // expand/contract the boundaries of a range condition
01198     virtual int  expandRange(ibis::qContinuousRange& rng) const;
01199     virtual int  contractRange(ibis::qContinuousRange& rng) const;
01200 
01201     long append(const ibis::bin& tail);
01202 
01203     // a simple structure to record the position of the values mapped to the
01204     // same value.  The bitvector marked the locations of the values and the
01205     // min and max record the actual minimum and maximum value encountered.
01206     struct grain {
01207         double min, max;
01208         ibis::bitvector* loc;
01209 
01210         // the default construct, user to explicitly allocated the bitvector
01211         grain() : min(DBL_MAX), max(-DBL_MAX), loc(0) {}
01212         ~grain() {delete loc;}
01213     };
01214 
01215     typedef std::map< double, grain > bakMap;
01216 
01217 
01218 protected:
01219 
01220     // reads all values and records positions in bmap
01221     void mapValues(const char* f, bakMap& bmap) const;
01222     void printMap(std::ostream& out, const bakMap& bmap) const;
01223 
01224     virtual uint32_t locate(const double& val) const;
01225     virtual void locate(const ibis::qContinuousRange& expr,
01226                         uint32_t& cand0, uint32_t& cand1) const {
01227         ibis::bin::locate(expr, cand0, cand1);
01228     }
01229     virtual void locate(const ibis::qContinuousRange& expr,
01230                         uint32_t& cand0, uint32_t& cand1,
01231                         uint32_t& hit0, uint32_t& hit1) const {
01232         ibis::bin::locate(expr, cand0, cand1, hit0, hit1);
01233     }
01234 
01235 private:
01236     // coverts the std::map structure into the structure defined in ibis::bin
01237     void construct(bakMap& bmap);
01238 
01239     bak(const bak&);
01240     const bak& operator&=(const bak&);
01241 }; // ibis::bak
01242 
01248 class ibis::bak2 : public ibis::bin {
01249 public:
01250     virtual ~bak2() {clear();};
01251     bak2(const ibis::column* c=0, const char* f=0);
01252     bak2(const ibis::column* c, ibis::fileManager::storage* st,
01253          size_t offset = 8) : ibis::bin(c, st, offset) {};
01254 
01255     virtual void print(std::ostream& out) const;
01256     virtual int write(const char* dt) const; // write to the named file
01257     using ibis::bin::read;
01258     virtual int read(const char* idxfile);
01259     virtual long append(const char* dt, const char* df, uint32_t nnew);
01260     virtual INDEX_TYPE type() const {return BAK;}
01261     virtual const char* name() const
01262     {return "equality code on mapped values";}
01263     // bin boundaries and counts of each bin
01264     virtual void binBoundaries(std::vector<double>&) const;
01265     virtual void binWeights(std::vector<uint32_t>&) const;
01266     // expand/contract the boundaries of a range condition
01267     virtual int  expandRange(ibis::qContinuousRange& rng) const;
01268     virtual int  contractRange(ibis::qContinuousRange& rng) const;
01269 
01270     long append(const ibis::bin& tail);
01271 
01276     struct grain {
01277         double minm, maxm, minp, maxp;
01278         ibis::bitvector* locm; 
01279         ibis::bitvector* loce; 
01280         ibis::bitvector* locp; 
01281 
01282         // the default construct, user to explicitly allocated the bitvector
01283         grain() : minm(DBL_MAX), maxm(-DBL_MAX), minp(DBL_MAX), maxp(-DBL_MAX),
01284                   locm(0), loce(0), locp(0) {}
01285         ~grain() {delete locm; delete loce; delete locp;}
01286     };
01287 
01288     typedef std::map< double, grain > bakMap;
01289 
01290 
01291 protected:
01292 
01294     void mapValues(const char* f, bakMap& bmap) const;
01295     void printMap(std::ostream& out, const bakMap& bmap) const;
01296 
01297     virtual uint32_t locate(const double& val) const;
01298     virtual void locate(const ibis::qContinuousRange& expr,
01299                         uint32_t& cand0, uint32_t& cand1) const {
01300         ibis::bin::locate(expr, cand0, cand1);
01301     }
01302     virtual void locate(const ibis::qContinuousRange& expr,
01303                         uint32_t& cand0, uint32_t& cand1,
01304                         uint32_t& hit0, uint32_t& hit1) const {
01305         ibis::bin::locate(expr, cand0, cand1, hit0, hit1);
01306     }
01307 
01308 private:
01311     void construct(bakMap& bmap);
01312 
01313     bak2(const bak2&);
01314     bak2& operator=(const bak2&);
01315 }; // ibis::bak2
01316 
01317 #endif // IBIS_IBIN_H

Make It A Bit Faster
Contact us
Disclaimers
FastBit source code
FastBit mailing list archive