sequence.hh

Go to the documentation of this file.

 
#ifndef sequence_hh
#define sequence_hh
 
#include <vector>
#include <algorithm>
#include <set>
#include <queue>
#include <stdarg.h>
#include <initializer_list>
#include "basics/typedefs.hh"
#include "basics/outputOperator.hh"
#include "basics/exceptions.hh"
#include "basics/pointerOutput.hh"
 
#define SeqInput_D 0
 
namespace concepts {
 
  // forward declaration
  template<class F>
  class BaseSequence;
 
  // ************************************************************** Sequence **
 
  template<class F>
  class Sequence : public BaseSequence<F> {
  public:
    Sequence() : BaseSequence<F>() {}
    Sequence(const int N) : BaseSequence<F>(N) {}
    template<class G>
    Sequence(const G& seq) : BaseSequence<F>(seq) {}
    virtual ~Sequence() {}
  };
 
  template<>
  class Sequence<bool>;
 
 
 // *********************************************************** BaseSequence **
 
  template<class F>
  class BaseSequence : public std::vector<F>, public concepts::OutputOperator {
  public:
    BaseSequence() : std::vector<F>() {}
    BaseSequence(const std::string& str);
 
    BaseSequence(std::queue<F> q);
 
    BaseSequence(const int N);
 
    template<class G>
    BaseSequence(const G& seq) 
      : std::vector<F>(seq) {}
    virtual ~BaseSequence() {}
 
 
    inline operator Sequence<F>() const { return *this; }
 
    inline operator std::set<F>() const {
      std::set<F> set;
      for(typename std::vector<F>::
      const_iterator i = this->begin(); i != this->end(); ++i)
        set.insert(*i);
      return set;
    }
 
    template<class G, class H>
    inline Sequence<G> operator()(G (H::*fun)() const) const;
    template<class G, class H>
    inline Sequence<G*> operator()(G& (H::*fun)() const) const;
    template<class G, class H, class I, class J>
    inline Sequence<G> operator()(G (H::*fun)(I) const, J i) const;
 
    // Return set union
    inline std::vector<bool> operator||(const Sequence<F>& set) const;
    // Return set intersection
    inline std::vector<bool> operator&&(const Sequence<F>& set) const;
 
 
    // Return a sequence with appended \c seq
    inline Sequence<F> operator+(const Sequence<F>& seq) const;
    // Return sequence, where \c val is not inside
    inline Sequence<F> operator-(const F& val) const;
    // Return sequence, where are elements of \c seq are not inside
    inline Sequence<F> operator-(const Sequence<F>& seq) const; 
    inline std::vector<bool> operator==(const F val) const;
    inline Sequence<F> operator()(const BaseSequence<bool>& seq) const;
 
    inline bool exist(F val) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  template<class F>
  std::istream& operator>>(std::istream& is, BaseSequence<F>& seq) {
    F val;
    while(!is.eof()) {
      is >> val;
      DEBUGL(SeqInput_D, "val = " << val);
      if (!is.fail())
  seq.push_back(val);
    }
    return is;
  }
 
  template<class F>
  BaseSequence<F>::BaseSequence(const std::string& str) {
    if (str.size() > 0) {
      std::stringstream s;
      s << str;
      s >> *this;
    }
  }
 
  template<class F>
  BaseSequence<F>::BaseSequence(std::queue<F> q) {
    while(!q.empty()) {
      // take the first element of the queue
      this->push_back(q.front());
      // delete the first element
      q.pop();
    }
  }
 
 
  template<class F>
  BaseSequence<F>::BaseSequence(const int N)
  {
    this->resize(N);
  }
 
  // e.g. concepts::Key::key()
  template<class F>
  template<class G, class H>
  Sequence<G> BaseSequence<F>::operator()(G (H::*fun)() const) const {
    std::vector<G> seq;
    for(typename std::vector<F>::
    const_iterator i = this->begin(); i != this->end(); ++i) {
      G val = ((*i)->*fun)();
      seq.push_back(val);
    }
    return seq;
  }
  // e.g. concepts::Connector1::key()
  template<class F>
  template<class G, class H>
  Sequence<G*> BaseSequence<F>::operator()(G& (H::*fun)() const) const {
    std::vector<G*> seq;
    for(typename std::vector<F>::
    const_iterator i = this->begin(); i != this->end();++i) {
      G* val = &((*i)->*fun)();
      seq.push_back(val);
    }
    return seq;
  }
  // e.g. concepts::Connector1::vertex(uint i)
  template<class F>
  template<class G, class H, class I, class J>
  Sequence<G> BaseSequence<F>::operator()(G (H::*fun)(I) const, J i) const {
    std::vector<G> seq;
    for(typename std::vector<F>::
    const_iterator is = this->begin(); is != this->end();++is) {
      G val = ((*is)->*fun)(i);
      seq.push_back(val);
    }
    return seq;
  }
 
