tuple.hpp

Go to the documentation of this file.

// Copyright (c) Lawrence Livermore National Security, LLC and
// other Smith Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include <utility>
 
#include "smith/infrastructure/accelerator.hpp"
 
namespace smith {
 
template <typename... T>
struct tuple {};
 
template <typename T0>
struct tuple<T0> {
  T0 v0;  
};
 
template <typename T0, typename T1>
struct tuple<T0, T1> {
  T0 v0;  
  T1 v1;  
};
 
template <typename T0, typename T1, typename T2>
struct tuple<T0, T1, T2> {
  T0 v0;  
  T1 v1;  
  T2 v2;  
};
 
template <typename T0, typename T1, typename T2, typename T3>
struct tuple<T0, T1, T2, T3> {
  T0 v0;  
  T1 v1;  
  T2 v2;  
  T3 v3;  
};
 
template <typename T0, typename T1, typename T2, typename T3, typename T4>
struct tuple<T0, T1, T2, T3, T4> {
  T0 v0;  
  T1 v1;  
  T2 v2;  
  T3 v3;  
  T4 v4;  
};
 
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
struct tuple<T0, T1, T2, T3, T4, T5> {
  T0 v0;  
  T1 v1;  
  T2 v2;  
  T3 v3;  
  T4 v4;  
  T5 v5;  
};
 
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
struct tuple<T0, T1, T2, T3, T4, T5, T6> {
  T0 v0;  
  T1 v1;  
  T2 v2;  
  T3 v3;  
  T4 v4;  
  T5 v5;  
  T6 v6;  
};
 
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
struct tuple<T0, T1, T2, T3, T4, T5, T6, T7> {
  T0 v0;  
  T1 v1;  
  T2 v2;  
  T3 v3;  
  T4 v4;  
  T5 v5;  
  T6 v6;  
  T7 v7;  
};
 
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
          typename T8>
struct tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> {
  T0 v0;  
  T1 v1;  
  T2 v2;  
  T3 v3;  
  T4 v4;  
  T5 v5;  
  T6 v6;  
  T7 v7;  
  T8 v8;  
};
 
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
          typename T8, typename T9>
struct tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
  T0 v0;  
  T1 v1;  
  T2 v2;  
  T3 v3;  
  T4 v4;  
  T5 v5;  
  T6 v6;  
  T7 v7;  
  T8 v8;  
  T9 v9;  
};
 
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
          typename T8, typename T9, typename T10>
struct tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
  T0 v0;    
  T1 v1;    
  T2 v2;    
  T3 v3;    
  T4 v4;    
  T5 v5;    
  T6 v6;    
  T7 v7;    
  T8 v8;    
  T9 v9;    
  T10 v10;  
};
 
template <typename... T>
tuple(T...) -> tuple<T...>;
 
template <typename... T>
SMITH_HOST_DEVICE tuple<T...> make_tuple(const T&... args)
{
  return tuple<T...>{args...};
}
 
template <class... Types>
struct tuple_size {};
 
template <class... Types>
struct tuple_size<smith::tuple<Types...>> : std::integral_constant<std::size_t, sizeof...(Types)> {};
 
template <int i, typename... T>
SMITH_HOST_DEVICE constexpr auto& get(tuple<T...>& values)
{
  static_assert(i < sizeof...(T), "");
  if constexpr (i == 0) {
    return values.v0;
  }
  if constexpr (i == 1) {
    return values.v1;
  }
  if constexpr (i == 2) {
    return values.v2;
  }
  if constexpr (i == 3) {
    return values.v3;
  }
  if constexpr (i == 4) {
    return values.v4;
  }
  if constexpr (i == 5) {
    return values.v5;
  }
  if constexpr (i == 6) {
    return values.v6;
  }
  if constexpr (i == 7) {
    return values.v7;
  }
  if constexpr (i == 8) {
    return values.v8;
  }
  if constexpr (i == 9) {
    return values.v9;
  }
  if constexpr (i == 10) {
    return values.v10;
  }
}
 
