algorithms.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2024 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
// This file contains stl-like algorithms
#include <iosfwd>
#include <ranges>
 
#include <ikarus/utils/traits.hh>
namespace Ikarus::utils {
 
  void makeUniqueAndSort(std::ranges::random_access_range auto& r) {
    sort(r.begin(), r.end());
    r.erase(std::unique(r.begin(), r.end()), r.end());
  }
 
  template <typename Value>
  auto appendUnique(std::ranges::random_access_range auto& r, Value&& v) {
    static_assert(std::is_same_v<typename decltype(begin(r))::value_type, std::remove_reference_t<decltype(v)>>);
    const auto it = find(begin(r), end(r), v);
    size_t index  = std::distance(begin(r), it);
    if (it == end(r)) r.push_back(std::forward<Value>(v));
 
    return index;
  }
 
  template <class Container>
  void printContent(Container&& c, std::ostream& os = std::cout) {
    std::ranges::for_each(c, [&os](auto&& var) { os << var << '\n'; });
  }
 
  template <class Container>
  auto transformValueRangeToPointerRange(Container& cont) {
    auto transformValueToPointer = [](auto&& obj) { return &obj; };
    return (std::ranges::subrange(cont.begin(), cont.end()) | std::views::transform(transformValueToPointer));
  }
 
  template <class Container>
  auto transformPointerRangeToReferenceRange(Container& cont) {
    auto transformValueToPointer = [](auto&& obj) -> auto& { return *obj; };
    return (std::ranges::subrange(cont.begin(), cont.end()) | std::views::transform(transformValueToPointer));
  }
 
#ifndef DOXYGEN
  // Forward declare functions
  template <typename... Types>
  auto makeNestedTupleFlat(std::tuple<Types...> tup);
#endif
 
  namespace Impl {
    template <class Tuple, std::size_t... I>
    constexpr auto makeTupleSubsetImpl(Tuple&& t, std::index_sequence<I...>) {
      return std::make_tuple(std::get<I>(std::forward<Tuple>(t))...);
    }
 
    template <class Tuple, std::size_t... I>
    constexpr auto makeTupleFromTupleIndicesImpl(Tuple&& t, std::index_sequence<I...>) {
      return std::make_tuple(std::get<I>(std::forward<Tuple>(t))...);
    }
 
    template <typename T, typename... Ts>
    struct uniqueImpl : std::type_identity<T> {};
 
    template <typename... Ts, typename U, typename... Us>
    struct uniqueImpl<std::tuple<Ts...>, U, Us...>
        : std::conditional_t<(std::is_same_v<U, Ts> || ...), uniqueImpl<std::tuple<Ts...>, Us...>,
                             uniqueImpl<std::tuple<Ts..., U>, Us...>> {};
 
    template <typename... Ts>
    using unique_tupleImpl = typename uniqueImpl<std::tuple<>, Ts...>::type;
 
    template <typename T, typename... Types>
    auto makeNestedTupleFlatImpl() {
      constexpr bool isTuple = traits::isSpecialization<std::tuple, T>::value;
      if constexpr (sizeof...(Types) > 0) {
        if constexpr (isTuple)
          return std::tuple_cat(makeNestedTupleFlat(T()), makeNestedTupleFlatImpl<Types...>());
        else
          return std::tuple_cat(std::make_tuple(T()), makeNestedTupleFlatImpl<Types...>());
      } else {
        if constexpr (isTuple)
          return makeNestedTupleFlat(T());
        else
          return std::make_tuple(T());
      }
    }
 
    template <typename T, typename... Types>
    auto makeNestedTupleFlatAndStoreReferencesImpl(const std::tuple<T, Types...>& tup) {
      constexpr bool isTuple = traits::isSpecialization<std::tuple, std::remove_cvref_t<T>>::value;
      if constexpr (sizeof...(Types) > 0) {
        if constexpr (isTuple)
          return std::tuple_cat(
              makeNestedTupleFlatAndStoreReferencesImpl(std::get<0>(tup)),
              std::apply(
                  [](const T&, const Types&... args) {
                    return makeNestedTupleFlatAndStoreReferencesImpl(std::make_tuple(std::cref(args)...));
                  },
                  tup));
        else
          return std::tuple_cat(
              std::make_tuple(std::cref(std::get<0>(tup))),
              std::apply(
                  [](const T&, const Types&... args) {
                    return makeNestedTupleFlatAndStoreReferencesImpl(std::make_tuple(std::cref(args)...));
                  },
                  tup));
      } else {
        if constexpr (isTuple)
          return makeNestedTupleFlatAndStoreReferencesImpl(std::get<0>(tup));
        else
          return std::make_tuple(std::cref(std::get<0>(tup)));
      }
    }
 
    template <typename T, typename... Types>
    auto makeNestedTupleFlatAndStoreReferencesNonConstImpl(const std::tuple<T, Types...>& tupconst) {
      auto& tup              = const_cast<std::tuple<T, Types...>&>(tupconst);
      constexpr bool isTuple = traits::isSpecialization<std::tuple, std::remove_cvref_t<T>>::value;
      if constexpr (sizeof...(Types) > 0) {
        if constexpr (isTuple)
          return std::tuple_cat(
              makeNestedTupleFlatAndStoreReferencesNonConstImpl(std::get<0>(tup)),
              std::apply(
                  [](T&, Types&... args) {
                    return makeNestedTupleFlatAndStoreReferencesNonConstImpl(std::make_tuple(std::ref(args)...));
                  },
                  tup));
        else
          return std::tuple_cat(
              std::make_tuple(std::ref(std::get<0>(tup))),
              std::apply(
                  [](T&, Types&... args) {
                    return makeNestedTupleFlatAndStoreReferencesNonConstImpl(std::make_tuple(std::ref(args)...));
                  },
                  tup));
      } else {
        if constexpr (isTuple)
          return makeNestedTupleFlatAndStoreReferencesNonConstImpl(std::get<0>(tup));
        else
          return std::make_tuple(std::ref(std::get<0>(tup)));
      }
    }
 
  }  // namespace Impl
 