  template<class F>
  std::vector<bool> BaseSequence<F>::operator||(const Sequence<F>& seq) const 
  {
    conceptsAssert(this->size() == seq.size(), Assertion());
    std::vector<bool> result(this->size(), false);
 
    std::vector<bool>::iterator i = result.begin();
    typename std::vector<F>::
      const_iterator it = this->begin(), is = seq.begin();
    for(; it != this->end(); ++it, ++is, ++i) 
      *i = *it || *is;
    return result;
  }
 
  template<class F>
  std::vector<bool> BaseSequence<F>::operator&&(const Sequence<F>& seq) const 
  {
    conceptsAssert(this->size() == seq.size(), Assertion());
    std::vector<bool> result(this->size(), false);
 
    std::vector<bool>::iterator i = result.begin();
    typename std::vector<F>::
      const_iterator it = this->begin(), is = seq.begin();
    for(; it != this->end(); ++it, ++is, ++i) 
      *i = *it && *is;
    return result;
  }
 
  template<class F>
  Sequence<F> BaseSequence<F>::operator-(const Sequence<F>& seq) const {
    std::set<F> set = seq;
    std::vector<F> result;
    result.reserve(this->size());
    for(typename std::vector<F>::
    const_iterator i = this->begin(); i != this->end(); ++i)
      if (set.find(*i) == set.end()) result.push_back(*i);
    return result;
  }
 
  template<class F>
  Sequence<F> BaseSequence<F>::operator-(const F& val) const {
    std::vector<F> result;
    result.reserve(this->size());
    for(typename std::vector<F>::
    const_iterator i = this->begin(); i != this->end(); ++i)
      if (!(*i == val)) result.push_back(*i);
    return result;    
  }
 
  template<class F>
  Sequence<F> BaseSequence<F>::operator+(const Sequence<F>& seq) const {
    std::vector<F> result(this->size() + seq.size());
    typename std::vector<F>::iterator i = result.begin();
    typename std::vector<F>::
      const_iterator it = this->begin(), is = seq.begin();
    for(; it != this->end(); ++it, ++i) *i = *it;
    for(; is != seq.end(); ++is, ++i) *i = *is;
    return result;
  }
 
  template<class F>
  std::vector<bool> BaseSequence<F>::operator==(const F val) const {
    std::vector<bool> result(this->size());
//     uint i = 0;
//     for(typename std::vector<F>::
//    const_iterator is = this->begin(); is != this->end(); ++is, ++i)
//       if (*is == val) result.push_back(i);
    std::vector<bool>::iterator i = result.begin();
    for(typename std::vector<F>::
    const_iterator it = this->begin(); it != this->end(); ++it, ++i)
      *i = *it == val;
    return result;
  }
 
//   template<class F>
//   Sequence<F> BaseSequence<F>::operator()(const Sequence<uint>& seq) const {
//     std::vector<F> result(seq.size());
//     std::vector<uint> sortedIdx = seq;
//     sort(sortedIdx.begin(), sortedIdx.end());
//     sortedIdx.erase(unique(sortedIdx.begin(), sortedIdx.end()), 
//        sortedIdx.end());
 
//     uint i = 0;
//     std::vector<uint>::const_iterator is = sortedIdx.begin();
//     typename std::vector<F>::const_iterator it = this->begin();
//     typename std::vector<F>::iterator ir = result.begin();
//     while(is != sortedIdx.end() && it != this->end()) {
//       if (i == *is) {
//  *ir = *it;
//  ++ir;
//  ++is;
//       }
//       ++it; ++i;
//     }
//     conceptsAssert(is == sortedIdx.end(), Assertion());
//     return result;
//   }
 
  template<class F>
  Sequence<F> BaseSequence<F>::operator()(const BaseSequence<bool>& seq) const {
    conceptsAssert(this->size() == seq.size(), Assertion());
 
    std::vector<F> result(count(seq.begin(), seq.end(), true));
    if (result.size() > 0) {
      std::vector<bool>::const_iterator is = seq.begin();
      typename std::vector<F>::const_iterator it = this->begin();
      typename std::vector<F>::iterator i = result.begin();
      for(; it != this->end(); ++it, ++is)
        if (*is) {
          *i = *it;
          ++i;
        }
    }
    return result;
  }
 
