[WIP] Use auto and more general template types

stan/math/fwd/mat/fun/columns_dot_product.hpp

@@ -5,10 +5,10 @@
 #include <stan/math/prim/mat/err/check_matching_dims.hpp>
 #include <stan/math/fwd/mat/fun/typedefs.hpp>
 #include <stan/math/fwd/core.hpp>
-
+#include <stan/math/prim/mat/fun/columns_dot_product.hpp>
 namespace stan {
 namespace math {
-
+#ifdef NOOO
 template <typename T, int R1, int C1, int R2, int C2>
 inline Eigen::Matrix<fvar<T>, 1, C1> columns_dot_product(
     const Eigen::Matrix<fvar<T>, R1, C1>& v1,
@@ -50,7 +50,7 @@ inline Eigen::Matrix<fvar<T>, 1, C1> columns_dot_product(
   }
   return ret;
 }
-
+#endif
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/fwd/mat/fun/columns_dot_self.hpp

@@ -4,10 +4,10 @@
 #include <stan/math/prim/mat/fun/Eigen.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/mat/fun/dot_self.hpp>
-
+#include <stan/math/prim/mat.hpp>
 namespace stan {
 namespace math {
-
+#ifdef NOOOO
 template <typename T, int R, int C>
 inline Eigen::Matrix<fvar<T>, 1, C> columns_dot_self(
     const Eigen::Matrix<fvar<T>, R, C>& x) {
@@ -18,6 +18,7 @@ inline Eigen::Matrix<fvar<T>, 1, C> columns_dot_self(
   }
   return ret;
 }
+#endif
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/fwd/mat/fun/crossprod.hpp

@@ -5,17 +5,4 @@
 #include <stan/math/fwd/mat/fun/multiply.hpp>
 #include <stan/math/prim/mat/fun/transpose.hpp>
 
-namespace stan {
-namespace math {
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<fvar<T>, C, C> crossprod(
-    const Eigen::Matrix<fvar<T>, R, C>& m) {
-  if (m.rows() == 0)
-    return Eigen::Matrix<fvar<T>, C, C>(0, 0);
-  return multiply(transpose(m), m);
-}
-
-}  // namespace math
-}  // namespace stan
 #endif

stan/math/fwd/mat/fun/divide.hpp

@@ -3,60 +3,5 @@
 
 #include <stan/math/prim/mat/fun/Eigen.hpp>
 #include <stan/math/fwd/core.hpp>
-
-namespace stan {
-namespace math {
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<fvar<T>, R, C> divide(
-    const Eigen::Matrix<fvar<T>, R, C>& v, const fvar<T>& c) {
-  Eigen::Matrix<fvar<T>, R, C> res(v.rows(), v.cols());
-  for (int i = 0; i < v.rows(); i++) {
-    for (int j = 0; j < v.cols(); j++)
-      res(i, j) = v(i, j) / c;
-  }
-  return res;
-}
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<fvar<T>, R, C> divide(
-    const Eigen::Matrix<fvar<T>, R, C>& v, double c) {
-  Eigen::Matrix<fvar<T>, R, C> res(v.rows(), v.cols());
-  for (int i = 0; i < v.rows(); i++) {
-    for (int j = 0; j < v.cols(); j++)
-      res(i, j) = v(i, j) / c;
-  }
-  return res;
-}
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<fvar<T>, R, C> divide(const Eigen::Matrix<double, R, C>& v,
-                                           const fvar<T>& c) {
-  Eigen::Matrix<fvar<T>, R, C> res(v.rows(), v.cols());
-  for (int i = 0; i < v.rows(); i++) {
-    for (int j = 0; j < v.cols(); j++)
-      res(i, j) = v(i, j) / c;
-  }
-  return res;
-}
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<fvar<T>, R, C> operator/(
-    const Eigen::Matrix<fvar<T>, R, C>& v, const fvar<T>& c) {
-  return divide(v, c);
-}
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<fvar<T>, R, C> operator/(
-    const Eigen::Matrix<fvar<T>, R, C>& v, double c) {
-  return divide(v, c);
-}
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<fvar<T>, R, C> operator/(
-    const Eigen::Matrix<double, R, C>& v, const fvar<T>& c) {
-  return divide(v, c);
-}
-}  // namespace math
-}  // namespace stan
+#include <stan/math/prim/mat.hpp>
 #endif

stan/math/fwd/mat/fun/dot_product.hpp

@@ -5,146 +5,7 @@
 #include <stan/math/prim/mat/err/check_vector.hpp>
 #include <stan/math/prim/arr/err/check_matching_sizes.hpp>
 #include <stan/math/fwd/mat/fun/typedefs.hpp>
+#include <stan/math/prim/mat.hpp>
 #include <vector>
 
-namespace stan {
-namespace math {
-
-template <typename T, int R1, int C1, int R2, int C2>
-inline fvar<T> dot_product(const Eigen::Matrix<fvar<T>, R1, C1>& v1,
-                           const Eigen::Matrix<fvar<T>, R2, C2>& v2) {
-  check_vector("dot_product", "v1", v1);
-  check_vector("dot_product", "v2", v2);
-  check_matching_sizes("dot_product", "v1", v1, "v2", v2);
-
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < v1.size(); i++)
-    ret += v1(i) * v2(i);
-  return ret;
-}
-
-template <typename T, int R1, int C1, int R2, int C2>
-inline fvar<T> dot_product(const Eigen::Matrix<fvar<T>, R1, C1>& v1,
-                           const Eigen::Matrix<double, R2, C2>& v2) {
-  check_vector("dot_product", "v1", v1);
-  check_vector("dot_product", "v2", v2);
-  check_matching_sizes("dot_product", "v1", v1, "v2", v2);
-
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < v1.size(); i++)
-    ret += v1(i) * v2(i);
-  return ret;
-}
-
-template <typename T, int R1, int C1, int R2, int C2>
-inline fvar<T> dot_product(const Eigen::Matrix<double, R1, C1>& v1,
-                           const Eigen::Matrix<fvar<T>, R2, C2>& v2) {
-  check_vector("dot_product", "v1", v1);
-  check_vector("dot_product", "v2", v2);
-  check_matching_sizes("dot_product", "v1", v1, "v2", v2);
-
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < v1.size(); i++)
-    ret += v1(i) * v2(i);
-  return ret;
-}
-
-template <typename T, int R1, int C1, int R2, int C2>
-inline fvar<T> dot_product(const Eigen::Matrix<fvar<T>, R1, C1>& v1,
-                           const Eigen::Matrix<fvar<T>, R2, C2>& v2,
-                           size_type& length) {
-  check_vector("dot_product", "v1", v1);
-  check_vector("dot_product", "v2", v2);
-
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < length; i++)
-    ret += v1(i) * v2(i);
-  return ret;
-}
-
-template <typename T, int R1, int C1, int R2, int C2>
-inline fvar<T> dot_product(const Eigen::Matrix<fvar<T>, R1, C1>& v1,
-                           const Eigen::Matrix<double, R2, C2>& v2,
-                           size_type& length) {
-  check_vector("dot_product", "v1", v1);
-  check_vector("dot_product", "v2", v2);
-
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < length; i++)
-    ret += v1(i) * v2(i);
-  return ret;
-}
-
-template <typename T, int R1, int C1, int R2, int C2>
-inline fvar<T> dot_product(const Eigen::Matrix<double, R1, C1>& v1,
-                           const Eigen::Matrix<fvar<T>, R2, C2>& v2,
-                           size_type& length) {
-  check_vector("dot_product", "v1", v1);
-  check_vector("dot_product", "v2", v2);
-
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < length; i++)
-    ret += v1(i) * v2(i);
-  return ret;
-}
-
-template <typename T>
-inline fvar<T> dot_product(const std::vector<fvar<T> >& v1,
-                           const std::vector<fvar<T> >& v2) {
-  check_matching_sizes("dot_product", "v1", v1, "v2", v2);
-  fvar<T> ret(0, 0);
-  for (size_t i = 0; i < v1.size(); i++)
-    ret += v1.at(i) * v2.at(i);
-  return ret;
-}
-
-template <typename T>
-inline fvar<T> dot_product(const std::vector<double>& v1,
-                           const std::vector<fvar<T> >& v2) {
-  check_matching_sizes("dot_product", "v1", v1, "v2", v2);
-  fvar<T> ret(0, 0);
-  for (size_t i = 0; i < v1.size(); i++)
-    ret += v1.at(i) * v2.at(i);
-  return ret;
-}
-
-template <typename T>
-inline fvar<T> dot_product(const std::vector<fvar<T> >& v1,
-                           const std::vector<double>& v2) {
-  check_matching_sizes("dot_product", "v1", v1, "v2", v2);
-  fvar<T> ret(0, 0);
-  for (size_t i = 0; i < v1.size(); i++)
-    ret += v1.at(i) * v2.at(i);
-  return ret;
-}
-
-template <typename T>
-inline fvar<T> dot_product(const std::vector<fvar<T> >& v1,
-                           const std::vector<fvar<T> >& v2, size_type& length) {
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < length; i++)
-    ret += v1.at(i) * v2.at(i);
-  return ret;
-}
-
-template <typename T>
-inline fvar<T> dot_product(const std::vector<double>& v1,
-                           const std::vector<fvar<T> >& v2, size_type& length) {
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < length; i++)
-    ret += v1.at(i) * v2.at(i);
-  return ret;
-}
-
-template <typename T>
-inline fvar<T> dot_product(const std::vector<fvar<T> >& v1,
-                           const std::vector<double>& v2, size_type& length) {
-  fvar<T> ret(0, 0);
-  for (size_type i = 0; i < length; i++)
-    ret += v1.at(i) * v2.at(i);
-  return ret;
-}
-
-}  // namespace math
-}  // namespace stan
 #endif

