Distribute_Block.h

#ifndef QNANO_NEW_DISTRIBUTE_BLOCK_DEFINED_H_
#define QNANO_NEW_DISTRIBUTE_BLOCK_DEFINED_H_

#include <iostream>
#include <cstdlib>

class Distribute_Block
{
private:
  size_t total_size;
  size_t nr_blocks;
  size_t nr_onemore;

public:
  size_t get_total_size() const{return total_size;}
  size_t get_nr_blocks() const{return nr_blocks;}
  size_t get_floor_blocksize() const
  {
    return get_total_size()/get_nr_blocks();
  }
  size_t get_blocksize(size_t bl) const
  {
    if(bl<0 || bl>=nr_blocks)
    {
      std::cerr<<"DistributeBlock out of bound: "<<bl<<"/"<<nr_blocks<<std::endl
;
      exit(1);
    }
    else if(bl<nr_onemore)
    {
      return get_total_size()/get_nr_blocks()+1;
    }
    else 
    {
      return get_total_size()/get_nr_blocks();
    }
  }
  size_t get_start(size_t bl) const
  {
    if(bl<0 || bl>=get_nr_blocks())
    {
      std::cerr<<"DistributeBlock out of bound: "<<bl<<"/"<<get_nr_blocks()<<std::endl;
      exit(1);
    }
    if(bl<nr_onemore)
    {
      return bl*get_blocksize(0);
    }
    else
    {
      return bl*get_floor_blocksize()+nr_onemore;
    }
  }
  size_t lookup_element(size_t el) const
  {
    size_t max_size_before_onemore = (get_floor_blocksize()+1)*nr_onemore;
    if(el<max_size_before_onemore) return el/(get_floor_blocksize()+1);
    return (el-max_size_before_onemore)/(get_floor_blocksize())+nr_onemore;
  }
  virtual void print() const
  {
    for(size_t i=0;i<get_nr_blocks();i++){
      std::cout<<i<<": start: "<<get_start(i)<<" blocksize: "<<get_blocksize(i)<<std::endl;
    }
  }
  void initialize(size_t total_size_, size_t nr_blocks_)
  { 
    total_size=total_size_;
    nr_blocks=nr_blocks_; 
    size_t div=total_size/nr_blocks;
    nr_onemore=total_size-div*nr_blocks;
  }
  Distribute_Block(size_t total_size_=0, size_t nr_blocks_=1) 
  {
    initialize(total_size_, nr_blocks_);
  }
};


#endif