Merge branch 'develop' into generalize_view_and_size

# Conflicts:
#	stan/math/prim/fun/cols.hpp
#	stan/math/prim/fun/transpose.hpp

Author: t4c1

Jenkinsfile

@@ -8,10 +8,12 @@ def runTests(String testPath) {
     finally { junit 'test/**/*.xml' }
 }
 
-def runTestsWin(String testPath) {
+def runTestsWin(String testPath, boolean buildLibs = true) {
     withEnv(['PATH+TBB=./lib/tbb']) {
        bat "echo $PATH"
-       bat "mingw32-make.exe -f make/standalone math-libs"
+       if (buildLibs){
+           bat "mingw32-make.exe -f make/standalone math-libs"
+       }
        bat "runTests.py -j${env.PARALLEL} ${testPath} --make-only"
        try { bat "runTests.py -j${env.PARALLEL} ${testPath}" }
        finally { junit 'test/**/*.xml' }
@@ -246,8 +248,9 @@ pipeline {
                     steps {
                         deleteDirWin()
                         unstash 'MathSetup'
+                        bat "mingw32-make.exe -f make/standalone math-libs"
                         bat "mingw32-make -j${env.PARALLEL} test-headers"
-                        runTestsWin("test/unit")
+                        runTestsWin("test/unit", false)
                     }
                 }
                 stage('Windows Threading') {

RELEASE-NOTES.txt

@@ -434,7 +434,7 @@ Bug Fixes
 --------------------------------------------------
 * beta_rng no longer returns NaN
 * fixed memory issue with cholesky_decompose in reverse-mode (#415)
-* no more mulitple definitions when including Stan headers in
+* no more multiple definitions when including Stan headers in
   multiple source files (#394)
 * fixed broken _MSC_VER conditionals and remove math.h includes (#370)
 

doxygen/contributor_help_pages/distribution_tests.md

@@ -101,7 +101,7 @@ Before diving into details, the overall structure of the test file is:
 ```
   template <class T_n, class T_prob, typename T2,
             typename T3, typename T4, typename T5>
-  typename stan::return_type<T_n, T_prob>::type
+  stan::return_type_t<T_n, T_prob>
   log_prob(const T_n& n, const T_prob& theta, const T2&,
            const T3&, const T4&, const T5&)
 ```
@@ -110,15 +110,15 @@ Before diving into details, the overall structure of the test file is:
   template <bool propto,
             class T_n, class T_prob, typename T2,
             typename T3, typename T4, typename T5>
-  typename stan::return_type<T_n, T_prob>::type
+  stan::return_type_t<T_n, T_prob>
   log_prob(const T_n& n, const T_prob& theta, const T2&,
            const T3&, const T4&, const T5&)
 ```
     -
 ```
   template <class T_n, class T_prob, typename T2,
             typename T3, typename T4, typename T5>
-  typename stan::return_type<T_n, T_prob>::type
+  stan::return_type_t<T_n, T_prob>
   log_prob_function(const T_n& n, const T_prob& theta, const T2&,
                     const T3&, const T4&, const T5&)
 ```

make/compiler_flags

@@ -1,3 +1,11 @@
+# Find files subroutine for different operating system
+# This is recursive version of the makefiles wildcard function
+findfiles = $(foreach d,$(wildcard $(addsuffix *,$(1))),$(call findfiles,$(d)/,$(2)) $(wildcard $(d)/$(2)))
+
+ifneq ($(OS),Windows_NT)
+GENERATE_DISTRIBUTION_TESTS=true
+endif
+
 # Detect operating system, set default compiler, and detect compiler type
 # The defaults are configured for the compilers we test:
 # https://github.com/stan-dev/stan/wiki/Supported-C---Compilers-and-Language-Features

make/libraries

@@ -74,7 +74,7 @@ $(SUNDIALS)/lib/libsundials_nvecserial.a: $(SUNDIALS_NVECSERIAL)
 
 LIBSUNDIALS := $(SUNDIALS)/lib/libsundials_nvecserial.a $(SUNDIALS)/lib/libsundials_cvodes.a $(SUNDIALS)/lib/libsundials_idas.a $(SUNDIALS)/lib/libsundials_kinsol.a
 
-STAN_SUNDIALS_HEADERS := $(shell find $(MATH)stan -name *cvodes*.hpp) $(shell find $(MATH)stan -name *idas*.hpp) $(shell find $(MATH)stan -name *kinsol*.hpp)
+STAN_SUNDIALS_HEADERS :=  $(call findfiles,$(MATH)stan,*cvodes*.hpp) $(call findfiles,$(MATH)stan,*idas*.hpp) $(call findfiles,$(MATH)stan,*kinsol*.hpp)
 $(STAN_SUNDIALS_HEADERS) : $(LIBSUNDIALS)
 
 clean-sundials:
@@ -196,7 +196,7 @@ $(BOOST)/stage/lib/libboost_mpi.dylib: $(BOOST)/stage/lib/mpi.so $(BOOST)/stage/
 	install_name_tool -change libboost_serialization.dylib @rpath/libboost_serialization.dylib "$(BOOST)/stage/lib/libboost_mpi.dylib"
 	install_name_tool -id @rpath/libboost_mpi.dylib "$(BOOST)/stage/lib/libboost_mpi.dylib"
 
-MPI_TEMPLATE_INSTANTIATION_CPP := $(shell find $(MATH)stan -type f -name 'mpi_*_inst.cpp') $(shell find $(MATH)stan -type f -name 'mpi_*_def.cpp')
+MPI_TEMPLATE_INSTANTIATION_CPP := $(call findfiles,$(MATH)stan,mpi_*_inst.cpp) $(call findfiles,$(MATH)stan,mpi_*_def.cpp)
 MPI_TEMPLATE_INSTANTIATION := $(MPI_TEMPLATE_INSTANTIATION_CPP:%.cpp=%.o)
 
 $(MPI_TEMPLATE_INSTANTIATION) : CXXFLAGS += -fPIC

make/tests

@@ -40,7 +40,7 @@ test/unit/multiple_translation_units_test$(EXE): test/unit/libmultiple.so
 # CVODES tests
 ##
 
-CVODES_TESTS := $(subst .cpp,$(EXE),$(shell find test -name *cvodes*_test.cpp) $(shell find test -name *_bdf_*_test.cpp) $(shell find test -name *_adams_*_test.cpp))
+CVODES_TESTS := $(subst .cpp,$(EXE),$(call findfiles,test,*cvodes*_test.cpp) $(call findfiles,test,*_bdf_*_test.cpp) $(call findfiles,test,*_adams_*_test.cpp))
 $(CVODES_TESTS) : $(LIBSUNDIALS)
 
 
@@ -49,7 +49,7 @@ $(CVODES_TESTS) : $(LIBSUNDIALS)
 # IDAS tests
 ##
 
-IDAS_TESTS := $(subst .cpp,$(EXE),$(shell find test -name *idas*_test.cpp) $(shell find test -name *_dae*_test.cpp))
+IDAS_TESTS := $(subst .cpp,$(EXE),$(call findfiles,test,*idas*_test.cpp) $(call findfiles,test,*_dae*_test.cpp))
 $(IDAS_TESTS) : $(LIBSUNDIALS)
 
 
@@ -58,7 +58,7 @@ $(IDAS_TESTS) : $(LIBSUNDIALS)
 # KINSOL tests
 ##
 
-ALGEBRA_SOLVER_TESTS := $(subst .cpp,$(EXE),$(shell find test -name *algebra_solver*_test.cpp))
+ALGEBRA_SOLVER_TESTS := $(subst .cpp,$(EXE),$(call findfiles,test,*algebra_solver*_test.cpp))
 $(ALGEBRA_SOLVER_TESTS) : $(LIBSUNDIALS)
 
 
@@ -67,7 +67,7 @@ $(ALGEBRA_SOLVER_TESTS) : $(LIBSUNDIALS)
 # Target to verify header files within Stan has
 # enough include calls
 ##
-HEADER_TESTS := $(addsuffix -test,$(shell find stan -name '*.hpp' -type f))
+HEADER_TESTS := $(addsuffix -test,$(call findfiles,stan,*.hpp))
 
 ifeq ($(OS),Windows_NT)
   DEV_NULL = nul
@@ -86,6 +86,7 @@ test/dummy.cpp:
 .PHONY: test-headers
 test-headers: $(HEADER_TESTS)
 
+ifdef GENERATE_DISTRIBUTION_TESTS
 ############################################################
 ##
 # Test generator for distribution tests
@@ -108,3 +109,4 @@ LIST_OF_GENERATED_TESTS := $(shell find test/prob -type f -name '*_test.hpp' | s
 
 .PHONY: generate-tests
 generate-tests: $(LIST_OF_GENERATED_TESTS)
+endif

makefile

@@ -98,25 +98,29 @@ doxygen:
 .PHONY: clean clean-doxygen clean-deps clean-all
 clean:
 	@echo '  removing test executables'
-	$(shell find test -type f -name "*_test$(EXE)" -exec rm {} +)
-	$(shell find test -type f -name "*_test.d" -exec rm {} +)
-	$(shell find test -type f -name "*_test.d.*" -exec rm {} +)
-	$(shell find test -type f -name "*_test.xml" -exec rm {} +)
-	$(shell find test -type f -name "*.o" -exec rm {} +)
-	$(RM) $(wildcard $(GTEST)/src/gtest-all.o)
+	@$(RM) $(call findfiles,test,*_test$(EXE))
+	@$(RM) $(call findfiles,test,*_test.d)
+	@$(RM) $(call findfiles,test,*_test.d.*)
+	@$(RM) $(call findfiles,test,*_test.xml)
+	@$(RM) $(call findfiles,test,*.o)
+	@$(RM) $(wildcard $(GTEST)/src/gtest-all.o)
 	@echo '  removing generated test files'
-	$(RM) $(wildcard test/prob/generate_tests$(EXE))
-	$(shell find test/prob -name '*_generated_*_test.cpp' -type f -exec rm {} +)
+	@$(RM) $(wildcard test/prob/generate_tests$(EXE))
+	@$(RM) $(call findfiles,test/prob,*_generated_*_test.cpp)
 
 clean-doxygen:
 	@echo '  removing doxygen'
 	$(RM) -r doc/api
 
 clean-deps:
 	@echo '  removing dependency files'
-	$(shell find stan test lib -type f -name '*.d' -exec rm {} +)
-	$(shell find stan test lib -type f -name '*.d.*' -exec rm {} +)
-	$(shell find stan  -type f -name '*.dSYM' -exec rm {} +)
+	@$(RM) $(call findfiles,stan,*.d)
+	@$(RM) $(call findfiles,test,*.d)
+	@$(RM) $(call findfiles,lib,*.d)
+	@$(RM) $(call findfiles,stan,*.d.*)
+	@$(RM) $(call findfiles,test,*.d.*)
+	@$(RM) $(call findfiles,lib,*.d.*)
+	@$(RM) $(call findfiles,stan,*.dSYM)
 
 clean-all: clean clean-doxygen clean-deps clean-libraries
 

runChecks.py

@@ -57,7 +57,7 @@ def check_non_unique_test_names():
             for y in duplicates[x]:
                 duplicates_error_msg += "\t" + y + "\n"
         errors.append(
-            "Tests or test fixtures with non-unqiue names found in test/unit:\n\n" +
+            "Tests or test fixtures with non-unique names found in test/unit:\n\n" +
             duplicates_error_msg
         )
     return errors

stan/math.hpp

@@ -109,17 +109,17 @@
  *
  * In general, these methods allow Stan to have more generic types so that the
  * library can forward along Eigen expression and have better move semantics.
- * For instance, the below code will accept any arbitrary eigen expression
+ * For instance, the code below will accept any arbitrary Eigen expression
  * that, if it's an rvalue, can be forwarded to another function.
  *
  *~~~~~{.cpp}
- *  template <typename Mat1, typename Mat2,
+ * template <typename Mat1, typename Mat2,
  * require_all_eigen_vt<is_arithmetic, Mat1, Mat2>...>
  * inline auto a_func(Mat1&& m1, Mat2&& m2) {
  *   check_nan(m1);
  *   check_nan(m2);
  *   // If m1 and/or m2 is an rvalue it will be moved over to this function
- *  // instead of copied to an lvalue
+ *   // instead of copied to an lvalue
  *   auto B = another_func(std::forward<Mat1>(m1), std::forward<Mat2>(m2)); //
  *(3) return B;
  *~~~~~
@@ -141,7 +141,7 @@
  * certain conditions while @c _st methods check that the objects @c scalar_type
  * fulfills certain conditions. @c value_type and @c scalar_type differ in that
  * @c value_type is the first level of a container while @c scalar_type
- * recursivly goes through containers of containers till it comes to a simple
+ * recursively goes through containers of containers till it comes to a simple
  * type.
  */
 

stan/math/fwd.hpp

@@ -5,7 +5,6 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
-#include <stan/math/fwd/vectorize.hpp>
 #include <stan/math/prim.hpp>
 
 #include <stan/math/fwd/fun.hpp>

stan/math/fwd/core.hpp

@@ -18,5 +18,6 @@
 #include <stan/math/fwd/core/operator_unary_not.hpp>
 #include <stan/math/fwd/core/operator_unary_plus.hpp>
 #include <stan/math/fwd/core/std_numeric_limits.hpp>
+#include <stan/math/fwd/core/std_iterator_traits.hpp>
 
 #endif

stan/math/fwd/core/std_iterator_traits.hpp

@@ -0,0 +1,42 @@
+#ifndef STAN_MATH_FWD_CORE_STD_ITERATOR_TRAITS_HPP
+#define STAN_MATH_FWD_CORE_STD_ITERATOR_TRAITS_HPP
+
+#include <stan/math/fwd/core/fvar.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <iterator>
+
+namespace std {
+/**
+ * Specialization of iterator traits for Stan math.  These all take
+ * the form of typedefs.
+ */
+template <typename T>
+struct iterator_traits<stan::math::fvar<T>> {
+  /**
+   * Iterator category for traits.
+   */
+  typedef random_access_iterator_tag iterator_category;
+
+  /**
+   * Type for difference between pointers.
+   */
+  typedef ptrdiff_t difference_type;
+
+  /**
+   * Type for value of pointer to values.
+   */
+  typedef stan::math::fvar<T> value_type;
+
+  /**
+   * Type of pointer to variables.
+   */
+  typedef stan::math::fvar<T>* pointer;
+
+  /**
+   * Type of reference to variables.
+   */
+  typedef stan::math::fvar<T>& reference;
+};
+}  // namespace std
+
+#endif

stan/math/fwd/fun.hpp

@@ -23,7 +23,6 @@
 #include <stan/math/fwd/fun/determinant.hpp>
 #include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/fwd/fun/divide.hpp>
-#include <stan/math/fwd/fun/dot_product.hpp>
 #include <stan/math/fwd/fun/dot_self.hpp>
 #include <stan/math/fwd/fun/Eigen_NumTraits.hpp>
 #include <stan/math/fwd/fun/erf.hpp>
@@ -92,6 +91,7 @@
 #include <stan/math/fwd/fun/primitive_value.hpp>
 #include <stan/math/fwd/fun/qr_Q.hpp>
 #include <stan/math/fwd/fun/qr_R.hpp>
+#include <stan/math/fwd/fun/quad_form.hpp>
 #include <stan/math/fwd/fun/quad_form_sym.hpp>
 #include <stan/math/fwd/fun/rising_factorial.hpp>
 #include <stan/math/fwd/fun/round.hpp>

stan/math/fwd/fun/columns_dot_product.hpp

@@ -16,8 +16,8 @@ inline Eigen::Matrix<fvar<T>, 1, C1> columns_dot_product(
   check_matching_dims("columns_dot_product", "v1", v1, "v2", v2);
   Eigen::Matrix<fvar<T>, 1, C1> ret(1, v1.cols());
   for (size_type j = 0; j < v1.cols(); ++j) {
-    Eigen::Matrix<fvar<T>, R1, C1> ccol1 = v1.col(j);
-    Eigen::Matrix<fvar<T>, R2, C2> ccol2 = v2.col(j);
+    Eigen::Matrix<fvar<T>, R1, 1> ccol1 = v1.col(j);
+    Eigen::Matrix<fvar<T>, R2, 1> ccol2 = v2.col(j);
     ret(0, j) = dot_product(ccol1, ccol2);
   }
   return ret;
@@ -30,8 +30,8 @@ inline Eigen::Matrix<fvar<T>, 1, C1> columns_dot_product(
   check_matching_dims("columns_dot_product", "v1", v1, "v2", v2);
   Eigen::Matrix<fvar<T>, 1, C1> ret(1, v1.cols());
   for (size_type j = 0; j < v1.cols(); ++j) {
-    Eigen::Matrix<fvar<T>, R1, C1> ccol1 = v1.col(j);
-    Eigen::Matrix<double, R2, C2> ccol = v2.col(j);
+    Eigen::Matrix<fvar<T>, R1, 1> ccol1 = v1.col(j);
+    Eigen::Matrix<double, R2, 1> ccol = v2.col(j);
     ret(0, j) = dot_product(ccol1, ccol);
   }
   return ret;
@@ -44,8 +44,8 @@ inline Eigen::Matrix<fvar<T>, 1, C1> columns_dot_product(
   check_matching_dims("columns_dot_product", "v1", v1, "v2", v2);
   Eigen::Matrix<fvar<T>, 1, C1> ret(1, v1.cols());
   for (size_type j = 0; j < v1.cols(); ++j) {
-    Eigen::Matrix<double, R1, C1> ccol = v1.col(j);
-    Eigen::Matrix<fvar<T>, R2, C2> ccol2 = v2.col(j);
+    Eigen::Matrix<double, R1, 1> ccol = v1.col(j);
+    Eigen::Matrix<fvar<T>, R2, 1> ccol2 = v2.col(j);
     ret(0, j) = dot_product(ccol, ccol2);
   }
   return ret;

stan/math/fwd/fun/columns_dot_self.hpp

@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/typedefs.hpp>
 #include <stan/math/fwd/fun/dot_self.hpp>
 
 namespace stan {

stan/math/fwd/fun/crossprod.hpp

@@ -12,7 +12,7 @@ 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 {};
   }
   return multiply(transpose(m), m);
 }