  template <typename Tuple, typename Predicate>
  constexpr size_t find_if(Tuple&& tuple, Predicate pred) {
    size_t index        = std::tuple_size<std::remove_reference_t<Tuple>>::value;
    size_t currentIndex = 0;
    bool found          = false;
 
    Dune::Hybrid::forEach(tuple, [&](auto&& value) {
      if (!found && pred(value)) {
        index = currentIndex;
        found = true;
      }
      ++currentIndex;
    });
    return index;
  }
 
  template <typename Tuple, typename Predicate>
  bool none_of(Tuple&& tuple, Predicate pred) {
    return find_if(tuple, pred) == std::tuple_size<std::decay_t<Tuple>>::value;
  }
 
  template <typename Tuple, typename Predicate>
  bool any_of(Tuple&& tuple, Predicate pred) {
    return !none_of(tuple, pred);
  }
 
  template <typename Tuple, typename Predicate>
  auto filter(Tuple&& tuple, Predicate pred) {
    return std::apply(
        [&pred](auto... ts) {
          return std::tuple_cat(std::conditional_t<pred(ts), std::tuple<decltype(ts)>, std::tuple<>>{}...);
        },
        tuple);
  }
 
  template <typename... Types>
  constexpr auto unique([[maybe_unused]] std::tuple<Types...>&& tuple) {
    return Impl::unique_tupleImpl<Types...>();
  }
 
  template <typename Tuple, typename Predicate>
  constexpr size_t count_if(Tuple&& tuple, Predicate pred) {
    size_t counter = 0;
    Dune::Hybrid::forEach(tuple, [&](auto&& value) {
      if (pred(value)) ++counter;
    });
    return counter;
  }
 
  template <template <auto...> class Type, typename Tuple>
  constexpr int findTypeSpecialization() {
    return find_if(std::remove_cvref_t<Tuple>(), []<typename T>(T&&) {
      return traits::isSpecializationNonTypes<Type, std::remove_cvref_t<T>>::value;
    });
  }
 
  template <template <auto...> class Type, typename Tuple>
  auto getSpecialization(Tuple&& tuple) {
    constexpr int index = findTypeSpecialization<Type, Tuple>();
    static_assert(index < std::tuple_size_v<std::remove_cvref_t<Tuple>>,
                  "The found index has to be smaller than the tuple size");
    return std::get<index>(tuple);
  }
 
  template <template <auto...> class Type, typename Tuple>
  constexpr bool hasTypeSpecialization() {
    return (
        find_if(std::remove_cvref_t<Tuple>(),
                []<typename T>(T&&) { return traits::isSpecializationNonTypes<Type, std::remove_cvref_t<T>>::value; })
        < std::tuple_size_v<std::remove_cvref_t<Tuple>>);
  }
 
  template <template <auto...> class Type, typename Tuple>
  constexpr bool countTypeSpecialization() {
    return count_if(
        Tuple(), []<typename T>(T&&) { return traits::isSpecializationNonTypes<Type, std::remove_cvref_t<T>>::value; });
  }
 
  template <template <auto...> class Type, typename Tuple>
  static constexpr bool countTypeSpecialization_v = countTypeSpecialization<Type, Tuple>();
 
  template <int N, class Tuple>
  constexpr auto makeTupleSubset(Tuple&& t) {
    static_assert(N < std::tuple_size_v<std::remove_reference_t<Tuple>>,
                  "The requested size needs to be smaller than the size of the tuple.");
 
    return Impl::makeTupleSubsetImpl(std::forward<Tuple>(t), std::make_index_sequence<N>{});
  }
 
  template <class Tuple, std::size_t... I>
  constexpr auto makeTupleFromTupleIndices(Tuple&& t) {
    return Impl::makeTupleFromTupleIndicesImpl(std::forward<Tuple>(t), std::index_sequence<I...>{});
  }
 
  template <typename... Types>
  auto makeNestedTupleFlat(std::tuple<Types...>) {
    return decltype(Impl::makeNestedTupleFlatImpl<Types...>())();
  }
 
  template <typename Tuple>
  auto makeNestedTupleFlatAndStoreReferences(Tuple&& tup) {
    if constexpr (std::tuple_size_v<std::remove_cvref_t<Tuple>> == 0)
      return tup;
    else if constexpr (!std::is_const_v<std::remove_reference_t<Tuple>>)
      return Impl::makeNestedTupleFlatAndStoreReferencesNonConstImpl(std::forward<Tuple>(tup));
    else
      return Impl::makeNestedTupleFlatAndStoreReferencesImpl(std::forward<Tuple>(tup));
  }
 
  template <typename T>
  requires traits::Pointer<T>
  auto& returnReferenceOrNulloptIfObjectIsNullPtr(T v) {
    if constexpr (!std::is_same_v<T, std::nullptr_t>)
      return *v;
    else
      return std::nullopt;
  }
 
}  // namespace Ikarus::utils