Add missing scalar prim signatures

.github/workflows/header_checks.yml → .github/workflows/checks.yml

@@ -1,4 +1,4 @@
-name: Header checks
+name: Header & signature checks
 
 on:
   pull_request:
@@ -80,3 +80,19 @@ jobs:
       run: |
         echo "STAN_NO_RANGE_CHECKS=true" > make/local
         ./runTests.py -j2 ./test/unit/math/prim/err/
+  prim_scalar_sig_checks:
+    name: Prim scalar signature schecks
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: n1hility/cancel-previous-runs@v2
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        workflow: c-cpp.yml
+      if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/master' && github.ref != 'refs/heads/develop'"
+
+    - uses: actions/checkout@v2
+
+    - name: Run Prim scalar signature schecks
+      run: |
+        ./runTests.py test/scalar_prim_sig

runTests.py

@@ -315,6 +315,21 @@ def handleExpressionTests(tests, only_functions, n_test_files):
             -1,
         )
 
+def handleScalarPrimSigTests(tests):
+    scalar_prim_sig_tests = False
+    for n, i in list(enumerate(tests))[::-1]:
+        if "test/scalar_prim_sig" in i or "test/scalar_prim_sig" in i:
+            del tests[n]
+            scalar_prim_sig_tests = True
+    if scalar_prim_sig_tests:
+        HERE = os.path.dirname(os.path.realpath(__file__))
+        sys.path.append(os.path.join(HERE, "test"))
+        sys.path.append(os.path.join(HERE, "test/expressions"))
+        import generate_prim_sig_tests
+
+        generate_prim_sig_tests.main()
+        tests.append("test/expressions/prim_sig_test.cpp")
+
 
 def checkToolchainPathWindows():
     if isWin():
@@ -357,6 +372,7 @@ def main():
     else:
         num_expr_test_files = inputs.e
     handleExpressionTests(tests, inputs.only_functions, num_expr_test_files)
+    handleScalarPrimSigTests(tests)
 
     tests = findTests(inputs.tests, inputs.f, inputs.do_jumbo)
 

stan/math/prim/fun.hpp

@@ -22,6 +22,7 @@
 #include <stan/math/prim/fun/asinh.hpp>
 #include <stan/math/prim/fun/assign.hpp>
 #include <stan/math/prim/fun/atan.hpp>
+#include <stan/math/prim/fun/atan2.hpp>
 #include <stan/math/prim/fun/atanh.hpp>
 #include <stan/math/prim/fun/autocorrelation.hpp>
 #include <stan/math/prim/fun/autocovariance.hpp>

stan/math/prim/fun/abs.hpp

