Encapsulate std::complex functions (#3122)

* testing encapsulation of std complex * fix all headers in rev * add docs for all new functions * fix conj * fix complex conj * [Jenkins] auto-formatting by clang-format version 10.0.0-4ubuntu1 * fix double header includes * fix docs * update fwd includes * update includes for fwd to always prefer fwd version before prim version. * update includes for fwd to always prefer fwd version before prim version. * Docstring duplication and edits * update header includes * [Jenkins] auto-formatting by clang-format version 10.0.0-4ubuntu1 * update header includes * fix headers * update headers * [Jenkins] auto-formatting by clang-format version 10.0.0-4ubuntu1 * cpplint fix --------- Co-authored-by: Stan Jenkins <[email protected]> Co-authored-by: Brian Ward <[email protected]>
stan-dev · Nov 18, 2024 · baae551 · baae551
1 parent 4a812be
commit baae551
Show file tree

Hide file tree

Showing 281 changed files with 1,240 additions and 782 deletions.
diff --git a/stan/math/fwd/fun/Phi.hpp b/stan/math/fwd/fun/Phi.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/pow.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/Phi.hpp>
 #include <cmath>
@@ -12,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> Phi(const fvar<T>& x) {
-  using std::exp;
-  using std::sqrt;
   T xv = x.val_;
   return fvar<T>(Phi(xv), x.d_ * exp(xv * xv / -2.0) * INV_SQRT_TWO_PI);
 }

diff --git a/stan/math/fwd/fun/Phi_approx.hpp b/stan/math/fwd/fun/Phi_approx.hpp
@@ -3,7 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
+#include <stan/math/fwd/fun/inv_logit.hpp>
+#include <stan/math/fwd/fun/pow.hpp>
+#include <stan/math/prim/fun/Phi_approx.hpp>
 #include <cmath>
 
 namespace stan {
@@ -21,7 +23,6 @@ namespace math {
  */
 template <typename T>
 inline fvar<T> Phi_approx(const fvar<T>& x) {
-  using std::pow;
   return inv_logit(0.07056 * pow(x, 3.0) + 1.5976 * x);
 }
 

diff --git a/stan/math/fwd/fun/abs.hpp b/stan/math/fwd/fun/abs.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/abs.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/abs.hpp>
 #include <complex>
 
 namespace stan {

diff --git a/stan/math/fwd/fun/acos.hpp b/stan/math/fwd/fun/acos.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/acos.hpp>
 #include <cmath>
 #include <complex>
@@ -13,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> acos(const fvar<T>& x) {
-  using std::acos;
-  using std::sqrt;
   return fvar<T>(acos(x.val_), x.d_ / -sqrt(1 - square(x.val_)));
 }
 

diff --git a/stan/math/fwd/fun/acosh.hpp b/stan/math/fwd/fun/acosh.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/acosh.hpp>
-#include <stan/math/prim/fun/square.hpp>
-#include <stan/math/prim/fun/sqrt.hpp>
 #include <cmath>
 #include <complex>
 
@@ -14,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> acosh(const fvar<T>& x) {
-  using std::sqrt;
   return fvar<T>(acosh(x.val_), x.d_ / sqrt(square(x.val_) - 1));
 }
 

diff --git a/stan/math/fwd/fun/asin.hpp b/stan/math/fwd/fun/asin.hpp
@@ -3,8 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/asin.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 #include <complex>
 
@@ -13,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> asin(const fvar<T>& x) {
-  using std::asin;
-  using std::sqrt;
   return fvar<T>(asin(x.val_), x.d_ / sqrt(1 - square(x.val_)));
 }
 

diff --git a/stan/math/fwd/fun/asinh.hpp b/stan/math/fwd/fun/asinh.hpp
@@ -3,8 +3,9 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/asinh.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 #include <complex>
 
@@ -13,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> asinh(const fvar<T>& x) {
-  using std::sqrt;
   return fvar<T>(asinh(x.val_), x.d_ / sqrt(square(x.val_) + 1));
 }
 

diff --git a/stan/math/fwd/fun/atan.hpp b/stan/math/fwd/fun/atan.hpp
@@ -3,8 +3,9 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/atanh.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/atan.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 #include <complex>
 
@@ -13,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> atan(const fvar<T>& x) {
-  using std::atan;
   return fvar<T>(atan(x.val_), x.d_ / (1 + square(x.val_)));
 }
 

diff --git a/stan/math/fwd/fun/atan2.hpp b/stan/math/fwd/fun/atan2.hpp
@@ -3,30 +3,28 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/fwd/fun/square.hpp>
+#include <stan/math/prim/fun/atan2.hpp>
 #include <cmath>
 
 namespace stan {
 namespace math {
 
 template <typename T>
 inline fvar<T> atan2(const fvar<T>& x1, const fvar<T>& x2) {
-  using std::atan2;
   return fvar<T>(atan2(x1.val_, x2.val_),
                  (x1.d_ * x2.val_ - x1.val_ * x2.d_)
                      / (square(x2.val_) + square(x1.val_)));
 }
 
 template <typename T>
 inline fvar<T> atan2(double x1, const fvar<T>& x2) {
-  using std::atan2;
   return fvar<T>(atan2(x1, x2.val_),
                  (-x1 * x2.d_) / (square(x1) + square(x2.val_)));
 }
 
 template <typename T>
 inline fvar<T> atan2(const fvar<T>& x1, double x2) {
-  using std::atan2;
   return fvar<T>(atan2(x1.val_, x2),
                  (x1.d_ * x2) / (square(x2) + square(x1.val_)));
 }

diff --git a/stan/math/fwd/fun/atanh.hpp b/stan/math/fwd/fun/atanh.hpp
@@ -3,8 +3,10 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/log.hpp>
+#include <stan/math/fwd/fun/square.hpp>
+#include <stan/math/fwd/fun/value_of_rec.hpp>
 #include <stan/math/prim/fun/atanh.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 #include <complex>
 

diff --git a/stan/math/fwd/fun/beta.hpp b/stan/math/fwd/fun/beta.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/beta.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
 namespace math {

diff --git a/stan/math/fwd/fun/cbrt.hpp b/stan/math/fwd/fun/cbrt.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/cbrt.hpp>
-#include <stan/math/prim/fun/square.hpp>
 
 namespace stan {
 namespace math {

diff --git a/stan/math/fwd/fun/ceil.hpp b/stan/math/fwd/fun/ceil.hpp
@@ -3,14 +3,14 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/prim/fun/ceil.hpp>
 #include <cmath>
 
 namespace stan {
 namespace math {
 
 template <typename T>
 inline fvar<T> ceil(const fvar<T>& x) {
-  using std::ceil;
   return fvar<T>(ceil(x.val_), 0);
 }
 

diff --git a/stan/math/fwd/fun/conj.hpp b/stan/math/fwd/fun/conj.hpp
@@ -5,22 +5,4 @@
 #include <stan/math/prim/fun/conj.hpp>
 #include <complex>
 
-namespace stan {
-namespace math {
-
-/**
- * Return the phase angle of the complex argument.
- *
- * @tparam T value type of autodiff variable
- * @param[in] z argument
- * @return phase angle of the argument
- */
-template <typename T>
-inline std::complex<fvar<T>> conj(const std::complex<fvar<T>>& z) {
-  return internal::complex_conj(z);
-}
-
-}  // namespace math
-}  // namespace stan
-
 #endif
diff --git a/stan/math/fwd/fun/cos.hpp b/stan/math/fwd/fun/cos.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/sin.hpp>
+#include <stan/math/fwd/fun/cosh.hpp>
 #include <stan/math/prim/fun/cos.hpp>
 #include <cmath>
 #include <complex>
@@ -12,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> cos(const fvar<T>& x) {
-  using std::cos;
-  using std::sin;
   return fvar<T>(cos(x.val_), x.d_ * -sin(x.val_));
 }
 

diff --git a/stan/math/fwd/fun/cosh.hpp b/stan/math/fwd/fun/cosh.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/sinh.hpp>
 #include <stan/math/prim/fun/cosh.hpp>
 #include <cmath>
 #include <complex>
@@ -13,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> cosh(const fvar<T>& x) {
-  using std::cosh;
-  using std::sinh;
   return fvar<T>(cosh(x.val_), x.d_ * sinh(x.val_));
 }
 

diff --git a/stan/math/fwd/fun/determinant.hpp b/stan/math/fwd/fun/determinant.hpp
@@ -1,11 +1,11 @@
 #ifndef STAN_MATH_FWD_FUN_DETERMINANT_HPP
 #define STAN_MATH_FWD_FUN_DETERMINANT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
-#include <stan/math/fwd/core.hpp>
 
 namespace stan {
 namespace math {

diff --git a/stan/math/fwd/fun/digamma.hpp b/stan/math/fwd/fun/digamma.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/trigamma.hpp>
 
 #include <stan/math/prim/fun/digamma.hpp>
-#include <stan/math/prim/fun/trigamma.hpp>
 
 namespace stan {
 namespace math {

diff --git a/stan/math/fwd/fun/erf.hpp b/stan/math/fwd/fun/erf.hpp
@@ -3,17 +3,17 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/erf.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 
 namespace stan {
 namespace math {
 
 template <typename T>
 inline fvar<T> erf(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(erf(x.val_), x.d_ * exp(-square(x.val_)) * TWO_OVER_SQRT_PI);
 }
 

diff --git a/stan/math/fwd/fun/erfc.hpp b/stan/math/fwd/fun/erfc.hpp
@@ -3,17 +3,17 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/erfc.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 
 namespace stan {
 namespace math {
 
 template <typename T>
 inline fvar<T> erfc(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(erfc(x.val_), -x.d_ * exp(-square(x.val_)) * TWO_OVER_SQRT_PI);
 }
 

diff --git a/stan/math/fwd/fun/exp.hpp b/stan/math/fwd/fun/exp.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/cos.hpp>
+#include <stan/math/fwd/fun/sin.hpp>
 #include <stan/math/prim/fun/exp.hpp>
 #include <cmath>
 #include <complex>
@@ -11,7 +13,6 @@ namespace stan {
 namespace math {
 template <typename T>
 inline fvar<T> exp(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(exp(x.val_), x.d_ * exp(x.val_));
 }
 

diff --git a/stan/math/fwd/fun/exp2.hpp b/stan/math/fwd/fun/exp2.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/exp2.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/exp2.hpp>
 #include <cmath>
 
 namespace stan {

diff --git a/stan/math/fwd/fun/expm1.hpp b/stan/math/fwd/fun/expm1.hpp
@@ -1,17 +1,17 @@
 #ifndef STAN_MATH_FWD_FUN_EXPM1_HPP
 #define STAN_MATH_FWD_FUN_EXPM1_HPP
 
-#include <stan/math/prim/fun/expm1.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/prim/fun/expm1.hpp>
 #include <cmath>
 
 namespace stan {
 namespace math {
 
 template <typename T>
 inline fvar<T> expm1(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(expm1(x.val_), x.d_ * exp(x.val_));
 }