stan/math/fwd/mat/fun/dot_self.hpp

@@ -5,16 +5,5 @@
 #include <stan/math/prim/mat/err/check_vector.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/mat/fun/dot_product.hpp>
-
-namespace stan {
-namespace math {
-
-template <typename T, int R, int C>
-inline fvar<T> dot_self(const Eigen::Matrix<fvar<T>, R, C>& v) {
-  check_vector("dot_self", "v", v);
-  return dot_product(v, v);
-}
-
-}  // namespace math
-}  // namespace stan
+#include <stan/math/prim/mat.hpp>
 #endif

stan/math/fwd/mat/fun/inverse.hpp

@@ -8,32 +8,4 @@
 #include <stan/math/fwd/mat/fun/multiply.hpp>
 #include <stan/math/prim/mat/fun/inverse.hpp>
 #include <stan/math/prim/mat/err/check_square.hpp>
-
-namespace stan {
-namespace math {
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<fvar<T>, R, C> inverse(
-    const Eigen::Matrix<fvar<T>, R, C>& m) {
-  check_square("inverse", "m", m);
-  Eigen::Matrix<T, R, C> m_deriv(m.rows(), m.cols());
-  Eigen::Matrix<T, R, C> m_inv(m.rows(), m.cols());
-
-  for (size_type i = 0; i < m.rows(); i++) {
-    for (size_type j = 0; j < m.cols(); j++) {
-      m_inv(i, j) = m(i, j).val_;
-      m_deriv(i, j) = m(i, j).d_;
-    }
-  }
-
-  m_inv = inverse(m_inv);
-
-  m_deriv = multiply(multiply(m_inv, m_deriv), m_inv);
-  m_deriv = -m_deriv;
-
-  return to_fvar(m_inv, m_deriv);
-}
-
-}  // namespace math
-}  // namespace stan
 #endif

