Merge pull request #2771 from andrjohns/feature/as-int-fun

Add to_int function and tests

Author: bob-carpenter

stan/math/prim/fun.hpp

@@ -338,6 +338,7 @@
 #include <stan/math/prim/fun/to_array_1d.hpp>
 #include <stan/math/prim/fun/to_array_2d.hpp>
 #include <stan/math/prim/fun/to_complex.hpp>
+#include <stan/math/prim/fun/to_int.hpp>
 #include <stan/math/prim/fun/to_matrix.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/to_row_vector.hpp>

stan/math/prim/fun/to_int.hpp

@@ -0,0 +1,81 @@
+#ifndef STAN_MATH_PRIM_FUN_TO_INT_HPP
+#define STAN_MATH_PRIM_FUN_TO_INT_HPP
+
+#include <stan/math/prim/err/check_bounded.hpp>
+#include <stan/math/prim/functor/apply_scalar_unary.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Returns the input scalar as an integer type. Specialisation for integral
+ * types which do not need conversion, reduces to a no-op.
+ *
+ * @tparam T type of integral argument
+ * @param x argument
+ * @return Input argument unchanged
+ */
+template <typename T, require_integral_t<T>* = nullptr>
+inline T to_int(T x) {
+  return std::forward<T>(x);
+}
+
+/**
+ * Returns the input scalar as an integer type. This function performs no
+ * rounding and simply truncates the decimal to return only the signficand as an
+ * integer.
+ *
+ * Casting NaN and Inf values to integers is considered undefined behavior as
+ * NaN and Inf cannot be represented as an integer and most implementations
+ * simply overflow, as such this function throws for these inputs.
+ *
+ * The function also throws for floating-point values that are too large to be
+ * represented as an integer.
+ *
+ * @tparam T type of argument (must be arithmetic)
+ * @param x argument
+ * @return Integer value of argument
+ * @throw std::domain_error for NaN, Inf, or floating point values not in range
+ *        to be represented as int
+ */
+template <typename T, require_floating_point_t<T>* = nullptr>
+inline int to_int(T x) {
+  static const char* function = "to_int";
+  check_bounded(function, "x", x, std::numeric_limits<int>::min(),
+                std::numeric_limits<int>::max());
+  return static_cast<int>(x);
+}
+
+/**
+ * Return elementwise integer value of the specified real-valued
+ * container.
+ *
+ * @tparam T type of argument
+ * @param x argument
+ * @return Integer value of argument
+ */
+struct to_int_fun {
+  template <typename T>
+  static inline auto fun(const T& x) {
+    return to_int(x);
+  }
+};
+
+/**
+ * Returns the elementwise `to_int()` of the input,
+ * which may be a scalar or any Stan container of numeric scalars.
+ *
+ * @tparam Container type of container
+ * @param x argument
+ * @return Integer value of each variable in the container.
+ */
+template <typename Container,
+          require_std_vector_st<std::is_arithmetic, Container>* = nullptr>
+inline auto to_int(const Container& x) {
+  return apply_scalar_unary<to_int_fun, Container>::apply(x);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

test/unit/math/prim/fun/to_int_test.cpp

@@ -0,0 +1,58 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/util.hpp>
+#include <gtest/gtest.h>
+#include <cmath>
+#include <limits>
+
+TEST(MathFunctions, to_int_values) {
+  using stan::math::to_int;
+
+  EXPECT_EQ(2, to_int(2.0));
+  EXPECT_EQ(2, to_int(2.1));
+  EXPECT_EQ(2, to_int(2.9));
+  EXPECT_EQ(2, to_int(2.999999999));
+
+  EXPECT_EQ(-36574, to_int(-36574.0));
+  EXPECT_EQ(-36574, to_int(-36574.1));
+  EXPECT_EQ(-36574, to_int(-36574.9));
+  EXPECT_EQ(-36574, to_int(-36574.999999999));
+}
+
+TEST(MathFunctions, to_int_errors) {
+  using stan::math::INFTY;
+  using stan::math::NEGATIVE_INFTY;
+  using stan::math::NOT_A_NUMBER;
+  using stan::math::to_int;
+
+  EXPECT_THROW(to_int(std::numeric_limits<int>::max() + 1.0),
+               std::domain_error);
+  EXPECT_THROW(to_int(std::numeric_limits<int>::min() - 1.0),
+               std::domain_error);
+
+  EXPECT_THROW(to_int(NOT_A_NUMBER), std::domain_error);
+  EXPECT_THROW(to_int(INFTY), std::domain_error);
+  EXPECT_THROW(to_int(NEGATIVE_INFTY), std::domain_error);
+}
+
+TEST(MathFunctions, to_int_vec) {
+  using stan::math::to_int;
+
+  std::vector<double> inputs_1{2.1, -34.64, 10.89, 1000000};
+  std::vector<double> inputs_2{-409831.987, 403.1, 10.61, -0.00001};
+  std::vector<std::vector<double>> inputs{inputs_1, inputs_2};
+
+  std::vector<int> target_result_1{2, -34, 10, 1000000};
+  std::vector<int> target_result_2{-409831, 403, 10, 0};
+  std::vector<std::vector<int>> target_result{target_result_1, target_result_2};
+
+  EXPECT_STD_VECTOR_EQ(to_int(inputs), target_result);
+
+  inputs[0][2] = std::numeric_limits<int>::min() - 1.0;
+  EXPECT_THROW(to_int(inputs), std::domain_error);
+
+  std::vector<double> inputs_empty;
+  std::vector<double> inputs_size_one{1.5};
+
+  EXPECT_NO_THROW(to_int(inputs_empty));
+  EXPECT_STD_VECTOR_EQ(to_int(inputs_size_one), std::vector<int>{1});
+}