Updating tests

stan/math/prim/arr.hpp

@@ -4,13 +4,16 @@
 #include <stan/math/prim/arr/meta/container_view.hpp>
 #include <stan/math/prim/arr/meta/get.hpp>
 #include <stan/math/prim/arr/meta/index_type.hpp>
+#include <stan/math/prim/arr/meta/is_constant_struct.hpp>
 #include <stan/math/prim/arr/meta/is_vector.hpp>
 #include <stan/math/prim/arr/meta/length.hpp>
 
 #include <stan/math/prim/arr/fun/dist.hpp>
 #include <stan/math/prim/arr/fun/dot.hpp>
 #include <stan/math/prim/arr/fun/dot_self.hpp>
 #include <stan/math/prim/arr/fun/log_sum_exp.hpp>
+#include <stan/math/prim/arr/fun/promote_scalar.hpp>
+#include <stan/math/prim/arr/fun/promote_scalar_type.hpp>
 #include <stan/math/prim/arr/fun/rep_array.hpp>
 #include <stan/math/prim/arr/fun/scaled_add.hpp>
 #include <stan/math/prim/arr/fun/sub.hpp>

stan/math/prim/arr/fun/promote_scalar.hpp

@@ -0,0 +1,44 @@
+#ifndef STAN_MATH_PRIM_ARR_FUN_PROMOTE_SCALAR_HPP
+#define STAN_MATH_PRIM_ARR_FUN_PROMOTE_SCALAR_HPP
+
+#include <stan/math/prim/scal/fun/promote_scalar.hpp>
+#include <stan/math/prim/scal/fun/promote_scalar_type.hpp>
+#include <stan/math/prim/arr/meta/index_type.hpp>
+#include <vector>
+
+namespace stan {
+  namespace math {
+
+    /**
+     * Struct to hold static function for promoting underlying scalar
+     * types.  This specialization is for standard vector inputs.
+     *
+     * @tparam T return scalar type
+     * @tparam S input type for standard vector elements in static
+     * nested function, which must have an underlying scalar type
+     * assignable to T.
+     */
+    template <typename T, typename S>
+    struct promote_scalar_struct<T, std::vector<S> > {
+      /**
+       * Return the standard vector consisting of the recursive
+       * promotion of the elements of the input standard vector to the
+       * scalar type specified by the return template parameter.
+       *
+       * @param x input standard vector.
+       * @return standard vector with values promoted from input vector.
+       */
+      static std::vector<typename promote_scalar_type<T, S>::type>
+      apply(const std::vector<S>& x) {
+        typedef std::vector<typename promote_scalar_type<T, S>::type> return_t;
+        typedef typename index_type<return_t>::type idx_t;
+        return_t y(x.size());
+        for (idx_t i = 0; i < x.size(); ++i)
+          y[i] = promote_scalar_struct<T, S>::apply(x[i]);
+        return y;
+      }
+    };
+
+  }
+}
+#endif

stan/math/prim/arr/fun/promote_scalar_type.hpp

@@ -0,0 +1,28 @@
+#ifndef STAN_MATH_PRIM_ARR_FUN_PROMOTE_SCALAR_TYPE_HPP
+#define STAN_MATH_PRIM_ARR_FUN_PROMOTE_SCALAR_TYPE_HPP
+
+#include <stan/math/prim/scal/fun/promote_scalar_type.hpp>
+#include <vector>
+
+namespace stan {
+  namespace math {
+
+    /**
+     * Template metaprogram to calculate a type for a container whose
+     * underlying scalar is converted from the second template
+     * parameter type to the first.
+     *
+     * @tparam T result scalar type.
+     * @tparam S input type
+     */
+    template <typename T, typename S>
+    struct promote_scalar_type<T, std::vector<S> > {
+      /**
+       * The promoted type.
+       */
+      typedef std::vector<typename promote_scalar_type<T, S>::type> type;
+    };
+
+  }
+}
+#endif

stan/math/prim/arr/meta/is_constant_struct.hpp

