diff --git a/.clang-tidy b/.clang-tidy
index a0f6366..53e81de 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,4 +1,3 @@
-Checks:          'modernize-use-*, performance-*'
-AnalyzeTemporaryDtors: false
-HeaderFilterRegex: 'src/.*'
-FormatStyle:     file
+Checks:            'modernize-use-*, performance-*, bugprone-*, readability-*'
+HeaderFilterRegex: 'include/.*'
+FormatStyle:       file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 39d1839..7410eab 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,69 +1,75 @@
 cmake_minimum_required(VERSION 3.10)
 
 project(AkantuIterators)
 
 # ------------------------------------------------------------------------------
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(BUILD_SHARED_LIBS ON)
 if (NOT AKANTU_ITERATORS_PYTHON_MAJOR_VERSION)
   set(AKANTU_ITERATORS_PYTHON_MAJOR_VERSION 3)
 endif()
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
 
 include(AkantuIteratorsTools)
 # ------------------------------------------------------------------------------
 
 set(AKANTU_ITERATORS_PUBLIC_HDRS
   aka_compatibilty_with_cpp_standard.hh
   aka_iterators.hh
   aka_static_if.hh
   aka_tuple_tools.hh
+  iterators/aka_arange_iterator.hh
+  iterators/aka_enumerate_iterator.hh
+  iterators/aka_filter_iterator.hh
+  iterators/aka_named_zip_iterator.hh
+  iterators/aka_transform_iterator.hh
+  iterators/aka_zip_iterator.hh
   )
 
 add_library(akantu_iterators INTERFACE)
 
 target_include_directories(akantu_iterators
   INTERFACE $<INSTALL_INTERFACE:include/akantu_iterators>
   )
 
 # small trick for build includes in public
 set_property(TARGET akantu_iterators APPEND PROPERTY
   INTERFACE_INCLUDE_DIRECTORIES $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
 
 set_property(TARGET akantu_iterators PROPERTY
   INTERFACE_PUBLIC_HEADER ${AKANTU_ITERATORS_PUBLIC_HDRS})
 
 set_target_properties(akantu_iterators
   PROPERTIES
   INTERFACE_CXX_STANDARD 14
   )
 # ------------------------------------------------------------------------------
 
 option(AKANTU_ITERATORS_TESTS "Activating tests" OFF)
 mark_as_advanced(AKANTU_ITERATORS_TESTS)
 if(AKANTU_ITERATORS_TESTS)
   enable_testing()
   add_external_package(GTest)
   add_subdirectory(test)
 endif()
 
 # ------------------------------------------------------------------------------  
 if(NOT AKANTU_ITERATORS_TARGETS_EXPORT)
   set(AKANTU_ITERATORS_TARGETS_EXPORT AkantuIteratorsTargets)
 endif()
 
 install(TARGETS akantu_iterators
   EXPORT ${AKANTU_ITERATORS_TARGETS_EXPORT}
   PUBLIC_HEADER DESTINATION include/akantu_iterators/ COMPONENT dev
   )
 
 if("${AKANTU_ITERATORS_TARGETS_EXPORT}" STREQUAL "AkantuIteratorsTargets")
   install(EXPORT AkantuIteratorsTargets DESTINATION share/cmake/${PROJECT_NAME}
     COMPONENT dev)
 
   #Export for build tree
   export(EXPORT AkantuIteratorsTargets
     FILE "${CMAKE_CURRENT_BINARY_DIR}/AkantuIteratorsTargets.cmake")
   export(PACKAGE AkantuIterators)
 endif()
 
diff --git a/include/aka_compatibilty_with_cpp_standard.hh b/include/aka_compatibilty_with_cpp_standard.hh
index bf02f0d..b139159 100644
--- a/include/aka_compatibilty_with_cpp_standard.hh
+++ b/include/aka_compatibilty_with_cpp_standard.hh
@@ -1,186 +1,186 @@
 /**
  * @file   aka_compatibilty_with_cpp_standard.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Wed Jan 10 2018
  *
  * @brief  The content of this file is taken from the possible implementations
  * on
  * http://en.cppreference.com
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-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_static_if.hh"
 /* -------------------------------------------------------------------------- */
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <iterator>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_AKA_COMPATIBILTY_WITH_CPP_STANDARD_HH
 #define AKANTU_AKA_COMPATIBILTY_WITH_CPP_STANDARD_HH
 
 namespace aka {
 
 /* -------------------------------------------------------------------------- */
 // Part taken from C++14
 #if __cplusplus < 201402L
 template <bool B, class T = void>
 using enable_if_t = typename enable_if<B, T>::type;
 #else
 template <bool B, class T = void> using enable_if_t = std::enable_if_t<B, T>;
 #endif
 
 /* -------------------------------------------------------------------------- */
 // Part taken from C++17
 #if __cplusplus < 201703L
 
 /* -------------------------------------------------------------------------- */
 // bool_constant
 template <bool B> using bool_constant = std::integral_constant<bool, B>;
 namespace {
 template <bool B> constexpr bool bool_constant_v = bool_constant<B>::value;
 }
 
 /* -------------------------------------------------------------------------- */
 // conjunction
 template <class...> struct conjunction : std::true_type {};
 template <class B1> struct conjunction<B1> : B1 {};
 template <class B1, class... Bn>
 struct conjunction<B1, Bn...>
     : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
 
 /* -------------------------------------------------------------------------- */
 // disjunction
 template <class...> struct disjunction : std::false_type {};
 template <class B1> struct disjunction<B1> : B1 {};
 template <class B1, class... Bn>
 struct disjunction<B1, Bn...>
     : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
 
 /* -------------------------------------------------------------------------- */
 // negations
 template <class B> struct negation : bool_constant<!bool(B::value)> {};
 
 /* -------------------------------------------------------------------------- */
 // invoke
 namespace detail {
 template <class T> struct is_reference_wrapper : std::false_type {};
 template <class U>
 struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};
 
 template <class T, class Type, class T1, class... Args>
 decltype(auto) INVOKE(Type T::*f, T1 &&t1, Args &&... args) {
   static_if(std::is_member_function_pointer<decltype(f)>{})
       .then_([&](auto &&f) {
         static_if(std::is_base_of<T, std::decay_t<T1>>{})
             .then_([&](auto &&f) {
               return (std::forward<T1>(t1).*f)(std::forward<Args>(args)...);
             })
             .elseif(is_reference_wrapper<std::decay_t<T1>>{})([&](auto &&f) {
               return (t1.get().*f)(std::forward<Args>(args)...);
             })
             .else_([&](auto &&f) {
               return ((*std::forward<T1>(t1)).*f)(std::forward<Args>(args)...);
             })(std::forward<decltype(f)>(f));
       })
       .else_([&](auto &&f) {
         static_assert(std::is_member_object_pointer<decltype(f)>::value,
                       "f is not a member object");
         static_assert(sizeof...(args) == 0, "f takes arguments");
         static_if(std::is_base_of<T, std::decay_t<T1>>{})
             .then_([&](auto &&f) { return std::forward<T1>(t1).*f; })
             .elseif(std::is_base_of<T, std::decay_t<T1>>{})(
                 [&](auto &&f) { return t1.get().*f; })
             .else_([&](auto &&f) { return (*std::forward<T1>(t1)).*f; })(
                 std::forward<decltype(f)>(f));
       })(std::forward<decltype(f)>(f));
 }
 
 template <class F, class... Args>
 decltype(auto) INVOKE(F &&f, Args &&... args) {
   return std::forward<F>(f)(std::forward<Args>(args)...);
 }
 } // namespace detail
 
 template <class F, class... Args>
 decltype(auto) invoke(F &&f, Args &&... args) {
   return detail::INVOKE(std::forward<F>(f), std::forward<Args>(args)...);
 }
 
 /* -------------------------------------------------------------------------- */
 // apply
 namespace detail {
-template <class F, class Tuple, std::size_t... Is>
-constexpr decltype(auto) apply_impl(F &&f, Tuple &&t,
-                                    std::index_sequence<Is...>) {
-  return invoke(std::forward<F>(f), std::get<Is>(std::forward<Tuple>(t))...);
-}
+  template <class F, class Tuple, std::size_t... Is>
+  constexpr decltype(auto) apply_impl(F && f, Tuple && t,
+                                      std::index_sequence<Is...> /*unused*/) {
+    return invoke(std::forward<F>(f), std::get<Is>(std::forward<Tuple>(t))...);
+  }
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <class F, class Tuple>
 constexpr decltype(auto) apply(F &&f, Tuple &&t) {
   return detail::apply_impl(
       std::forward<F>(f), std::forward<Tuple>(t),
       std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{});
 }
 
 /* -------------------------------------------------------------------------- */
 // count_if
 template <class InputIt, class UnaryPredicate>
 typename std::iterator_traits<InputIt>::difference_type
 count_if(InputIt first, InputIt last, UnaryPredicate p) {
   typename std::iterator_traits<InputIt>::difference_type ret = 0;
   for (; first != last; ++first) {
     if (p(*first)) {
       ret++;
     }
   }
   return ret;
 }
 
 #else
 template <bool B> using bool_constant = std::bool_constant<B>;
 template <bool B> using bool_constant_v = std::bool_constant_v<B>;
 
 template <class... Args> using conjunction = std::conjunction<Args...>;
 template <class... Args> using disjunction = std::disjunction<Args...>;
 template <class B> using negation = std::negation<B>;
 
 using invoke = std::invoke;
 using apply = std::apply;
 
 using count_if = std::count_if;
 #endif
 
 
 template <typename cat1, typename cat2>
 using is_iterator_category_at_least =
                   std::is_same<std::common_type_t<cat1, cat2>, cat2>;
 
 } // namespace aka
 
 #endif /* AKANTU_AKA_COMPATIBILTY_WITH_CPP_STANDARD_HH */
diff --git a/include/aka_static_if.hh b/include/aka_static_if.hh
index d5fb0dc..369f653 100644
--- a/include/aka_static_if.hh
+++ b/include/aka_static_if.hh
@@ -1,98 +1,108 @@
 // Copyright (c) 2016 Vittorio Romeo
 // License: AFL 3.0 | https://opensource.org/licenses/AFL-3.0
 // http://vittorioromeo.info | vittorio.romeo@outlook.com
 
 #ifndef AKANTU_AKA_STATIC_IF_HH
 #define AKANTU_AKA_STATIC_IF_HH
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
 #include <utility>
 
 #define FWD(...) ::std::forward<decltype(__VA_ARGS__)>(__VA_ARGS__)
 
 namespace AKANTU_ITERATORS_NAMESPACE {
 
-template <typename TPredicate> auto static_if(TPredicate) noexcept;
+template <typename TPredicate> auto static_if(TPredicate /*unused*/) noexcept;
 
 namespace impl {
   template <bool TPredicateResult> struct static_if_impl;
 
   template <typename TFunctionToCall> struct static_if_result;
 
   template <typename TF> auto make_static_if_result(TF && f) noexcept;
 
   template <> struct static_if_impl<true> {
-    template <typename TF> auto & else_(TF &&) noexcept {
+    template <typename TF> auto & else_(TF && /*unused*/) noexcept {
       // Ignore `else_`, as the predicate is true.
       return *this;
     }
 
-    template <typename TPredicate> auto & else_if(TPredicate) noexcept {
+    template <typename TPredicate>
+    auto & else_if(TPredicate /*unused*/) noexcept {
       // Ignore `else_if`, as the predicate is true.
       return *this;
     }
 
     template <typename TF> auto then(TF && f) noexcept {
       // We found a matching branch, just make a result and
       // ignore everything else.
       return make_static_if_result(FWD(f));
     }
   };
 
   template <> struct static_if_impl<false> {
-    template <typename TF> auto & then(TF &&) noexcept {
+    template <typename TF> auto & then(TF && /*unused*/) noexcept {
       // Ignore `then`, as the predicate is false.
       return *this;
     }
 
     template <typename TF> auto else_(TF && f) noexcept {
       // (Assuming that `else_` is after all `else_if` calls.)
 
       // We found a matching branch, just make a result and
       // ignore everything else.
 
       return make_static_if_result(FWD(f));
     }
 
-    template <typename TPredicate> auto else_if(TPredicate) noexcept {
+    template <typename TPredicate>
+    auto else_if(TPredicate /*unused*/) noexcept {
       return static_if(TPredicate{});
     }
 
-    template <typename... Ts> auto operator()(Ts &&...) noexcept {
+    template <typename... Ts> auto operator()(Ts &&... /*unused*/) noexcept {
       // If there are no `else` branches, we must ignore calls
       // to a failed `static_if` matching.
     }
   };
 
   template <typename TFunctionToCall>
   struct static_if_result : TFunctionToCall {
     // Perfect-forward the function in the result instance.
     template <typename TFFwd>
     explicit static_if_result(TFFwd && f) noexcept : TFunctionToCall(FWD(f)) {}
 
+    static_if_result(const static_if_result & /* unused */) = delete;
+    static_if_result(static_if_result && /* unused */) = delete;
+
     // Ignore everything, we found a result.
-    template <typename TF> auto & then(TF &&) noexcept { return *this; }
+    template <typename TF> auto & then(TF && /*unused*/) noexcept {
+      return *this;
+    }
 
-    template <typename TPredicate> auto & else_if(TPredicate) noexcept {
+    template <typename TPredicate>
+    auto & else_if(TPredicate /*unused*/) noexcept {
       return *this;
     }
 
-    template <typename TF> auto & else_(TF &&) noexcept { return *this; }
+    template <typename TF> auto & else_(TF && /*unused*/) noexcept {
+      return *this;
+    }
   };
 
   template <typename TF> auto make_static_if_result(TF && f) noexcept {
     return static_if_result<TF>{FWD(f)};
   }
 } // namespace impl
 
-template <typename TPredicate> auto static_if(TPredicate) noexcept {
+template <typename TPredicate> auto static_if(TPredicate /*unused*/) noexcept {
   return impl::static_if_impl<TPredicate{}>{};
 }
 
 #undef FWD
 } // namespace AKANTU_ITERATORS_NAMESPACE
 
 #endif /* AKANTU_AKA_STATIC_IF_HH */
diff --git a/include/aka_str_hash.hh b/include/aka_str_hash.hh
index 02392a2..3602e50 100644
--- a/include/aka_str_hash.hh
+++ b/include/aka_str_hash.hh
@@ -1,181 +1,185 @@
 /**
  * @file   aka_str_hash.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  lun déc 09 2019
  *
  * @brief A Documented file.
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * akantu-iterators 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-iterators 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-iterators. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include <cstddef>
 #include <cstdint>
-#include <type_traits>
 #include <initializer_list>
+#include <limits>
+#include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_AKA_STR_HASH_HH
 #define AKANTU_AKA_STR_HASH_HH
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
-
 namespace AKANTU_ITERATORS_NAMESPACE {
 
 namespace hash {
   namespace details {
 
     // CRC32 Table (zlib polynomial)
     static constexpr uint32_t crc_table[256] = {
         0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
         0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
         0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
         0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
         0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
         0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
         0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
         0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
         0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
         0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
         0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
         0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
         0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
         0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
         0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
         0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
         0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
         0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
         0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
         0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
         0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
         0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
         0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
         0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
         0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
         0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
         0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
         0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
         0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
         0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
         0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
         0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
         0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
         0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
         0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
         0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
         0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
         0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
         0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
         0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
         0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
         0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
         0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
         0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
         0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
         0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
         0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
         0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
         0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
         0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
         0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
         0x2d02ef8dL};
 
     /* --------------------------------------------------------------------------
      */
     /// CRC32 hashing algorithm
     constexpr uint32_t crc32_hash(const char * str, size_t idx) {
-      auto crc = (idx == 0 ? 0xFFFFFFFF : crc32_hash(str, idx - 1));
+      constexpr uint8_t mask_size = 8;
+      auto crc = (idx == 0 ? std::numeric_limits<uint32_t>::max()
+                           : crc32_hash(str, idx - 1));
 
-      return (crc >> 8) ^ crc_table[(crc ^ str[idx]) & 0x000000FF];
+      return (crc >> mask_size) ^
+             crc_table[(crc ^ str[idx]) & std::numeric_limits<uint8_t>::max()];
     }
 
     namespace {
       template <typename Hash> constexpr Hash fnv1a_offset = 0x0;
       template <>
       constexpr uint64_t fnv1a_offset<uint64_t> = 0xcbf29ce484222325;
       template <> constexpr uint32_t fnv1a_offset<uint32_t> = 0x811c9dc5;
 
       template <typename Hash> constexpr Hash fnv1a_prime = 0x0;
       template <> constexpr uint64_t fnv1a_prime<uint64_t> = 0x00000100000001b3;
       template <> constexpr uint32_t fnv1a_prime<uint32_t> = 0x01000193;
 
     } // namespace
 
     template <class T, T offset = fnv1a_offset<T>, T prime = fnv1a_prime<T>>
     constexpr T fnv1a_hash(const char * str, size_t idx) {
       return ((idx ? fnv1a_hash<T, offset, prime>(str, idx - 1) : offset) ^
               str[idx]) *
              prime;
     }
 
     // FNV-1a 32bit hashing algorithm.
     constexpr decltype(auto) fnv1a_32_hash(const char * str, size_t idx) {
       return fnv1a_hash<uint32_t>(str, idx);
     }
 
     // FNV-1a 32bit hashing algorithm.
     constexpr decltype(auto) fnv1a_64_hash(const char * str, size_t idx) {
       return fnv1a_hash<uint64_t>(str, idx);
     }
 
     template <typename Hash, typename CharT, CharT... chars>
     constexpr Hash fnv1a() {
       auto result = fnv1a_offset<Hash>;
       (void)std::initializer_list<Hash>{
           (result = (result ^ chars) * fnv1a_prime<Hash>, Hash{})...};
       return result;
     }
 
   } // namespace details
 
   constexpr uint32_t operator"" _crc32(const char * str, size_t size) {
-    return details::crc32_hash(str, size - 1) ^ 0xFFFFFFFF;
+    return details::crc32_hash(str, size - 1) ^
+           std::numeric_limits<uint32_t>::max();
   }
 
   constexpr uint32_t operator"" _fnv1a32(const char * str, size_t size) {
     return details::fnv1a_32_hash(str, size - 1);
   }
 
   constexpr uint64_t operator"" _fnv1a64(const char * str, size_t size) {
     return details::fnv1a_64_hash(str, size - 1);
   }
 
 } // namespace hash
 
 template <typename CharT, CharT... chars> struct string_literal {
   static constexpr uint64_t hash =
       hash::details::fnv1a<uint64_t, CharT, chars...>();
   using hash_type = std::integral_constant<uint64_t, hash>;
 };
 
 template <typename CharT, CharT... chars>
 constexpr uint64_t string_literal<CharT, chars...>::hash;
 
 constexpr auto operator"" _h(const char * str, size_t size) {
   return hash::details::fnv1a_64_hash(str, size - 1);
 }
 
-} // namespace AKANTU_ITERATOR_NAMESPACE
+} // namespace AKANTU_ITERATORS_NAMESPACE
 
 #endif /* AKANTU_AKA_STR_HASH_HH */
diff --git a/include/aka_tuple_tools.hh b/include/aka_tuple_tools.hh
index 38cc179..4a7ec02 100644
--- a/include/aka_tuple_tools.hh
+++ b/include/aka_tuple_tools.hh
@@ -1,266 +1,270 @@
 /**
  * @file   aka_tuple_tools.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 2019 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_str_hash.hh"
 /* -------------------------------------------------------------------------- */
 #include <tuple>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_AKA_TUPLE_TOOLS_HH
 #define AKANTU_AKA_TUPLE_TOOLS_HH
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
 namespace AKANTU_ITERATORS_NAMESPACE {
 
 namespace tuple {
   /* ------------------------------------------------------------------------ */
   namespace details {
     template <std::size_t N> struct Foreach {
       template <class Tuple>
       static inline bool not_equal(Tuple && a, Tuple && b) {
         if (std::get<N - 1>(std::forward<Tuple>(a)) ==
-            std::get<N - 1>(std::forward<Tuple>(b)))
+            std::get<N - 1>(std::forward<Tuple>(b))) {
           return false;
+        }
         return Foreach<N - 1>::not_equal(std::forward<Tuple>(a),
                                          std::forward<Tuple>(b));
       }
     };
 
     /* ---------------------------------------------------------------------- */
     template <> struct Foreach<0> {
       template <class Tuple>
       static inline bool not_equal(Tuple && a, Tuple && b) {
         return std::get<0>(std::forward<Tuple>(a)) !=
                std::get<0>(std::forward<Tuple>(b));
       }
     };
 
     template <typename... Ts>
     decltype(auto) make_tuple_no_decay(Ts &&... args) {
       return std::tuple<Ts...>(std::forward<Ts>(args)...);
     }
 
     template <class F, class Tuple, std::size_t... Is>
     void foreach_impl(F && func, Tuple && tuple,
-                      std::index_sequence<Is...> &&) {
+                      std::index_sequence<Is...> && /*unused*/) {
       (void)std::initializer_list<int>{
           (std::forward<F>(func)(std::get<Is>(std::forward<Tuple>(tuple))),
            0)...};
     }
 
     template <class F, class Tuple, std::size_t... Is>
     decltype(auto) transform_impl(F && func, Tuple && tuple,
-                                  std::index_sequence<Is...> &&) {
+                                  std::index_sequence<Is...> && /*unused*/) {
       return make_tuple_no_decay(
           std::forward<F>(func)(std::get<Is>(std::forward<Tuple>(tuple)))...);
     }
   } // namespace details
 
   /* ------------------------------------------------------------------------ */
   template <class Tuple> bool are_not_equal(Tuple && a, Tuple && b) {
     return details::Foreach<std::tuple_size<std::decay_t<Tuple>>::value>::
         not_equal(std::forward<Tuple>(a), std::forward<Tuple>(b));
   }
 
   template <class F, class Tuple> void foreach (F && func, Tuple && tuple) {
     return details::foreach_impl(
         std::forward<F>(func), std::forward<Tuple>(tuple),
         std::make_index_sequence<
             std::tuple_size<std::decay_t<Tuple>>::value>{});
   }
 
   template <class F, class Tuple>
   decltype(auto) transform(F && func, Tuple && tuple) {
     return details::transform_impl(
         std::forward<F>(func), std::forward<Tuple>(tuple),
         std::make_index_sequence<
             std::tuple_size<std::decay_t<Tuple>>::value>{});
   }
 
   namespace details {
     template <class Tuple, std::size_t... Is>
-    decltype(auto) flatten(Tuple && tuples, std::index_sequence<Is...>) {
+    decltype(auto) flatten(Tuple && tuples,
+                           std::index_sequence<Is...> /*unused*/) {
       return std::tuple_cat(std::get<Is>(tuples)...);
     }
   } // namespace details
 
   template <class Tuple> decltype(auto) flatten(Tuple && tuples) {
     return details::flatten(std::forward<Tuple>(tuples),
                             std::make_index_sequence<
                                 std::tuple_size<std::decay_t<Tuple>>::value>());
   }
 
   template <template <class> class traits, typename... Ts>
   struct conjunction {};
 
   template <template <class> class traits, typename... Ts>
   struct conjunction<traits, std::tuple<Ts...>>
       : public aka::conjunction<typename traits<Ts>::value...> {};
 
 } // namespace tuple
 
 namespace tuple {
   namespace details {
     /* ---------------------------------------------------------------------- */
     template <typename tag, typename type> struct named_tag {
       using _tag = tag;   ///< key
       using _type = type; ///< value type
 
-      template <typename T>
-      explicit named_tag(T && value) : _value(std::forward<T>(value)) {}
+      template <
+          typename T,
+          std::enable_if_t<not std::is_same<named_tag, T>::value> * = nullptr>
+      explicit named_tag(T && value) // NOLINT
+          : _value(std::forward<T>(value)) {}
 
       type _value;
     };
 
 /* ---------------------------------------------------------------------- */
 #if (defined(__GNUC__) || defined(__GNUG__))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Weffc++"
 #endif
     template <typename tag> struct named_tag_proxy {
       using _tag = tag;
 
       template <typename T> decltype(auto) operator=(T && value) {
         return named_tag<tag, T>{std::forward<T>(value)};
       }
     };
 #if (defined(__GNUC__) || defined(__GNUG__))
 #pragma GCC diagnostic pop
 #endif
 
     template <typename T> struct is_named_tag : public std::false_type {};
     template <typename tag>
     struct is_named_tag<named_tag_proxy<tag>> : public std::true_type {};
 
     /* ---------------------------------------------------------------------- */
     /// Named tuple is just tuple of named params
     template <typename... Params>
     struct named_tuple : public std::tuple<Params...> {
       template <typename... Args>
       named_tuple(Args &&... args)
           : std::tuple<Args...>(std::forward<Args>(args)...) {}
 
     private:
       template <typename tag, std::size_t Idx,
                 std::enable_if_t<Idx == sizeof...(Params)> * = nullptr>
       static constexpr std::size_t get_element_index() noexcept {
         return -1;
       }
 
       template <typename tag, std::size_t Idx,
                 std::enable_if_t<(Idx < sizeof...(Params))> * = nullptr>
       static constexpr std::size_t get_element_index() noexcept {
         using element_t = std::tuple_element_t<Idx, std::tuple<Params...>>;
         return (std::is_same<typename element_t::_tag, tag>::value)
                    ? Idx
                    : get_element_index<tag, Idx + 1>();
       }
 
     public:
       template <typename NT,
                 std::enable_if_t<is_named_tag<NT>::value> * = nullptr>
-      constexpr decltype(auto) get(NT &&) noexcept {
+      constexpr decltype(auto) get(NT && /*unused*/) noexcept {
         const auto index = get_element_index<typename NT::_tag, 0>();
         static_assert((index != -1), "wrong named_tag");
         return (std::get<index>(*this)._value);
       }
 
       template <typename NT,
                 std::enable_if_t<is_named_tag<NT>::value> * = nullptr>
-      constexpr decltype(auto) get(NT &&) const noexcept {
+      constexpr decltype(auto) get(NT && /*unused*/) const noexcept {
         const auto index = get_element_index<typename NT::_tag, 0>();
         static_assert((index != -1), "wrong named_tag");
 
         return std::get<index>(*this)._value;
       }
     };
 
   } // namespace details
 
   template <typename... Params>
   constexpr decltype(auto) make_named_tuple(Params &&... params) noexcept {
     return details::named_tuple<Params...>(std::forward<Params>(params)...);
   }
 
   template <typename tag> constexpr decltype(auto) make_named_tag() noexcept {
     return details::named_tag_proxy<tag>{};
   }
 
   template <size_t HashCode> constexpr decltype(auto) get() {
     return make_named_tag<std::integral_constant<size_t, HashCode>>();
   }
 
   template <size_t HashCode, class Tuple>
   constexpr decltype(auto) get(Tuple && tuple) {
     return tuple.get(get<HashCode>());
   }
 
   template <typename Param, typename Tuple,
             std::enable_if_t<details::is_named_tag<Param>::value> * = nullptr>
   constexpr decltype(auto) get(Tuple && tuple) noexcept {
     return tuple.template get<typename Param::hash>();
   }
 
-
 #if defined(__INTEL_COMPILER)
 // intel warnings here
 #elif defined(__clang__)
 // clang warnings here
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
 #elif (defined(__GNUC__) || defined(__GNUG__))
 // gcc warnings here
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpedantic"
 #endif
 
   /// this is a GNU exstension
   /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3599.html
   template <class CharT, CharT... chars>
   constexpr decltype(auto) operator"" _n() {
     return make_named_tag<string_literal<CharT, chars...>>();
   }
 
 #if defined(__INTEL_COMPILER)
 #elif defined(__clang__)
 #pragma clang diagnostic pop
 #elif (defined(__GNUC__) || defined(__GNUG__))
 #pragma GCC diagnostic pop
 #endif
 
 } // namespace tuple
 } // namespace AKANTU_ITERATORS_NAMESPACE
 
 #endif /* AKANTU_AKA_TUPLE_TOOLS_HH */
diff --git a/include/iterators/aka_filter_iterator.hh b/include/iterators/aka_filter_iterator.hh
index 6f4c604..4722391 100644
--- a/include/iterators/aka_filter_iterator.hh
+++ b/include/iterators/aka_filter_iterator.hh
@@ -1,157 +1,158 @@
 /**
  * @file   aka_filter_iterator.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  jeu déc 12 2019
  *
  * @brief A Documented file.
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 <iterator>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKA_FILTER_ITERATOR_H
 #define AKA_FILTER_ITERATOR_H
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
 namespace AKANTU_ITERATORS_NAMESPACE {
 
 /* -------------------------------------------------------------------------- */
 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(std::move(container_begin)) {}
 
     FilterIterator(const FilterIterator &) = default;
 
     FilterIterator & operator++() {
       ++filter_it;
       return *this;
     }
 
     decltype(auto) operator*() {
       auto container_it = this->container_begin + *this->filter_it;
       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;
   };
 
   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_ITERATORS_NAMESPACE
 
 namespace std {
 template <class filter_iterator_t, class container_iterator_t>
 struct iterator_traits<::AKANTU_ITERATORS_NAMESPACE::iterators::FilterIterator<
     filter_iterator_t, container_iterator_t>> {
 private:
   using iterator_type =
       typename ::AKANTU_ITERATORS_NAMESPACE::iterators::FilterIterator<
           filter_iterator_t, container_iterator_t>;
+
 public:
   using iterator_category = typename iterator_type::iterator_category;
   using value_type = typename iterator_type::value_type;
   using difference_type = typename iterator_type::difference_type;
   using pointer = typename iterator_type::pointer;
   using reference = typename iterator_type::reference;
 };
 } // namespace std
- 
+
 #endif // AKA_FILTER_ITERATOR_H
diff --git a/include/iterators/aka_transform_iterator.hh b/include/iterators/aka_transform_iterator.hh
index 8c01865..7830f74 100644
--- a/include/iterators/aka_transform_iterator.hh
+++ b/include/iterators/aka_transform_iterator.hh
@@ -1,154 +1,156 @@
 /**
  * @file   aka_transform_iterator.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  jeu déc 12 2019
  *
  * @brief transform adaptors
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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-iterators 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.
+ * akantu-iterators 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/>.
+ * along with akantu-iterators. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
+#include "aka_compatibilty_with_cpp_standard.hh"
+/* -------------------------------------------------------------------------- */
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKA_TRANSFORM_ITERATOR_H
 #define AKA_TRANSFORM_ITERATOR_H
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
 namespace AKANTU_ITERATORS_NAMESPACE {
 
 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<aka::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; });
 }
 
 } // namespace AKANTU_ITERATORS_NAMESPACE
 
 #endif // AKA_TRANSFORM_ITERATOR_H
diff --git a/test/test_iterators.cc b/test/test_iterators.cc
index 5d0a499..8faf968 100644
--- a/test/test_iterators.cc
+++ b/test/test_iterators.cc
@@ -1,377 +1,376 @@
 /**
  * @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-iterators 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.
+ * akantu-iterators 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/>.
+ * along with akantu-iterators. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 using namespace aka;
 
 /* -------------------------------------------------------------------------- */
 
 // 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 it = begin;
   ++it;
   EXPECT_EQ(begin, --it);
 
   it = begin;
   EXPECT_EQ(begin, it++);
   EXPECT_EQ(begin, --it);
 
   auto it2 = it = begin;
   ++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};
   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_{1, 3, 4, 10, 8, 6};
   for (auto && data : zip(filter_, filter(filter_, values))) {
     EXPECT_EQ(std::get<0>(data), std::get<1>(data));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 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));
   }
 }
-