template <int i, typename... T>
SMITH_HOST_DEVICE constexpr const auto& get(const tuple<T...>& values)
{
  static_assert(i < sizeof...(T), "");
  if constexpr (i == 0) {
    return values.v0;
  }
  if constexpr (i == 1) {
    return values.v1;
  }
  if constexpr (i == 2) {
    return values.v2;
  }
  if constexpr (i == 3) {
    return values.v3;
  }
  if constexpr (i == 4) {
    return values.v4;
  }
  if constexpr (i == 5) {
    return values.v5;
  }
  if constexpr (i == 6) {
    return values.v6;
  }
  if constexpr (i == 7) {
    return values.v7;
  }
  if constexpr (i == 8) {
    return values.v8;
  }
  if constexpr (i == 9) {
    return values.v9;
  }
  if constexpr (i == 10) {
    return values.v10;
  }
}
 
template <int i, typename... T>
SMITH_HOST_DEVICE constexpr auto type(const tuple<T...>& values)
{
  static_assert(i < sizeof...(T), "");
  if constexpr (i == 0) {
    return values.v0;
  }
  if constexpr (i == 1) {
    return values.v1;
  }
  if constexpr (i == 2) {
    return values.v2;
  }
  if constexpr (i == 3) {
    return values.v3;
  }
  if constexpr (i == 4) {
    return values.v4;
  }
  if constexpr (i == 5) {
    return values.v5;
  }
  if constexpr (i == 6) {
    return values.v6;
  }
  if constexpr (i == 7) {
    return values.v7;
  }
  if constexpr (i == 8) {
    return values.v8;
  }
  if constexpr (i == 9) {
    return values.v9;
  }
  if constexpr (i == 10) {
    return values.v10;
  }
}
 
template <typename... S, typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto plus_helper(const tuple<S...>& x, const tuple<T...>& y,
                                             std::integer_sequence<int, i...>)
{
  return tuple{get<i>(x) + get<i>(y)...};
}
 
template <typename... S, typename... T>
SMITH_HOST_DEVICE constexpr auto operator+(const tuple<S...>& x, const tuple<T...>& y)
{
  static_assert(sizeof...(S) == sizeof...(T));
  return plus_helper(x, y, std::make_integer_sequence<int, static_cast<int>(sizeof...(S))>());
}
 
template <typename... T, int... i>
SMITH_HOST_DEVICE constexpr void plus_equals_helper(tuple<T...>& x, const tuple<T...>& y,
                                                    std::integer_sequence<int, i...>)
{
  ((get<i>(x) += get<i>(y)), ...);
}
 