@@ -0,0 +1,17 @@
+#ifndef STAN_MATH_PRIM_ARR_META_IS_CONSTANT_STRUCT_HPP
+#define STAN_MATH_PRIM_ARR_META_IS_CONSTANT_STRUCT_HPP
+
+#include <stan/math/prim/scal/meta/is_constant.hpp>
+#include <stan/math/prim/scal/meta/is_constant_struct.hpp>
+#include <vector>
+
+namespace stan {
+
+  template <typename T>
+  struct is_constant_struct<std::vector<T> > {
+    enum { value = is_constant_struct<T>::value };
+  };
+
+}
+#endif
+

stan/math/prim/mat.hpp

@@ -9,6 +9,7 @@
 #include <stan/math/prim/mat/meta/container_view.hpp>
 #include <stan/math/prim/mat/meta/get.hpp>
 #include <stan/math/prim/mat/meta/index_type.hpp>
+#include <stan/math/prim/mat/meta/is_constant_struct.hpp>
 #include <stan/math/prim/mat/meta/is_vector.hpp>
 #include <stan/math/prim/mat/meta/is_vector_like.hpp>
 #include <stan/math/prim/mat/meta/length.hpp>

stan/math/prim/mat/meta/is_constant_struct.hpp

@@ -0,0 +1,23 @@
+#ifndef STAN_MATH_PRIM_MAT_META_IS_CONSTANT_STRUCT_HPP
+#define STAN_MATH_PRIM_MAT_META_IS_CONSTANT_STRUCT_HPP
+
+#include <stan/math/prim/arr/meta/is_constant_struct.hpp>
+#include <stan/math/prim/mat/fun/Eigen.hpp>
+#include <stan/math/prim/scal/meta/is_constant.hpp>
+
+
+namespace stan {
+
+  template <typename T, int R, int C>
+  struct is_constant_struct<Eigen::Matrix<T, R, C> > {
+    enum { value = is_constant_struct<T>::value };
+  };
+
+  template <typename T>
+  struct is_constant_struct<Eigen::Block<T> > {
+    enum { value = is_constant_struct<T>::value };
+  };
+
+}
+#endif
+

stan/math/prim/scal/fun/promote_scalar.hpp

@@ -3,10 +3,8 @@
 
 #include <stan/math/prim/scal/fun/promote_scalar_type.hpp>
 #include <stan/math/prim/scal/meta/index_type.hpp>
-#include <vector>
 
 namespace stan {
-
   namespace math {
 
     /**
@@ -55,36 +53,6 @@ namespace stan {
       }
     };
 
-    /**
-     * Struct to hold static function for promoting underlying scalar
-     * types.  This specialization is for standard vector inputs.
-     *
-     * @tparam T return scalar type
-     * @tparam S input type for standard vector elements in static
-     * nested function, which must have an underlying scalar type
-     * assignable to T.
-     */
-    template <typename T, typename S>
-    struct promote_scalar_struct<T, std::vector<S> > {
-      /**
-       * Return the standard vector consisting of the recursive
-       * promotion of the elements of the input standard vector to the
-       * scalar type specified by the return template parameter.
-       *
-       * @param x input standard vector.
-       * @return standard vector with values promoted from input vector.
-       */
-      static std::vector<typename promote_scalar_type<T, S>::type>
-      apply(const std::vector<S>& x) {
-        typedef std::vector<typename promote_scalar_type<T, S>::type> return_t;
-        typedef typename index_type<return_t>::type idx_t;
-        return_t y(x.size());
-        for (idx_t i = 0; i < x.size(); ++i)
-          y[i] = promote_scalar_struct<T, S>::apply(x[i]);
-        return y;
-      }
-    };
-
     /**
      * This is the top-level function to call to promote the scalar
      * types of an input of type S to type T.
@@ -100,8 +68,6 @@ namespace stan {
       return promote_scalar_struct<T, S>::apply(x);
     }
 
-
   }
 }
-
 #endif

stan/math/prim/scal/fun/promote_scalar_type.hpp

@@ -1,13 +1,9 @@
 #ifndef STAN_MATH_PRIM_SCAL_FUN_PROMOTE_SCALAR_TYPE_HPP
 #define STAN_MATH_PRIM_SCAL_FUN_PROMOTE_SCALAR_TYPE_HPP
 
-#include <vector>
-
 namespace stan {
-
   namespace math {
 
-
     /**
      * Template metaprogram to calculate a type for converting a
      * convertible type.  This is the base case.
@@ -23,26 +19,6 @@ namespace stan {
       typedef T type;
     };
 
-
-    /**
-     * Template metaprogram to calculate a type for a container whose
-     * underlying scalar is converted from the second template
-     * parameter type to the first.
-     *
-     * @tparam T result scalar type.
-     * @tparam S input type
-     */
-    template <typename T, typename S>
-    struct promote_scalar_type<T, std::vector<S> > {
-      /**
-       * The promoted type.
-       */
-      typedef std::vector<typename promote_scalar_type<T, S>::type> type;
-    };
-
-
   }
-
 }
