diff --git a/include/aka_iterators.hh b/include/aka_iterators.hh
index 767ce8bd0..37c45ee2f 100644
--- a/include/aka_iterators.hh
+++ b/include/aka_iterators.hh
@@ -1,667 +1,670 @@
 /**
  * @file   aka_iterators.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Aug 11 2017
  * @date last modification: Mon Jan 29 2018
  *
  * @brief  iterator interfaces
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_compatibilty_with_cpp_standard.hh"
 #include "aka_tuple_tools.hh"
 /* -------------------------------------------------------------------------- */
 #include <iterator>
 #include <tuple>
 #include <utility>
 
 /* -------------------------------------------------------------------------- */
 #ifndef AKANTU_AKA_ITERATORS_HH
 #define AKANTU_AKA_ITERATORS_HH
 
 #ifndef AKANTU_ITERATOR_NAMESPACE
 #define AKANTU_ITERATOR_NAMESPACE akantu
 #endif
 
 namespace AKANTU_ITERATOR_NAMESPACE {
 
 /* -------------------------------------------------------------------------- */
 namespace iterators {
   namespace details {
     template <typename cat1, typename cat2>
     using is_iterator_category_at_least =
         std::is_same<std::common_type_t<cat1, cat2>, cat2>;
   }
 
   template <class... Iterators> class ZipIterator {
   private:
     using tuple_t = std::tuple<Iterators...>;
 
   public:
     using value_type =
         std::tuple<typename std::iterator_traits<Iterators>::value_type...>;
     using difference_type = std::common_type_t<
         typename std::iterator_traits<Iterators>::difference_type...>;
     using pointer =
         std::tuple<typename std::iterator_traits<Iterators>::pointer...>;
     using reference =
         std::tuple<typename std::iterator_traits<Iterators>::reference...>;
     using iterator_category = // std::input_iterator_tag;
         std::common_type_t<
             typename std::iterator_traits<Iterators>::iterator_category...>;
 
     using nb_iterators = std::tuple_size<tuple_t>;
 
   public:
     explicit ZipIterator(tuple_t iterators) : iterators(std::move(iterators)) {}
 
     ZipIterator(const ZipIterator & other) = default;
     ZipIterator(ZipIterator && other) noexcept = default;
 
     ZipIterator & operator=(const ZipIterator & other) = default;
     ZipIterator & operator=(ZipIterator && other) noexcept = default;
 
     /* ---------------------------------------------------------------------- */
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<details::is_iterator_category_at_least<
                   iterator_category_,
                   std::bidirectional_iterator_tag>::value> * = nullptr>
     ZipIterator & operator--() {
       tuple::foreach ([](auto && it) { --it; }, iterators);
       return *this;
     }
 
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<details::is_iterator_category_at_least<
                   iterator_category_,
                   std::bidirectional_iterator_tag>::value> * = nullptr>
     ZipIterator operator--(int a) {
       auto cpy = *this;
       this->operator--();
       return cpy;
     }
 
     // input iterator ++it
     ZipIterator & operator++() {
       tuple::foreach ([](auto && it) { ++it; }, iterators);
       return *this;
     }
 
     // input iterator it++
     ZipIterator operator++(int) {
       auto cpy = *this;
       this->operator++();
       return cpy;
     }
 
     // input iterator it != other_it
     bool operator!=(const ZipIterator & other) const {
       // return tuple::are_not_equal(iterators, other.iterators);
       return std::get<0>(iterators) !=
              std::get<0>(other.iterators); // helps the compiler to optimize
     }
 
     // input iterator dereference *it
     decltype(auto) operator*() {
       return tuple::transform([](auto && it) -> decltype(auto) { return *it; },
                               iterators);
     }
 
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<details::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     difference_type operator-(const ZipIterator & other) {
       return std::get<0>(this->iterators) - std::get<0>(other.iterators);
     }
 
     // random iterator it[idx]
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<details::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     decltype(auto) operator[](std::size_t idx) {
       return tuple::transform(
           [idx](auto && it) -> decltype(auto) { return it[idx]; }, iterators);
     }
 
     // random iterator it + n
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<details::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     decltype(auto) operator+(std::size_t n) {
       return ZipIterator(std::forward<tuple_t>(tuple::transform(
           [n](auto && it) -> decltype(auto) { return it + n; }, iterators)));
     }
 
     // random iterator it - n
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<details::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     decltype(auto) operator-(std::size_t n) {
       return ZipIterator(std::forward<tuple_t>(tuple::transform(
           [n](auto && it) -> decltype(auto) { return it - n; }, iterators)));
     }
 
     template <
         class iterator_category_ = iterator_category,
         std::enable_if_t<details::is_iterator_category_at_least<
             iterator_category_, std::forward_iterator_tag>::value> * = nullptr>
     bool operator==(const ZipIterator & other) const {
       return not tuple::are_not_equal(iterators, other.iterators);
     }
 
   private:
     tuple_t iterators;
   };
 } // namespace iterators
 
 /* -------------------------------------------------------------------------- */
 template <class... Iterators>
 decltype(auto) zip_iterator(std::tuple<Iterators...> && iterators_tuple) {
   auto zip = iterators::ZipIterator<Iterators...>(
       std::forward<decltype(iterators_tuple)>(iterators_tuple));
   return zip;
 }
 
 /* -------------------------------------------------------------------------- */
 namespace containers {
   template <class... Containers> class ZipContainer {
     using containers_t = std::tuple<Containers...>;
 
   public:
     explicit ZipContainer(Containers &&... containers)
         : containers(std::forward<Containers>(containers)...) {}
 
     decltype(auto) begin() const {
       return zip_iterator(
           tuple::transform([](auto && c) { return c.begin(); },
                            std::forward<containers_t>(containers)));
     }
 
     decltype(auto) end() const {
       return zip_iterator(
           tuple::transform([](auto && c) { return c.end(); },
                            std::forward<containers_t>(containers)));
     }
 
     decltype(auto) begin() {
       return zip_iterator(
           tuple::transform([](auto && c) { return c.begin(); },
                            std::forward<containers_t>(containers)));
     }
 
     decltype(auto) end() {
       return zip_iterator(
           tuple::transform([](auto && c) { return c.end(); },
                            std::forward<containers_t>(containers)));
     }
 
     // template <class Container = std::tuple_element<0, containers_t>,
     //           std::enable_if_t<std::is_integral<decltype(
     //               std::declval<Container>().size())>::value> * = nullptr>
     // decltype(auto) size() {
     //   return std::forward<Container>(std::get<0>(containers)).size();
     // }
 
   private:
     containers_t containers;
   };
 
   template <class Iterator> class Range {
   public:
     using iterator = Iterator;
     // ugly trick
     using const_iterator = Iterator;
 
     explicit Range(Iterator && it1, Iterator && it2)
         : iterators(std::forward<Iterator>(it1), std::forward<Iterator>(it2)) {}
 
     decltype(auto) begin() const { return std::get<0>(iterators); }
     decltype(auto) begin() { return std::get<0>(iterators); }
 
     decltype(auto) end() const { return std::get<1>(iterators); }
     decltype(auto) end() { return std::get<1>(iterators); }
 
   private:
     std::tuple<Iterator, Iterator> iterators;
   };
 } // namespace containers
 
 /* -------------------------------------------------------------------------- */
 template <class... Containers> decltype(auto) zip(Containers &&... conts) {
   return containers::ZipContainer<Containers...>(
       std::forward<Containers>(conts)...);
 }
 
 template <class Iterator>
 decltype(auto) range(Iterator && it1, Iterator && it2) {
   return containers::Range<Iterator>(std::forward<Iterator>(it1),
                                      std::forward<Iterator>(it2));
 }
 /* -------------------------------------------------------------------------- */
 /* Arange                                                                     */
 /* -------------------------------------------------------------------------- */
 namespace iterators {
   template <class T> class ArangeIterator {
   public:
     using value_type = T;
     using pointer = T *;
     using reference = T &;
     using difference_type = size_t;
     using iterator_category = std::forward_iterator_tag;
 
     constexpr ArangeIterator(T value, T step) : value(value), step(step) {}
     constexpr ArangeIterator(const ArangeIterator &) = default;
 
     constexpr ArangeIterator & operator++() {
       value += step;
       return *this;
     }
 
     constexpr T operator*() const { return value; }
 
     constexpr bool operator==(const ArangeIterator & other) const {
       return (value == other.value) and (step == other.step);
     }
 
     constexpr bool operator!=(const ArangeIterator & other) const {
       return not operator==(other);
     }
 
   private:
     T value{0};
     const T step{1};
   };
 } // namespace iterators
 
 namespace containers {
   template <class T> class ArangeContainer {
   public:
     using iterator = iterators::ArangeIterator<T>;
     using const_iterator = iterators::ArangeIterator<T>;
 
     constexpr ArangeContainer(T start, T stop, T step = 1)
         : start(start), stop((stop - start) % step == 0
                                  ? stop
                                  : start + (1 + (stop - start) / step) * step),
           step(step) {}
     explicit constexpr ArangeContainer(T stop) : ArangeContainer(0, stop, 1) {}
 
     constexpr T operator[](size_t i) {
       T val = start + i * step;
       assert(val < stop && "i is out of range");
       return val;
     }
 
     constexpr T size() { return (stop - start) / step; }
 
     constexpr iterator begin() { return iterator(start, step); }
     constexpr iterator end() { return iterator(stop, step); }
 
   private:
     const T start{0}, stop{0}, step{1};
   };
 } // namespace containers
 
 template <class T,
           typename = std::enable_if_t<std::is_integral<std::decay_t<T>>::value>>
 inline decltype(auto) arange(const T & stop) {
   return containers::ArangeContainer<T>(stop);
 }
 
 template <class T1, class T2,
           typename = std::enable_if_t<
               std::is_integral<std::common_type_t<T1, T2>>::value>>
 inline constexpr decltype(auto) arange(const T1 & start, const T2 & stop) {
   return containers::ArangeContainer<std::common_type_t<T1, T2>>(start, stop);
 }
 
 template <class T1, class T2, class T3,
           typename = std::enable_if_t<
               std::is_integral<std::common_type_t<T1, T2, T3>>::value>>
 inline constexpr decltype(auto) arange(const T1 & start, const T2 & stop,
                                        const T3 & step) {
   return containers::ArangeContainer<std::common_type_t<T1, T2, T3>>(
       start, stop, step);
 }
 
 /* -------------------------------------------------------------------------- */
 namespace iterators {
   template <class Iterator> class EnumerateIterator {
   public:
     using value_type =
         std::tuple<size_t, typename std::iterator_traits<Iterator>::value_type>;
     using difference_type = size_t;
     using pointer =
         std::tuple<size_t, typename std::iterator_traits<Iterator>::pointer>;
     using reference =
         std::tuple<size_t, typename std::iterator_traits<Iterator>::reference>;
     using iterator_category = std::input_iterator_tag;
 
   public:
     explicit EnumerateIterator(Iterator && iterator) : iterator(iterator) {}
 
     // input iterator ++it
     EnumerateIterator & operator++() {
       ++iterator;
       ++index;
       return *this;
     }
 
     // input iterator it++
     EnumerateIterator operator++(int) {
       auto cpy = *this;
       this->operator++();
       return cpy;
     }
 
     // input iterator it != other_it
     bool operator!=(const EnumerateIterator & other) const {
       return iterator != other.iterator;
     }
 
     // input iterator dereference *it
     decltype(auto) operator*() {
       return std::tuple_cat(std::make_tuple(index), *iterator);
     }
 
     bool operator==(const EnumerateIterator & other) const {
       return not this->operator!=(other);
     }
 
   private:
     Iterator iterator;
     size_t index{0};
   };
 
   template <class Iterator>
   inline constexpr decltype(auto) enumerate(Iterator && iterator) {
     return EnumerateIterator<Iterator>(std::forward<Iterator>(iterator));
   }
 
 } // namespace iterators
 
 namespace containers {
   template <class... Containers> class EnumerateContainer {
   public:
     explicit EnumerateContainer(Containers &&... containers)
         : zip_container(std::forward<Containers>(containers)...) {}
 
     decltype(auto) begin() {
       return iterators::enumerate(zip_container.begin());
     }
 
     decltype(auto) begin() const {
       return iterators::enumerate(zip_container.begin());
     }
 
     decltype(auto) end() { return iterators::enumerate(zip_container.end()); }
 
     decltype(auto) end() const {
       return iterators::enumerate(zip_container.end());
     }
 
   private:
     ZipContainer<Containers...> zip_container;
   };
 } // namespace containers
 
 template <class... Container>
 inline constexpr decltype(auto) enumerate(Container &&... container) {
   return containers::EnumerateContainer<Container...>(
       std::forward<Container>(container)...);
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 namespace iterators {
   template <class iterator_t, class operator_t>
   class transform_adaptor_iterator {
   public:
     using value_type = decltype(std::declval<operator_t>()(
         std::declval<typename iterator_t::value_type>()));
     using difference_type = typename iterator_t::difference_type;
     using pointer = std::decay_t<value_type> *;
     using reference = value_type &;
     using iterator_category = typename iterator_t::iterator_category;
 
     transform_adaptor_iterator(iterator_t it, operator_t op)
         : it(std::move(it)), op(op) {}
     transform_adaptor_iterator(const transform_adaptor_iterator &) = default;
 
     transform_adaptor_iterator & operator++() {
       ++it;
       return *this;
     }
 
     decltype(auto) operator*() { return op(std::forward<decltype(*it)>(*it)); }
 
     bool operator==(const transform_adaptor_iterator & other) const {
       return (it == other.it);
     }
 
     bool operator!=(const transform_adaptor_iterator & other) const {
       return not operator==(other);
     }
 
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<details::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     difference_type operator-(const transform_adaptor_iterator & other) {
       return other - *this;
     }
 
   private:
     iterator_t it;
     operator_t op;
   };
 
   template <class iterator_t, class operator_t>
   decltype(auto) make_transform_adaptor_iterator(iterator_t it, operator_t op) {
     return transform_adaptor_iterator<iterator_t, operator_t>(
         it, std::forward<operator_t>(op));
   }
 
 } // namespace iterators
 
 namespace containers {
   template <class container_t, class operator_t>
   class TransformIteratorAdaptor {
   public:
     // using const_iterator = typename
     // std::decay_t<container_t>::const_iterator; using iterator = typename
     // std::decay_t<container_t>::iterator;
 
     TransformIteratorAdaptor(container_t && cont, operator_t op)
         : cont(std::forward<container_t>(cont)),
           op(std::forward<operator_t>(op)) {}
 
     decltype(auto) begin() const {
       return iterators::make_transform_adaptor_iterator(cont.begin(), op);
     }
     decltype(auto) begin() {
       return iterators::make_transform_adaptor_iterator(cont.begin(), op);
     }
 
     decltype(auto) end() const {
       return iterators::make_transform_adaptor_iterator(cont.end(), op);
     }
     decltype(auto) end() {
       return iterators::make_transform_adaptor_iterator(cont.end(), op);
     }
 
   private:
     container_t cont;
     operator_t op;
   };
 } // namespace containers
 
 template <class container_t, class operator_t>
 decltype(auto) make_transform_adaptor(container_t && cont, operator_t && op) {
   return containers::TransformIteratorAdaptor<container_t, operator_t>(
       std::forward<container_t>(cont), std::forward<operator_t>(op));
 }
 
 template <class container_t>
 decltype(auto) make_keys_adaptor(container_t && cont) {
   return make_transform_adaptor(
       std::forward<container_t>(cont),
       [](auto && pair) -> const auto & { return pair.first; });
 }
 
 template <class container_t>
 decltype(auto) make_values_adaptor(container_t && cont) {
   return make_transform_adaptor(
       std::forward<container_t>(cont),
       [](auto && pair) -> auto & { return pair.second; });
 }
 
 template <class container_t>
 decltype(auto) make_dereference_adaptor(container_t && cont) {
   return make_transform_adaptor(
       std::forward<container_t>(cont),
       [](auto && value) -> decltype(*value) { return *value; });
 }
 
 template <class... zip_container_t>
 decltype(auto) make_zip_cat(zip_container_t &&... cont) {
   return make_transform_adaptor(
       zip(std::forward<zip_container_t>(cont)...),
       [](auto && value) { return tuple::flatten(value); });
 }
 
 /* -------------------------------------------------------------------------- */
 namespace iterators {
   template <class filter_iterator_t, class container_iterator_t>
   class FilterIterator {
   public:
     using value_type =
         decltype(std::declval<container_iterator_t>().operator[](0));
     using difference_type = typename filter_iterator_t::difference_type;
     using pointer = std::decay_t<value_type> *;
     using reference = value_type &;
     using iterator_category = typename filter_iterator_t::iterator_category;
 
     FilterIterator(filter_iterator_t filter_it,
                    container_iterator_t container_begin)
-        : filter_it(std::move(filter_it)), container_begin(container_begin),
-          container_it(container_begin) {}
+        : filter_it(std::move(filter_it)),
+          container_begin(std::move(container_begin)) {}
 
     FilterIterator(const FilterIterator &) = default;
 
     FilterIterator & operator++() {
       ++filter_it;
-      container_it =
-          container_begin + *filter_it; // this might return invalid iterators
       return *this;
     }
 
-    decltype(auto) operator*() { return *container_it; }
+    decltype(auto) operator*() {
+      auto container_it = this->container_begin + *this->filter_it;
+      return *container_it;
+    }
 
-    decltype(auto) operator*() const { return *container_it; }
+    decltype(auto) operator*() const {
+      auto container_it = this->container_begin + *this->filter_it;
+      return *container_it;
+    }
 
     bool operator==(const FilterIterator & other) const {
       return (filter_it == other.filter_it) and
              (container_begin == other.container_begin);
     }
 
     bool operator!=(const FilterIterator & other) const {
       return filter_it != other.filter_it;
     }
 
   private:
     filter_iterator_t filter_it;
     container_iterator_t container_begin;
-    container_iterator_t container_it;
   };
 
   template <class filter_iterator_t, class container_iterator_t>
   decltype(auto) make_filter_iterator(filter_iterator_t && filter_it,
                                       container_iterator_t && container_begin) {
     return FilterIterator<filter_iterator_t, container_iterator_t>(
         std::forward<filter_iterator_t>(filter_it),
         std::forward<container_iterator_t>(container_begin));
   }
 } // namespace iterators
 
 namespace containers {
   template <class filter_t, class Container> class FilterAdaptor {
   public:
     FilterAdaptor(filter_t && filter, Container && container)
         : filter(std::forward<filter_t>(filter)),
           container(std::forward<Container>(container)) {
       static_assert(
           std::is_same<typename decltype(container.begin())::iterator_category,
                        std::random_access_iterator_tag>::value,
           "Containers must all have random iterators");
     }
 
     decltype(auto) begin() const {
       return iterators::make_filter_iterator(filter.begin(), container.begin());
     }
     decltype(auto) begin() {
       return iterators::make_filter_iterator(filter.begin(), container.begin());
     }
 
     decltype(auto) end() const {
       return iterators::make_filter_iterator(filter.end(), container.begin());
     }
     decltype(auto) end() {
       return iterators::make_filter_iterator(filter.end(), container.begin());
     }
 
   private:
     filter_t filter;
     Container container;
   };
 } // namespace containers
 
 template <class filter_t, class Container>
 decltype(auto) filter(filter_t && filter, Container && container) {
   return containers::FilterAdaptor<filter_t, Container>(
       std::forward<filter_t>(filter), std::forward<Container>(container));
 }
 
 } // namespace AKANTU_ITERATOR_NAMESPACE
 
 namespace std {
 template <typename... Its>
 struct iterator_traits<::akantu::iterators::ZipIterator<Its...>> {
   using iterator_category = forward_iterator_tag;
   using value_type =
       typename ::akantu::iterators::ZipIterator<Its...>::value_type;
   using difference_type =
       typename ::akantu::iterators::ZipIterator<Its...>::difference_type;
   using pointer = typename ::akantu::iterators::ZipIterator<Its...>::pointer;
   using reference =
       typename ::akantu::iterators::ZipIterator<Its...>::reference;
 };
 
 } // namespace std
 
 #endif /* AKANTU_AKA_ITERATORS_HH */
diff --git a/test/test_iterators.cc b/test/test_iterators.cc
index 3b19ca799..b77b2434c 100644
--- a/test/test_iterators.cc
+++ b/test/test_iterators.cc
@@ -1,374 +1,383 @@
 /**
  * @file   test_zip_iterator.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 21 2017
  * @date last modification: Fri Dec 08 2017
  *
  * @brief  test the zip container and iterator
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 
 // Non Trivial class that counts moves and copies
 template <class T> class A {
 public:
   A() = default;
   A(T a) : a(a){};
   A(const A & other)
       : a(other.a), copy_counter(other.copy_counter + 1),
         move_counter(other.move_counter) {}
   A & operator=(const A & other) {
     if (this != &other) {
       a = other.a;
       copy_counter = other.copy_counter + 1;
     }
     return *this;
   }
 
   A(A && other)
       : a(std::move(other.a)), copy_counter(std::move(other.copy_counter)),
         move_counter(std::move(other.move_counter) + 1) {}
 
   A & operator=(A && other) {
     if (this != &other) {
       a = std::move(other.a);
       copy_counter = std::move(other.copy_counter);
       move_counter = std::move(other.move_counter) + 1;
     }
     return *this;
   }
 
   A & operator*=(const T & b) {
     a *= b;
     return *this;
   }
 
   T a;
   size_t copy_counter{0};
   size_t move_counter{0};
 };
 
 template <typename T> struct C {
   struct iterator {
     using reference = A<T>;
     using difference_type = void;
     using iterator_category = std::input_iterator_tag;
     using value_type = A<T>;
     using pointer = A<T> *;
 
     iterator(T pos) : pos(std::move(pos)) {}
 
     A<T> operator*() { return A<int>(pos); }
     bool operator!=(const iterator & other) const { return pos != other.pos; }
     bool operator==(const iterator & other) const { return pos == other.pos; }
     iterator & operator++() {
       ++pos;
       return *this;
     }
     T pos;
   };
 
   C(T begin_, T end_) : begin_(std::move(begin_)), end_(std::move(end_)) {}
 
   iterator begin() { return iterator(begin_); }
   iterator end() { return iterator(end_); }
 
   T begin_, end_;
 };
 
 class TestZipFixutre : public ::testing::Test {
 protected:
   void SetUp() override {
     a.reserve(size);
     b.reserve(size);
 
     for (size_t i = 0; i < size; ++i) {
       a.emplace_back(i);
       b.emplace_back(i + size);
     }
   }
 
   template <typename A, typename B>
   void check(A && a, B && b, size_t pos, size_t nb_copy, size_t nb_move) {
     EXPECT_EQ(pos, a.a);
     EXPECT_EQ(nb_copy, a.copy_counter);
     EXPECT_EQ(nb_move, a.move_counter);
 
     EXPECT_FLOAT_EQ(pos + this->size, b.a);
     EXPECT_EQ(nb_copy, b.copy_counter);
     EXPECT_EQ(nb_move, b.move_counter);
   }
 
 protected:
   size_t size{20};
   std::vector<A<int>> a;
   std::vector<A<float>> b;
 };
 
 TEST_F(TestZipFixutre, SimpleTest) {
   size_t i = 0;
   for (auto && pair : zip(this->a, this->b)) {
     this->check(std::get<0>(pair), std::get<1>(pair), i, 0, 0);
     ++i;
   }
 }
 
 TEST_F(TestZipFixutre, ConstTest) {
   size_t i = 0;
   const auto & ca = this->a;
   const auto & cb = this->b;
   for (auto && pair : zip(ca, cb)) {
     this->check(std::get<0>(pair), std::get<1>(pair), i, 0, 0);
     EXPECT_EQ(true,
               std::is_const<
                   std::remove_reference_t<decltype(std::get<0>(pair))>>::value);
     EXPECT_EQ(true,
               std::is_const<
                   std::remove_reference_t<decltype(std::get<1>(pair))>>::value);
     ++i;
   }
 }
 
 TEST_F(TestZipFixutre, MixteTest) {
   size_t i = 0;
   const auto & cb = this->b;
   for (auto && pair : zip(a, cb)) {
     this->check(std::get<0>(pair), std::get<1>(pair), i, 0, 0);
     EXPECT_EQ(false,
               std::is_const<
                   std::remove_reference_t<decltype(std::get<0>(pair))>>::value);
     EXPECT_EQ(true,
               std::is_const<
                   std::remove_reference_t<decltype(std::get<1>(pair))>>::value);
     ++i;
   }
 }
 
 TEST_F(TestZipFixutre, MoveTest) {
   size_t i = 0;
   for (auto && pair :
        zip(C<int>(0, this->size), C<int>(this->size, 2 * this->size))) {
     this->check(std::get<0>(pair), std::get<1>(pair), i, 0, 1);
     ++i;
   }
 }
 
 TEST_F(TestZipFixutre, Bidirectional) {
   auto _zip = zip(a, b);
   auto begin = _zip.begin();
   auto end = _zip.end();
 
   auto it = begin;
   ++it;
   EXPECT_EQ(begin, --it);
 
   it = begin;
   EXPECT_EQ(begin, it++);
   EXPECT_EQ(begin, --it);
 
   auto it2 = it = begin;
-  ++it; ++it2;
+  ++it;
+  ++it2;
   EXPECT_EQ(it2, it--);
   EXPECT_EQ(begin, it);
 }
 
 TEST_F(TestZipFixutre, RandomAccess) {
   auto _zip = zip(a, b);
   auto begin = _zip.begin();
   auto end = _zip.end();
 
   auto && val5 = begin[5];
   this->check(std::get<0>(val5), std::get<1>(val5), 5, 0, 0);
 
   auto && val13 = begin[13];
   this->check(std::get<0>(val13), std::get<1>(val13), 13, 0, 0);
 
   EXPECT_EQ(end - begin, a.size());
   auto it = ++begin;
   EXPECT_EQ(begin + 1, ++it);
   EXPECT_EQ(begin, it - 1);
 }
 
 TEST_F(TestZipFixutre, Cat) {
   size_t i = 0;
   for (auto && data : make_zip_cat(zip(a, b), zip(a, b))) {
     this->check(std::get<0>(data), std::get<1>(data), i, 0, 0);
     this->check(std::get<2>(data), std::get<3>(data), i, 0, 0);
     ++i;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestArangeIterator, Stop) {
   size_t ref_i = 0;
   for (auto i : arange(10)) {
     EXPECT_EQ(ref_i, i);
     ++ref_i;
   }
 }
 
 TEST(TestArangeIterator, StartStop) {
   size_t ref_i = 1;
   for (auto i : arange(1, 10)) {
     EXPECT_EQ(ref_i, i);
     ++ref_i;
   }
 }
 
 TEST(TestArangeIterator, StartStopStep) {
   size_t ref_i = 1;
   for (auto i : arange(1, 22, 2)) {
     EXPECT_EQ(ref_i, i);
     ref_i += 2;
   }
 }
 
 TEST(TestArangeIterator, StartStopStepZipped) {
   int ref_i1 = -1, ref_i2 = 1;
   for (auto && i : zip(arange(-1, -10, -1), arange(1, 18, 2))) {
     EXPECT_EQ(ref_i1, std::get<0>(i));
     EXPECT_EQ(ref_i2, std::get<1>(i));
     ref_i1 += -1;
     ref_i2 += 2;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestEnumerateIterator, SimpleTest) {
-  std::vector<int> a {0, 10, 20, 30, 40};
-  std::vector<int> b {0, 2, 4, 6, 8};
+  std::vector<int> a{0, 10, 20, 30, 40};
+  std::vector<int> b{0, 2, 4, 6, 8};
   for (auto && data : enumerate(a, b)) {
     EXPECT_EQ(std::get<0>(data) * 10, std::get<1>(data));
     EXPECT_EQ(std::get<0>(data) * 2, std::get<2>(data));
   }
 }
 
-
-
 /* -------------------------------------------------------------------------- */
 TEST(TestTransformAdaptor, Keys) {
   std::map<std::string, int> map{
       {"1", 1}, {"2", 2}, {"3", 3}, {"3", 3}, {"4", 4}};
 
   char counter = '1';
   for (auto && key : make_keys_adaptor(map)) {
     EXPECT_EQ(counter, key[0]);
     ++counter;
   }
 }
 
 TEST(TestTransformAdaptor, Values) {
   std::map<std::string, int> map{
       {"1", 1}, {"2", 2}, {"3", 3}, {"3", 3}, {"4", 4}};
 
   int counter = 1;
   for (auto && value : make_values_adaptor(map)) {
     EXPECT_EQ(counter, value);
     ++counter;
   }
 }
 
 static int plus1(int value) { return value + 1; }
 
 struct Plus {
   Plus(int a) : a(a) {}
   int operator()(int b) { return a + b; }
 
 private:
   int a{0};
 };
 
 TEST(TestTransformAdaptor, Lambda) {
   auto && container = arange(10);
 
   for (auto && data :
        zip(container, make_transform_adaptor(container, [](auto && value) {
              return value + 1;
            }))) {
     EXPECT_EQ(std::get<0>(data) + 1, std::get<1>(data));
   }
 }
 
 TEST(TestTransformAdaptor, LambdaLambda) {
   std::map<std::string, int> map{
       {"1", 1}, {"2", 2}, {"3", 3}, {"3", 3}, {"4", 4}};
 
   int counter = 1;
   for (auto && data : make_transform_adaptor(
            make_values_adaptor(map), [](auto && value) { return value + 1; })) {
     EXPECT_EQ(counter + 1, data);
     ++counter;
   }
 
   auto && container = arange(10);
 
   for (auto && data :
        zip(container, make_transform_adaptor(container, [](auto && value) {
              return value + 1;
            }))) {
     EXPECT_EQ(std::get<0>(data) + 1, std::get<1>(data));
   }
 }
 
 TEST(TestTransformAdaptor, Function) {
   auto && container = arange(10);
 
   for (auto && data :
        zip(container, make_transform_adaptor(container, plus1))) {
     EXPECT_EQ(std::get<0>(data) + 1, std::get<1>(data));
   }
 }
 
 TEST(TestTransformAdaptor, Functor) {
   auto && container = arange(10);
 
   for (auto && data :
        zip(container, make_transform_adaptor(container, Plus(1)))) {
     EXPECT_EQ(std::get<0>(data) + 1, std::get<1>(data));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 TEST(TestFilteredIterator, Simple) {
   std::vector<int> values{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-  std::vector<int> filter_{0, 2, 4, 10, 8, 6};
+  std::vector<int> filter_{1, 3, 4, 10, 8, 6};
   for (auto && data : zip(filter_, filter(filter_, values))) {
     EXPECT_EQ(std::get<0>(data), std::get<1>(data));
   }
 }
 
 /* -------------------------------------------------------------------------- */
-int main(int argc, char **argv) {
+TEST(TestFilteredIterator, Temporary) {
+  std::vector<int> filter_{1, 3, 4, 10, 8, 6};
+  for (auto && data :
+       zip(filter_, filter(filter_, std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7, 8,
+                                                     9, 10}))) {
+    EXPECT_EQ(std::get<0>(data), std::get<1>(data));
+  }
+}
+
+/* -------------------------------------------------------------------------- */
+int main(int argc, char ** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }