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 T>
auto appendUnique(std::ranges::random_access_range auto& r, T&& 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<T>(v));
 
  return index;
}
 
template <class C>
void printContent(C&& c, std::ostream& os = std::cout) {
  std::ranges::for_each(c, [&os](auto&& var) { os << var << '\n'; });
}
 
template <class C>
auto transformValueRangeToPointerRange(C& cont) {
  auto transformValueToPointer = [](auto&& obj) { return &obj; };
  return (std::ranges::subrange(cont.begin(), cont.end()) | std::views::transform(transformValueToPointer));
}
 
template <class C>
auto transformPointerRangeToReferenceRange(C& 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