Description
Description
For initialization in the language and for general use, we need functions that will initialize constant containers without allocating new vari
and without placing those vari
on the stack to have their chain()
methods called. What we need is something like this with an explicit template parameter,
template <typename T>
std::vector<T> constant_vector(size_t N, double value);
that would be implemented someting like this:
template <typename T>
inline std::vector<T> init_std_vector(size_t n) {
return std::vector<T>(n, std::numeric_limits<double>::quiet_Nan());
}
template <>
inline std::vector<var> init_std_vector<var>(size_t n) {
std::vector<var> x;
x.reserve(n);
vari* dummy_vi = new vari(std::numeric_limits<double>::quiet_Nan(), false);
for (size_t i = 0; i < n; ++i)
x.emplace_back(dummy_vi);
return x;
}
That creates a std::vector<var>
with only a single vari
that's not on the autodiff stack.
We want to do the same thing for Eigen::Matrix<T, R, C>
.
I'm not sure how this will interact with the existing functions that have recently been added. Those do not have template parameters and default to primitive types (double
and int
).
I also think we can get rid of the no-chain stack as I don't think it's being used for anything, but that's a different PR.
This came up in an issue in stanc3
Example
Current Version:
v3.1.0