@@ -17,7 +17,7 @@ namespace math {
  * Return the absolute value of the specified arithmetic argument.
  * The return type is the same as the argument type.
  *
- * @tparam T type of arument (must be arithmetic)
+ * @tparam T type of argument (must be arithmetic)
  * @param x argument
  * @return absolute value of argument
  */

stan/math/prim/fun/atan2.hpp

@@ -0,0 +1,29 @@
+#ifndef STAN_MATH_PRIM_FUN_ATAN2_HPP
+#define STAN_MATH_PRIM_FUN_ATAN2_HPP
+
+#include <stan/math/prim/core.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <cmath>
+
+namespace stan {
+namespace math {
+
+/**
+ * Returns the principal value of the arg tangent of y/x,
+ * expressed in radians.
+ *
+ * @tparam T1 type of first argument (must be arithmetic)
+ * @tparam T2 type of second argument (must be arithmetic)
+ * @param y first argument
+ * @param x second argument
+ * @return `atan2()` value of the arguments
+ */
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
+return_type_t<T1, T2> atan2(T1 y, T2 x) {
+  return std::atan2(y, x);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/fmod.hpp

@@ -8,6 +8,20 @@
 namespace stan {
 namespace math {
 
+/**
+ * The mod() function implementation for scalar inputs.
+ *
+ * @tparam T1 type of first input
+ * @tparam T2 type of second input
+ * @param a First input
+ * @param b Second input
+ * @return fmod function applied to the two inputs.
+ */
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
+inline auto fmod(const T1& a, const T2& b) {
+  return std::fmod(a, b);
+}
+
 /**
  * Enables the vectorised application of the fmod function,
  * when the first and/or second arguments are containers.

stan/math/prim/fun/max.hpp

@@ -11,6 +11,21 @@
 namespace stan {
 namespace math {
 
+/**
+ * Returns the maximum coefficient of the two specified
+ * scalar arguments.
+ *
+ * @tparam T1 type of first argument (must be arithmetic)
+ * @tparam T2 type of second argument (must be arithmetic)
+ * @param x first argument
+ * @param y second argument
+ * @return maximum value of the two arguments
+ */
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
+return_type_t<T1, T2> max(T1 x, T2 y) {
+  return std::max(x, y);
+}
+
 /**
  * Returns the maximum coefficient in the specified
  * matrix, vector, row vector or std vector.

stan/math/prim/fun/min.hpp

@@ -10,6 +10,21 @@
 namespace stan {
 namespace math {
 
+/**
+ * Returns the minimum coefficient of the two specified
+ * scalar arguments.
+ *
+ * @tparam T1 type of first argument (must be arithmetic)
+ * @tparam T2 type of second argument (must be arithmetic)
+ * @param x first argument
+ * @param y second argument
+ * @return minimum value of the two arguments
+ */
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
+return_type_t<T1, T2> min(T1 x, T2 y) {
+  return std::min(x, y);
+}
+
 /**
  * Returns the minimum coefficient in the specified
  * matrix, vector, row vector or std vector.

stan/math/prim/fun/pow.hpp

@@ -28,6 +28,20 @@ inline complex_return_t<U, V> complex_pow(const U& x, const V& y) {
 }
 }  // namespace internal
 
+/**
+ * The pow() function implementation for scalar inputs.
+ *
+ * @tparam T1 type of first input
+ * @tparam T2 type of second input
+ * @param a First input
+ * @param b Second input
+ * @return pow function applied to the two inputs.
+ */
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
+inline auto pow(const T1& a, const T2& b) {
+  return std::pow(a, b);
+}
+
 /**
  * Enables the vectorised application of the pow function, when
  * the first and/or second arguments are containers.

stan/math/rev/core/count_vars.hpp

@@ -114,7 +114,7 @@ inline size_t count_vars_impl(size_t count, const var& x, Pargs&&... args) {
  * Arguments without vars contribute zero to the total number of vars.
  *
  * Return the running total number of vars plus the number of
- *   vars in the remaining aruments.
+ *   vars in the remaining arguments.
  *
  * @tparam Arith An object that is either arithmetic or holds arithmetic
  * types

test/generate_prim_sig_tests.py

@@ -0,0 +1,90 @@
+#!/usr/bin/python
+
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
+import numbers
+import sys
+
+from sig_utils import handle_function_list, get_signatures
+from signature_parser import SignatureParser
+from code_generator import CodeGenerator
+
+src_folder = "./test/expressions/"
+build_folder = "./test/expressions/"
+
+test_code_template = """
+TEST(PrimSigsTests, {test_name}) {{
+/*
+{comment}
+ */    
+{code}
+{check}
+}}
+"""
+
+
+def main():
+    """
+    Generates tests to check primitive scalar functions.
+
+    The tests check whether the primitive scalar functions are defined in the
+    stan::math namespace and that no stan::math::var objects are created when
+    they are used. If a var object is created, some of the input arguments
+    were cast into a var and the reverse mode function was called.
+
+    """
+
+    tests = []
+
+    default_checks = True
+    signatures = set(get_signatures())
+
+    for n, signature in enumerate(signatures):
+        sp = SignatureParser(signature)
+
+        # skip ignored signatures if running the default checks
+        if default_checks and sp.is_ignored():
+            continue
+
+        # skip signatures without inputs that can be eigen types
+        if (
+            not sp.has_scalar_only_args()
+            or sp.returns_complex()
+            or sp.is_nullary()
+            or sp.is_rng()
+        ):
+            continue
+
+        cg = CodeGenerator()
+
+        arg_list_no_expression = cg.build_arguments(
+            sp, sp.number_arguments() * ["Prim"], size=1
+        )
+
+        # Check results with expressions and without are the same
+        cpp_function_name = "stan::math::" + sp.function_name
+        result_1 = cg.function_call_assign(cpp_function_name, *arg_list_no_expression)
+        result_2 = cg.function_call_assign(cpp_function_name, *arg_list_no_expression)
+        cg.expect_eq(result_1, result_2)
+
+        var_check = (
+            "EXPECT_EQ(stan::math::ChainableStack::instance_->var_stack_.size(), 0);\n"
+            + "EXPECT_EQ(stan::math::ChainableStack::instance_->var_nochain_stack_.size(), 0);\n"
+            + "EXPECT_EQ(stan::math::ChainableStack::instance_->var_alloc_stack_.size(), 0);\n"
+        )
+
+        tests.append(
+            test_code_template.format(
+                overload="Prim",
+                comment=signature.strip(),
+                test_name=sp.function_name + repr(n),
+                code=cg.cpp(),
+                check=var_check,
+            )
+        )
+
+    with open(src_folder + "prim_sig_test.cpp", "w") as out:
+        out.write(
+            "#include <stan/math.hpp>\n\n#include <test/expressions/expression_test_helpers.hpp>\n\n"
+        )
+        for test in tests:
+            out.write(test)

test/prob/cauchy/cauchy_cdf_test.hpp

@@ -72,8 +72,8 @@ class AgradCdfCauchy : public AgradCdfTest {
                                                         const T_scale& sigma,
                                                         const T3&, const T4&,
                                                         const T5&) {
+    using stan::math::atan2;
     using stan::math::pi;
-    using std::atan2;
     return atan2(y - mu, sigma) / pi() + 0.5;
   }
 };

test/prob/frechet/frechet_ccdf_log_test.hpp

@@ -69,9 +69,9 @@ class AgradCcdfLogFrechet : public AgradCcdfLogTest {
   stan::return_type_t<T_y, T_shape, T_scale> ccdf_log_function(
       const T_y& y, const T_shape& alpha, const T_scale& sigma, const T3&,
       const T4&, const T5&) {
-    using std::exp;
-    using std::log;
-    using std::pow;
+    using stan::math::exp;
+    using stan::math::log;
+    using stan::math::pow;
     return log(1.0 - exp(-pow(sigma / y, alpha)));
   }
 };

test/prob/frechet/frechet_cdf_log_test.hpp

@@ -74,8 +74,8 @@ class AgradCdfLogFrechet : public AgradCdfLogTest {
   stan::return_type_t<T_y, T_shape, T_scale> cdf_log_function(
       const T_y& y, const T_shape& alpha, const T_scale& sigma, const T3&,
       const T4&, const T5&) {
-    using std::log;
-    using std::pow;
+    using stan::math::log;
+    using stan::math::pow;
     return -pow(sigma / y, alpha);
   }
 };

test/prob/frechet/frechet_cdf_test.hpp

@@ -75,8 +75,8 @@ class AgradCdfFrechet : public AgradCdfTest {
                                                           const T_scale& sigma,
                                                           const T3&, const T4&,
                                                           const T5&) {
-    using std::log;
-    using std::pow;
+    using stan::math::log;
+    using stan::math::pow;
     return exp(-pow(sigma / y, alpha));
   }
 };

test/prob/frechet/frechet_test.hpp

@@ -74,10 +74,10 @@ class AgradDistributionsFrechet : public AgradDistributionTest {
       const T_y& y, const T_shape& alpha, const T_scale& sigma, const T3&,
       const T4&, const T5&) {
     using stan::math::include_summand;
+    using stan::math::log;
     using stan::math::multiply_log;
+    using stan::math::pow;
     using stan::math::value_of;
-    using std::log;
-    using std::pow;
 
     return log(alpha) + multiply_log(alpha, sigma) - multiply_log(alpha + 1, y)
            - pow(sigma / y, alpha);

test/prob/loglogistic/loglogistic_cdf_test.hpp

@@ -1,9 +1,9 @@
 // Arguments: Doubles, Doubles, Doubles
 #include <stan/math/prim.hpp>
 
+using stan::math::pow;
 using stan::math::var;
 using std::numeric_limits;
-using std::pow;
 using std::vector;
 
 class AgradCdfLogistic : public AgradCdfTest {

test/prob/normal/normal_cdf_log_test.hpp

@@ -83,13 +83,13 @@ class AgradCdfLogNormal : public AgradCdfLogTest {
   stan::return_type_t<T_y, T_loc, T_scale> cdf_log_function(
       const T_y& y, const T_loc& mu, const T_scale& sigma, const T3&, const T4&,
       const T5&) {
+    using stan::math::exp;
+    using stan::math::log;
+    using stan::math::log1p;
     using stan::math::LOG_HALF;
+    using stan::math::pow;
     using stan::math::SQRT_PI;
     using stan::math::SQRT_TWO;
-    using std::exp;
-    using std::log;
-    using std::log1p;
-    using std::pow;
 
     stan::return_type_t<T_y, T_loc, T_scale> cdf_log(0.0);
 

test/prob/pareto_type_2/pareto_type_2_ccdf_log_test.hpp

@@ -65,8 +65,6 @@ class AgradCcdfLogParetoType2 : public AgradCcdfLogTest {
   stan::return_type_t<T_y, T_loc, T_scale, T_shape> ccdf_log_function(
       const T_y& y, const T_loc& mu, const T_scale& lambda,
       const T_shape& alpha, const T4&, const T5&) {
-    using std::log;
-    using std::pow;
-    return log(pow(1.0 + (y - mu) / lambda, -alpha));
+    return stan::math::log(stan::math::pow(1.0 + (y - mu) / lambda, -alpha));
   }
 };

test/prob/pareto_type_2/pareto_type_2_cdf_log_test.hpp

@@ -64,8 +64,6 @@ class AgradCdfLogParetoType2 : public AgradCdfLogTest {
   stan::return_type_t<T_y, T_loc, T_scale, T_shape> cdf_log_function(
       const T_y& y, const T_loc& mu, const T_scale& lambda,
       const T_shape& alpha, const T4&, const T5&) {
-    using stan::math::log1m;
-    using std::pow;
-    return log1m(pow(1.0 + (y - mu) / lambda, -alpha));
+    return stan::math::log1m(stan::math::pow(1.0 + (y - mu) / lambda, -alpha));
   }
 };