Add a few more type traits for use in stanc

Author: WardBrian

stan/math/prim/meta.hpp

@@ -95,7 +95,9 @@
 #include <stan/math/prim/meta/is_eigen_matrix.hpp>
 #include <stan/math/prim/meta/is_eigen_matrix_base.hpp>
 #include <stan/math/prim/meta/is_eigen_sparse_base.hpp>
+#include <stan/math/prim/meta/is_floating_point.hpp>
 #include <stan/math/prim/meta/is_fvar.hpp>
+#include <stan/math/prim/meta/is_integral.hpp>
 #include <stan/math/prim/meta/is_kernel_expression.hpp>
 #include <stan/math/prim/meta/is_matrix_cl.hpp>
 #include <stan/math/prim/meta/is_matrix.hpp>
@@ -128,6 +130,7 @@
 #include <stan/math/prim/meta/scalar_type.hpp>
 #include <stan/math/prim/meta/seq_view.hpp>
 #include <stan/math/prim/meta/static_select.hpp>
+#include <stan/math/prim/meta/tuple_elt.hpp>
 #include <stan/math/prim/meta/value_type.hpp>
 #include <stan/math/prim/meta/void_t.hpp>
 #include <stan/math/prim/meta/StdVectorBuilder.hpp>

stan/math/prim/meta/is_floating_point.hpp

@@ -0,0 +1,29 @@
+#ifndef STAN_MATH_PRIM_META_IS_FLOATING_POINT_HPP
+#define STAN_MATH_PRIM_META_IS_FLOATING_POINT_HPP
+
+#include <type_traits>
+
+namespace stan {
+
+/**
+ * Checks if decayed type is a floating point type
+ * @tparam The type to check
+ * @ingroup type_trait
+ */
+template <typename T>
+using is_floating_point = std::is_floating_point<std::decay_t<T>>;
+
+template <typename T>
+inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
+
+template <typename... Types>
+inline constexpr bool is_all_floating_point_v
+    = (is_floating_point_v<Types> && ...);
+
+template <typename... Types>
+inline constexpr bool is_any_floating_point_v
+    = (is_floating_point_v<Types> || ...);
+
+}  // namespace stan
+
+#endif

stan/math/prim/meta/is_integral.hpp

@@ -0,0 +1,27 @@
+#ifndef STAN_MATH_PRIM_META_IS_INTEGRAL_HPP
+#define STAN_MATH_PRIM_META_IS_INTEGRAL_HPP
+
+#include <type_traits>
+
+namespace stan {
+
+/**
+ * Checks if decayed type is integral
+ * @tparam The type to check
+ * @ingroup type_trait
+ */
+template <typename T>
+using is_integral = std::is_integral<std::decay_t<T>>;
+
+template <typename T>
+inline constexpr bool is_integral_v = is_integral<T>::value;
+
+template <typename... Types>
+inline constexpr bool is_all_integral_v = (is_integral_v<Types> && ...);
+
+template <typename... Types>
+inline constexpr bool is_any_integral_v = (is_integral_v<Types> || ...);
+
+}  // namespace stan
+
+#endif

stan/math/prim/meta/is_tuple.hpp

@@ -1,6 +1,7 @@
 #ifndef STAN_MATH_PRIM_META_IS_TUPLE_HPP
 #define STAN_MATH_PRIM_META_IS_TUPLE_HPP
 
+#include <cstddef>
 #include <stan/math/prim/meta/require_helpers.hpp>
 #include <tuple>
 #include <type_traits>
@@ -49,6 +50,26 @@ using require_all_not_tuple_t
 /*! @} */
 }  // namespace math
 
+template <typename T>
+using is_tuple = math::is_tuple<T>;
+
+template <typename T>
+inline constexpr bool is_tuple_v = math::is_tuple_v<T>;
+
+/**
+ * Checks both that T is a tuple and that its size is N
+ * @tparam T type to retrieve the element from
+ * @tparam N expected size
+ * @ingroup type_trait
+ */
+template <typename T, std::size_t N>
+struct is_tuple_of_size
+    : std::bool_constant<is_tuple_v<T>
+                         && std::tuple_size_v<std::decay_t<T>> == N> {};
+
+template <typename T, std::size_t N>
+inline constexpr bool is_tuple_of_size_v = is_tuple_of_size<T, N>::value;
+
 }  // namespace stan
 
 #endif

stan/math/prim/meta/tuple_elt.hpp

@@ -0,0 +1,32 @@
+#ifndef STAN_MATH_PRIM_META_IS_TUPLE_ELT_HPP
+#define STAN_MATH_PRIM_META_IS_TUPLE_ELT_HPP
+
+#include <type_traits>
+#include <cstddef>
+#include <tuple>
+
+namespace stan {
+
+/**
+ * Equivalent to std::tuple_element but returns void if N is out of range
+ * to avoid a static assertion failure in libstdc++.
+ * @tparam N index of the element to retrieve
+ * @tparam T type to retrieve the element from
+ * @ingroup type_trait
+ */
+template <std::size_t N, typename T, typename = void>
+struct tuple_element {
+  using type = void;
+};
+
+template <std::size_t N, typename T>
+struct tuple_element<
+    N, T, std::enable_if_t<(N < std::tuple_size_v<std::decay_t<T>>)>> {
+  using type = std::tuple_element_t<N, std::decay_t<T>>;
+};
+
+template <std::size_t N, typename T>
+using tuple_element_t = typename tuple_element<N, T>::type;
+}  // namespace stan
+
+#endif