template <typename... T>
SMITH_HOST_DEVICE constexpr auto operator+=(tuple<T...>& x, const tuple<T...>& y)
{
  return plus_equals_helper(x, y, std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <typename... T, int... i>
SMITH_HOST_DEVICE constexpr void minus_equals_helper(tuple<T...>& x, const tuple<T...>& y,
                                                     std::integer_sequence<int, i...>)
{
  ((get<i>(x) -= get<i>(y)), ...);
}
 
template <typename... T>
SMITH_HOST_DEVICE constexpr auto operator-=(tuple<T...>& x, const tuple<T...>& y)
{
  return minus_equals_helper(x, y, std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <typename... S, typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto minus_helper(const tuple<S...>& x, const tuple<T...>& y,
                                              std::integer_sequence<int, i...>)
{
  return tuple{get<i>(x) - get<i>(y)...};
}
 
template <typename... S, typename... T>
SMITH_HOST_DEVICE constexpr auto operator-(const tuple<S...>& x, const tuple<T...>& y)
{
  static_assert(sizeof...(S) == sizeof...(T));
  return minus_helper(x, y, std::make_integer_sequence<int, static_cast<int>(sizeof...(S))>());
}
 
template <typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto unary_minus_helper(const tuple<T...>& x, std::integer_sequence<int, i...>)
{
  return tuple{-get<i>(x)...};
}
 
template <typename... T>
SMITH_HOST_DEVICE constexpr auto operator-(const tuple<T...>& x)
{
  return unary_minus_helper(x, std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <typename... S, typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto div_helper(const tuple<S...>& x, const tuple<T...>& y,
                                            std::integer_sequence<int, i...>)
{
  return tuple{get<i>(x) / get<i>(y)...};
}
 
template <typename... S, typename... T>
SMITH_HOST_DEVICE constexpr auto operator/(const tuple<S...>& x, const tuple<T...>& y)
{
  static_assert(sizeof...(S) == sizeof...(T));
  return div_helper(x, y, std::make_integer_sequence<int, static_cast<int>(sizeof...(S))>());
}
 
template <typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto div_helper(const double a, const tuple<T...>& x, std::integer_sequence<int, i...>)
{
  return tuple{a / get<i>(x)...};
}
 
template <typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto div_helper(const tuple<T...>& x, const double a, std::integer_sequence<int, i...>)
{
  return tuple{get<i>(x) / a...};
}
 
template <typename... T>
SMITH_HOST_DEVICE constexpr auto operator/(const double a, const tuple<T...>& x)
{
  return div_helper(a, x, std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <typename... T>
SMITH_HOST_DEVICE constexpr auto operator/(const tuple<T...>& x, const double a)
{
  return div_helper(x, a, std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <typename... S, typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto mult_helper(const tuple<S...>& x, const tuple<T...>& y,
                                             std::integer_sequence<int, i...>)
{
  return tuple{get<i>(x) * get<i>(y)...};
}
 
template <typename... S, typename... T>
SMITH_HOST_DEVICE constexpr auto operator*(const tuple<S...>& x, const tuple<T...>& y)
{
  static_assert(sizeof...(S) == sizeof...(T));
  return mult_helper(x, y, std::make_integer_sequence<int, static_cast<int>(sizeof...(S))>());
}
 
template <typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto mult_helper(const double a, const tuple<T...>& x, std::integer_sequence<int, i...>)
{
  return tuple{a * get<i>(x)...};
}
 
template <typename... T, int... i>
SMITH_HOST_DEVICE constexpr auto mult_helper(const tuple<T...>& x, const double a, std::integer_sequence<int, i...>)
{
  return tuple{get<i>(x) * a...};
}
 
template <typename... T>
SMITH_HOST_DEVICE constexpr auto operator*(const double a, const tuple<T...>& x)
{
  return mult_helper(a, x, std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <typename... T>
SMITH_HOST_DEVICE constexpr auto operator*(const tuple<T...>& x, const double a)
{
  return mult_helper(x, a, std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <typename... T, std::size_t... i>
auto& print_helper(std::ostream& out, const smith::tuple<T...>& A, std::integer_sequence<size_t, i...>)
{
  out << "tuple{";
  (..., (out << (i == 0 ? "" : ", ") << smith::get<i>(A)));
  out << "}";
  return out;
}
 
template <typename... T>
auto& operator<<(std::ostream& out, const smith::tuple<T...>& A)
{
  return print_helper(out, A, std::make_integer_sequence<size_t, sizeof...(T)>());
}
 
template <typename lambda, typename... T, int... i>
SMITH_HOST_DEVICE auto apply_helper(lambda f, tuple<T...>& args, std::integer_sequence<int, i...>)
{
  return f(get<i>(args)...);
}
 
template <typename lambda, typename... T>
SMITH_HOST_DEVICE auto apply(lambda f, tuple<T...>& args)
{
  return apply_helper(f, std::move(args), std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <typename lambda, typename... T, int... i>
SMITH_HOST_DEVICE auto apply_helper(lambda f, const tuple<T...>& args, std::integer_sequence<int, i...>)
{
  return f(get<i>(args)...);
}
 
template <typename lambda, typename... T>
SMITH_HOST_DEVICE auto apply(lambda f, const tuple<T...>& args)
{
  return apply_helper(f, std::move(args), std::make_integer_sequence<int, static_cast<int>(sizeof...(T))>());
}
 
template <size_t I, class T>
struct tuple_element;
 
// recursive case
template <size_t I, class Head, class... Tail>
struct tuple_element<I, tuple<Head, Tail...>> : tuple_element<I - 1, tuple<Tail...>> {};
 
// base case
template <class Head, class... Tail>
struct tuple_element<0, tuple<Head, Tail...>> {
  using type = Head;  
};
 
template <typename T>
struct is_tuple : std::false_type {};
 
template <typename... T>
struct is_tuple<smith::tuple<T...>> : std::true_type {};
 
template <typename T>
struct is_tuple_of_tuples : std::false_type {};
 
template <typename... T>
struct is_tuple_of_tuples<smith::tuple<T...>> {
  static constexpr bool value = (is_tuple<T>::value && ...);  
};
 
}  // namespace smith
 
#include "smith/numerics/functional/tuple_tensor_dual_functions.hpp"