lazy_list.hpp

Go to the documentation of this file.

#ifndef LAZY_LIST_HPP
#define LAZY_LIST_HPP 1

#include <cassert>
#include "universal_error.hpp"
#include <algorithm>

using std::vector;
using std::size_t;

template<class T> class LazyList
{
public:

  virtual size_t size(void) const = 0;

  virtual T operator[](const size_t i) const = 0;

  T at(const size_t i) const
  {
    assert(i<size());
    return (*this)[i];
  }

  virtual ~LazyList(void) {}
};

template<class T> vector<T> serial_generate(const LazyList<T>& ll)
{
  vector<T> res(ll.size());
  for(size_t i=0, endp=res.size();i<endp;++i)
    res[i] = ll[i];
  return res;
}

template<class T> vector<T> termwise_product(const vector<T>& v,
                                             const T& s)
{
  class Multiplier: public LazyList<T>
  {
  public:

    Multiplier(const vector<T>& v_i,
               const T& s_i):
      v_(v_i), s_(s_i) {}

    size_t size(void) const
    {
      return v_.size();
    }

    T operator[](size_t i) const
    {
      return s_*v_[i];
    }

  private:
    const vector<T>& v_;
    const T& s_;
  } multiplier(v,s);

  return serial_generate(multiplier);
}

template<class T> vector<T> trim_top(const vector<T>& v,
                                     const size_t max_index)
{
  class Trimmer: public LazyList<T>
  {
  public:

    Trimmer(const vector<T>& v_i,
            const size_t max_index_i):
      v_(v_i), max_index_(max_index_i) {}

    size_t getLength(void) const
    {
      return max_index_;
    }

    T operator()(size_t i) const
    {
      return v_[i];
    }

  private:
    const vector<T>& v_;
    const size_t max_index_;
  } trimmer(v,max_index);

  return serial_generate(trimmer);
}

template<class T> int ElementNumber(vector<vector<T> > const& vec)
{
  size_t res=0;
  for(size_t i=0;i<vec.size();++i)
    res+=vec[i].size();
  return static_cast<int>(res);
}

template<class T> void ListExchange(vector<T> &vec,vector<int> const& indeces,
                                    vector<T> const& data)
{
  if(indeces.size()!=data.size())
    {
      UniversalError eo("Matching vectors are not the same length");
      eo.AddEntry("indeces length",static_cast<double>(indeces.size()));
      eo.AddEntry("data length",static_cast<double>(data.size()));
      throw eo;
    }
  for(size_t i=0;i<indeces.size();++i)
    vec[static_cast<size_t>(indeces[i])]=data[i];
}

template<class T> T lazy_sum(const LazyList<T>& i2m)
{
  T res = i2m[0];
  for(size_t i=1;i<i2m.size();++i)
    res += i2m[i];
  return res;
}

template<class T> T lazy_max(const LazyList<T>& i2m)
{
  T res = i2m(0);
  for(size_t i=1;i<i2m.getLength();++i)
    res = max(res,i2m(i));
  return res;
}

template<class T> T lazy_min(const LazyList<T>& i2m)
{
  T res = i2m[0];
  for(size_t i=1;i<i2m.size();++i)
    res = std::min(res,i2m[i]);
  return res;
}

template<class T> class Echo: public LazyList<T>
{
public:

  explicit Echo(const vector<T>& v):
    v_(v) {}

  size_t size(void) const
  {
    return v_.size();
  }

  T operator[](size_t i) const
  {
    return v_[i];
  }

private:
  const vector<T>& v_;
};

template<class T> class ContiguousChunk: public LazyList<T>
{
public:

  ContiguousChunk(const LazyList<T>& i2m,
                  size_t low,
                  size_t high):
    i2m_(i2m), low_(low), high_(high) 
  {
    assert(high_>low_);
  }

  size_t size(void) const
  {
    return high_-low_;
  }

  T operator[](size_t i) const
  {
    return i2m_(i+low_);
  }

private:
  const LazyList<T>& i2m_;
  const size_t low_;
  const size_t high_;
};

#endif // LAZY_LIST_HPP