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
![]() |