Ambiguities with between C/C++/stan pow implementations

[bbbales2]

Description

There are ambiguities between different pow implementations causing us problems with the complex funs pull request: #1774 (comment)

And these ambiguities are causing problems with this branch: #1804 (comment)

Expected Output

Tests should work

Currently:

using namespace stan::math;
pow(1.0, 1)

Fails to compile.

We'd like these both to work:

using namespace stan::math;
pow(1.0, 1);

using namespace stan::math;
using std::pow;
pow(1.0, 1);

Current Version:

v3.1.0

[bbbales2]

We're implementing a temporary fix. See: https://discourse.mc-stan.org/t/using-std-pow-inside-stan-math-namespace/13975/14

If we get a prim implementation of pow, we should include these tests in prim:

#include <stan/math/prim.hpp>
#include <gtest/gtest.h>
#include <cmath>
#include <limits>
#include <vector>

namespace test1 {
  using namespace stan::math; // NOLINT(build/namespaces)                                                                                                                                                                                                                                                                                                                                   
  void test_pow() {
    EXPECT_FLOAT_EQ(pow(1.5, 1.5), 1.837117);
    EXPECT_FLOAT_EQ(pow(1.7, 2), 2.89);
  }
}

namespace test2 {
  using namespace std; // NOLINT(build/namespaces)                                                                                                                                                                                                                                                                                                                                          
  using namespace stan::math; // NOLINT(build/namespaces)                                                                                                                                                                                                                                                                                                                                   
  void test_pow() {
    EXPECT_FLOAT_EQ(pow(1.5, 1.5), 1.837117);
    EXPECT_FLOAT_EQ(pow(1.7, 2), 2.89);
  }
}

namespace test3 {
  using namespace stan::math; // NOLINT(build/namespaces)                                                                                                                                                                                                                                                                                                                                   
  void test_pow() {
    using std::pow;
    EXPECT_FLOAT_EQ(pow(1.5, 1.5), 1.837117);
    EXPECT_FLOAT_EQ(pow(1.7, 2), 2.89);
  }
}

namespace test4 {
  using namespace std; // NOLINT(build/namespaces)                                                                                                                                                                                                                                                                                                                                          
  void test_pow() {
    using stan::math::pow;
    EXPECT_FLOAT_EQ(pow(1.5, 1.5), 1.837117);
    EXPECT_FLOAT_EQ(pow(1.7, 2), 2.89);
  }
}

namespace test5 {
  using namespace std; // NOLINT(build/namespaces)                                                                                                                                                                                                                                                                                                                                          
  void test_pow() {
    EXPECT_FLOAT_EQ(pow(1.5, 1.5), 1.837117);
    EXPECT_FLOAT_EQ(pow(1.7, 2), 2.89);
  }
}

TEST(MathFunctions, powNamespaceChecks) {
  EXPECT_FLOAT_EQ(stan::math::pow(1.5, 1.5), 1.837117);
  EXPECT_FLOAT_EQ(stan::math::pow(1.7, 2), 2.89);

  {
    using stan::math::pow;
    EXPECT_FLOAT_EQ(pow(1.5, 1.5), 1.837117);
    EXPECT_FLOAT_EQ(pow(1.7, 2), 2.89);
  }

  {
    using std::pow;
    EXPECT_FLOAT_EQ(pow(1.5, 1.5), 1.837117);
    EXPECT_FLOAT_EQ(pow(1.7, 2), 2.89);
  }

  {
    using stan::math::pow;
    using std::pow;
    EXPECT_FLOAT_EQ(pow(1.5, 1.5), 1.837117);
    EXPECT_FLOAT_EQ(pow(1.7, 2), 2.89);
  }

  test1::test_pow();
  test2::test_pow();
  test3::test_pow();
  test4::test_pow();
  test5::test_pow();
}