stan/math/fwd/mat/fun/log_determinant.hpp

@@ -7,17 +7,17 @@
 #include <stan/math/fwd/scal/fun/fabs.hpp>
 #include <stan/math/fwd/scal/fun/log.hpp>
 #include <stan/math/prim/mat/err/check_square.hpp>
-
+#include <stan/math/prim/mat.hpp>
 namespace stan {
 namespace math {
-
+#ifdef NOOOO
 template <typename T, int R, int C>
 inline fvar<T> log_determinant(const Eigen::Matrix<fvar<T>, R, C>& m) {
   check_square("log_determinant", "m", m);
 
   return log(fabs(determinant(m)));
 }
-
+#endif
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/fwd/mat/fun/log_softmax.hpp

@@ -9,7 +9,7 @@
 
 namespace stan {
 namespace math {
-
+#ifdef NOOOOO
 template <typename T>
 inline Eigen::Matrix<fvar<T>, Eigen::Dynamic, 1> log_softmax(
     const Eigen::Matrix<fvar<T>, Eigen::Dynamic, 1>& alpha) {
@@ -43,7 +43,7 @@ inline Eigen::Matrix<fvar<T>, Eigen::Dynamic, 1> log_softmax(
 
   return log_softmax_alpha;
 }
-
+#endif
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/fwd/mat/fun/rows_dot_product.hpp

@@ -5,10 +5,10 @@
 #include <stan/math/prim/mat/err/check_matching_dims.hpp>
 #include <stan/math/fwd/mat/fun/dot_product.hpp>
 #include <stan/math/fwd/core.hpp>
-
+#include <stan/math/prim/mat.hpp>
 namespace stan {
 namespace math {
-
+#ifdef NOOOO
 template <typename T, int R1, int C1, int R2, int C2>
 inline Eigen::Matrix<fvar<T>, R1, 1> rows_dot_product(
     const Eigen::Matrix<fvar<T>, R1, C1>& v1,
@@ -50,7 +50,7 @@ inline Eigen::Matrix<fvar<T>, R1, 1> rows_dot_product(
   }
   return ret;
 }
-
+#endif
 }  // namespace math
 }  // namespace stan
 #endif