-
 #endif

stan/math/prim/scal/meta/is_constant_struct.hpp

@@ -2,9 +2,6 @@
 #define STAN_MATH_PRIM_SCAL_META_IS_CONSTANT_STRUCT_HPP
 
 #include <stan/math/prim/scal/meta/is_constant.hpp>
-#include <stan/math/prim/mat/fun/Eigen.hpp>
-#include <vector>
-
 
 namespace stan {
 
@@ -17,21 +14,5 @@ namespace stan {
     enum { value = is_constant<T>::value };
   };
 
-  template <typename T>
-  struct is_constant_struct<std::vector<T> > {
-    enum { value = is_constant_struct<T>::value };
-  };
-
-  template <typename T, int R, int C>
-  struct is_constant_struct<Eigen::Matrix<T, R, C> > {
-    enum { value = is_constant_struct<T>::value };
-  };
-
-  template <typename T>
-  struct is_constant_struct<Eigen::Block<T> > {
-    enum { value = is_constant_struct<T>::value };
-  };
-
 }
 #endif
-

stan/math/prim/scal/meta/scalar_type_pre.hpp

@@ -2,9 +2,6 @@
 #define STAN_MATH_PRIM_SCAL_META_SCALAR_TYPE_PRE_HPP
 
 #include <stan/math/prim/scal/meta/is_vector.hpp>
-#include <stan/math/prim/mat/meta/is_vector.hpp>
-#include <stan/math/prim/arr/meta/is_vector.hpp>
-#include <stan/math/prim/mat/meta/value_type.hpp>
 #include <stan/math/prim/scal/meta/value_type.hpp>
 
 namespace stan {

stan/math/prim/scal/meta/size_of.hpp

@@ -2,13 +2,9 @@
 #define STAN_MATH_PRIM_SCAL_META_SIZE_OF_HPP
 
 #include <stan/math/prim/scal/meta/is_vector.hpp>
-#include <stan/math/prim/mat/meta/is_vector.hpp>
-#include <stan/math/prim/arr/meta/is_vector.hpp>
 
 namespace stan {
 
-
-
   template<typename T, bool is_vec>
   struct size_of_helper {
     static size_t size_of(const T& /*x*/) {

test/unit/math/prim/arr/fun/promote_scalar_type_test.cpp

@@ -0,0 +1,12 @@
+#include <stan/math/prim/arr.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/math/prim/scal/fun/promote_type_test_util.hpp>
+
+TEST(MathFunctionsPromoteScalarType,StdVector) {
+  using std::vector;
+  expect_promote_type<vector<vector<double> >, 
+                    double, vector<vector<int> > >();
+  expect_promote_type<vector<vector<double> >, 
+                    double, vector<vector<double> > >();
+}
+

test/unit/math/prim/scal/fun/promote_scalar_type_test.cpp

@@ -11,12 +11,3 @@ TEST(MathFunctionsPromoteScalarType,primitive) {
   expect_promote_type<vector<double>,
                       double, vector<int> >();
 }
-
-TEST(MathFunctionsPromoteScalarType,StdVector) {
-  using std::vector;
-  expect_promote_type<vector<vector<double> >, 
-                    double, vector<vector<int> > >();
-  expect_promote_type<vector<vector<double> >, 
-                    double, vector<vector<double> > >();
-}
-