  template<class F>
    bool BaseSequence<F>::exist(F val) const {
      for(typename std::vector<F>::
          const_iterator i = this->begin(); i != this->end(); ++i)
        {
          if (*i == val) return true;
        } 
      return false;
      //      return this->find(val) != this->end();
    }
 
  template<class F>
    std::ostream& BaseSequence<F>::info(std::ostream& os) const {
      os << concepts::typeOf(*this)<<"(";
      for(typename std::vector<F>::
          const_iterator i = this->begin(); i != this->end();) {
        pointerOutput(os, *i);
        if (++i != this->end()) os << ", ";
      }
      return os << ")";
    }
 
  // ******************************************************** Sequence<bool> **
 
  template<>
  class Sequence<bool> : public BaseSequence<bool> {
  public:
    Sequence() : BaseSequence<bool>() {}
    template<class F>
    Sequence(const F& seq) : BaseSequence<bool>(seq) {}
    virtual ~Sequence() {}
    
    Sequence<bool> operator&(const Sequence<bool>& seq) const;
    Sequence<bool> operator|(const Sequence<bool>& seq) const;
    Sequence<bool> operator~() const;
  };
 
  // ************************************************************ makeSequence **
 
  template<class F>
  Sequence<F> makeSequence(uint n, const F& first, ...) {
    Sequence<F> data(n);
    data[0] = first;
 
    va_list param;
    va_start(param, first);
    for(uint i = 1; i < n; ++i)
      data[i] = va_arg(param, F);
    va_end(param);  
    return data;
  }
 
  template<class F>
  Sequence<F> makeSequence(std::initializer_list<F> list) {
    uint n = list.size();
    Sequence<F> data(n);
    uint idx = 0;
    for( F elem : list )
      data[idx++] = elem;
    return data;
  }
  
  // ************************************************* makeEquidistantSequence **
 
  template<class F>
  Sequence<F> makeEquidistantSequence(uint n, const F& first, const F& diff) 
  {
    Sequence<F> data(n);
    typename Sequence<F>::iterator i = data.begin();
    F current = *i++ = first;
    for(; i != data.end(); ++i) 
      *i++ = (current+=diff);
    return data;
  }
 
  // ****************************************************** makeRangeSequence **
 
  Sequence<int> makeRangeSequence(uint n);
 
  Sequence<int> makeRangeSequence(int start, int afterlast);
 
  Sequence<int> makeRangeSequence(int start, int afterlast, uint dist);
 
  // ************************************************************ operator*() **
 
  template<class F, class G>  
  Sequence<typename Combtype<F,G>::type> 
  operator*(const Sequence<F> seq1, const Sequence<G> seq2) 
  {
    conceptsAssert(seq1.size() == seq2.size(), Assertion());
 
    Sequence<typename Combtype<F,G>::type> seq;
    typename Sequence<F>::const_iterator i1 = seq1.begin();
    typename Sequence<F>::const_iterator i2 = seq2.begin();
    for(; i1 != seq1.end(); )
      seq.push_back( *i1++ * *i2++);
    return seq;
  }
 
  template<class F, class G>  
  Sequence<typename Combtype<F,G>::type> 
  operator*(const Sequence<F> seq1, const G factor) 
  {
    Sequence<typename Combtype<F,G>::type> seq;
    typename Sequence<F>::const_iterator i1 = seq1.begin();
    for(; i1 != seq1.end(); )
      seq.push_back( *i1++ * factor);
    return seq;
  }
 
  // ************************************************************ operator/() **
 
  template<class F, class G>  
  Sequence<typename Combtype<F,G>::type> 
  operator/(const Sequence<F> seq1, const Sequence<G> seq2) 
  {
    conceptsAssert(seq1.size() == seq2.size(), Assertion());
 
    Sequence<typename Combtype<F,G>::type> seq;
    typename Sequence<F>::const_iterator i1 = seq1.begin();
    typename Sequence<F>::const_iterator i2 = seq2.begin();
    for(; i1 != seq1.end(); )
      seq.push_back( *i1++ / *i2++);
    return seq;
  }
 
  template<class F, class G>  
  Sequence<typename Combtype<F,G>::type> 
  operator/(const Sequence<F> seq1, const G divisor) 
  {
    Sequence<typename Combtype<F,G>::type> seq;
    typename Sequence<F>::const_iterator i1 = seq1.begin();
    for(; i1 != seq1.end(); )
      seq.push_back( *i1++ / divisor);
    return seq;
  }
 
} // namespace concepts
 
#endif // sequence_hh