Stan  1.1
probability, sampling & optimization
 All Classes Namespaces Files Functions Variables Typedefs Enumerator Friends Macros Pages
function_signatures.hpp
Go to the documentation of this file.
1 // included from constructor for function_signatures() in src/stan/gm/ast.hpp
2 
3 std::vector<expr_type> vector_types;
4 vector_types.push_back(DOUBLE_T); // scalar
5 vector_types.push_back(expr_type(DOUBLE_T,1U)); // std vector
6 vector_types.push_back(VECTOR_T); // Eigen vector
7 vector_types.push_back(ROW_VECTOR_T); // Eigen row vector
8 
9 std::vector<expr_type> int_vector_types;
10 int_vector_types.push_back(INT_T); // scalar
11 int_vector_types.push_back(expr_type(INT_T,1U)); // std vector
12 int_vector_types.push_back(VECTOR_T); // Eigen vector
13 int_vector_types.push_back(ROW_VECTOR_T); // Eigen row vector
14 
15 std::vector<expr_type> primitive_types;
16 primitive_types.push_back(INT_T);
17 primitive_types.push_back(DOUBLE_T);
18 
19 add_unary("abs");
20 add("abs",INT_T,INT_T);
21 add_unary("acos");
22 add_unary("acosh");
23 add("add",VECTOR_T,VECTOR_T,VECTOR_T);
24 add("add",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
25 add("add",MATRIX_T,MATRIX_T,MATRIX_T);
26 add("add",VECTOR_T,VECTOR_T,DOUBLE_T);
27 add("add",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
28 add("add",MATRIX_T,MATRIX_T,DOUBLE_T);
29 add("add",VECTOR_T,DOUBLE_T,VECTOR_T);
30 add("add",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
31 add("add",MATRIX_T,DOUBLE_T,MATRIX_T);
32 add_unary("asin");
33 add_unary("asinh");
34 add_unary("atan");
35 add_binary("atan2");
36 add_unary("atanh");
37 for (size_t i = 0; i < int_vector_types.size(); ++i)
38  for (size_t j = 0; j < vector_types.size(); ++j)
39  add("bernoulli_log",DOUBLE_T,int_vector_types[i],vector_types[j]);
40 for (size_t i = 0; i < int_vector_types.size(); ++i)
41  for (size_t j = 0; j < vector_types.size(); ++j)
42  add("bernoulli_logit_log",DOUBLE_T,int_vector_types[i],vector_types[j]);
43 for (size_t i = 0; i < int_vector_types.size(); i++)
44  for (size_t j = 0; j < int_vector_types.size(); j++)
45  for (size_t k = 0; k < vector_types.size(); k++)
46  for (size_t l = 0; l < vector_types.size(); l++)
47  add("beta_binomial_log",DOUBLE_T, // result
48  int_vector_types[i],int_vector_types[j],vector_types[k],vector_types[l]);
49 for (size_t i = 0; i < vector_types.size(); ++i)
50  for (size_t j = 0; j < vector_types.size(); ++j)
51  for (size_t k = 0; k < vector_types.size(); ++k)
52  add("beta_log",
53  DOUBLE_T, // result
54  vector_types[i], vector_types[j], vector_types[k]); // args
55 add("binary_log_loss",DOUBLE_T,INT_T,DOUBLE_T);
56 add_binary("binomial_coefficient_log");
57 for (size_t i = 0; i < int_vector_types.size(); ++i)
58  for (size_t j = 0; j < int_vector_types.size(); ++j)
59  for (size_t k = 0; k < vector_types.size(); ++k)
60  add("binomial_log",DOUBLE_T,int_vector_types[i],int_vector_types[j],vector_types[k]);
61 for (size_t i = 0; i < int_vector_types.size(); ++i)
62  for (size_t j = 0; j < int_vector_types.size(); ++j)
63  for (size_t k = 0; k < vector_types.size(); ++k)
64  add("binomial_logit_log",DOUBLE_T,int_vector_types[i],int_vector_types[j],vector_types[k]);
65 add("categorical_log",DOUBLE_T,INT_T,VECTOR_T);
66 for (size_t i = 0; i < vector_types.size(); ++i)
67  for (size_t j = 0; j < vector_types.size(); ++j)
68  for (size_t k = 0; k < vector_types.size(); ++k)
69  add("cauchy_log",
70  DOUBLE_T, // result
71  vector_types[i], vector_types[j], vector_types[k]); // args
72 add_unary("cbrt");
73 add_unary("ceil");
74 add("cholesky_decompose",MATRIX_T,MATRIX_T);
75 for (size_t i = 0; i < vector_types.size(); ++i)
76  for (size_t j = 0; j < vector_types.size(); ++j)
77  add("chi_square_log",
78  DOUBLE_T, // result
79  vector_types[i], vector_types[j]); // args
80 add("block",MATRIX_T,MATRIX_T,INT_T,INT_T,INT_T,INT_T);
81 add("col",VECTOR_T,MATRIX_T,INT_T);
82 add("cols",INT_T,VECTOR_T);
83 add("cols",INT_T,ROW_VECTOR_T);
84 add("cols",INT_T,MATRIX_T);
85 add_unary("cos");
86 add_unary("cosh");
87 add("cumulative_sum", expr_type(DOUBLE_T,1U), expr_type(DOUBLE_T,1U));
88 add("cumulative_sum", VECTOR_T, VECTOR_T);
89 add("cumulative_sum", ROW_VECTOR_T, ROW_VECTOR_T);
90 add("determinant",DOUBLE_T,MATRIX_T);
91 add("diagonal",VECTOR_T,MATRIX_T);
92 add("diag_matrix",MATRIX_T,VECTOR_T);
93 add("dirichlet_log",DOUBLE_T,VECTOR_T,VECTOR_T);
94 add("divide",DOUBLE_T,DOUBLE_T,DOUBLE_T);
95 add("divide",VECTOR_T,VECTOR_T,DOUBLE_T);
96 add("divide",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
97 add("divide",MATRIX_T,MATRIX_T,DOUBLE_T);
98 add("dot_product",DOUBLE_T,VECTOR_T,VECTOR_T);
99 add("dot_product",DOUBLE_T,ROW_VECTOR_T,ROW_VECTOR_T);
100 add("dot_product",DOUBLE_T,VECTOR_T,ROW_VECTOR_T);
101 add("dot_product",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
102 add("dot_product",DOUBLE_T,expr_type(DOUBLE_T,1U),expr_type(DOUBLE_T,1U)); // vectorized
103 add("dot_self",DOUBLE_T,VECTOR_T);
104 add("dot_self",DOUBLE_T,ROW_VECTOR_T);
105 for (size_t i = 0; i < vector_types.size(); ++i)
106  for (size_t j = 0; j < vector_types.size(); ++j)
107  for (size_t k = 0; k < vector_types.size(); ++k)
108  add("double_exponential_log",
109  DOUBLE_T, // result
110  vector_types[i], vector_types[j], vector_types[k]); // args
111 add_nullary("e");
112 add("eigenvalues_sym",VECTOR_T,MATRIX_T);
113 add("eigenvectors_sym",MATRIX_T,MATRIX_T);
114 add("elt_divide",VECTOR_T,VECTOR_T,VECTOR_T);
115 add("elt_divide",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
116 add("elt_divide",MATRIX_T,MATRIX_T,MATRIX_T);
117 add("elt_multiply",VECTOR_T,VECTOR_T,VECTOR_T);
118 add("elt_multiply",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
119 add("elt_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
120 add("diag_pre_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
121 add("diag_pre_multiply",MATRIX_T,VECTOR_T,MATRIX_T);
122 add("diag_pre_multiply",MATRIX_T,ROW_VECTOR_T,MATRIX_T);
123 add("diag_post_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
124 add("diag_post_multiply",MATRIX_T,MATRIX_T,VECTOR_T);
125 add("diag_post_multiply",MATRIX_T,MATRIX_T,ROW_VECTOR_T);
126 add_nullary("epsilon");
127 add_unary("erf");
128 add_unary("erfc");
129 add_unary("exp");
130 add("exp",VECTOR_T,VECTOR_T);
131 add("exp",ROW_VECTOR_T,ROW_VECTOR_T);
132 add("exp",MATRIX_T,MATRIX_T);
133 add_unary("exp2");
134 add_unary("expm1");
135 for (size_t i = 0; i < vector_types.size(); ++i)
136  for (size_t j = 0; j < vector_types.size(); ++j)
137  add("exponential_log",
138  DOUBLE_T, // result
139  vector_types[i], vector_types[j]); // args
140 add_binary("exponential_cdf");
141 add_unary("fabs");
142 add_binary("fdim");
143 add_unary("floor");
144 add_ternary("fma");
145 add_binary("fmax");
146 add_binary("fmin");
147 add_binary("fmod");
148 for (size_t i = 0; i < vector_types.size(); ++i)
149  for (size_t j = 0; j < vector_types.size(); ++j)
150  for (size_t k = 0; k < vector_types.size(); ++k)
151  add("gamma_log",
152  DOUBLE_T, // result
153  vector_types[i], vector_types[j], vector_types[k]); // args
154 //FIXME: add_ternary("gamma_cdf");
155 add("hypergeometric_log",DOUBLE_T, INT_T, INT_T, INT_T, INT_T);
156 add_binary("hypot");
157 add("if_else",DOUBLE_T,INT_T,DOUBLE_T,DOUBLE_T);
158 add("int_step",INT_T,DOUBLE_T);
159 add("int_step",INT_T,INT_T);
160 for (size_t i = 0; i < vector_types.size(); ++i)
161  for (size_t j = 0; j < vector_types.size(); ++j)
162  add("inv_chi_square_log",
163  DOUBLE_T, // result
164  vector_types[i], vector_types[j]); // args
165 add_unary("inv_cloglog");
166 for (size_t i = 0; i < vector_types.size(); ++i)
167  for (size_t j = 0; j < vector_types.size(); ++j)
168  for (size_t k = 0; k < vector_types.size(); ++k)
169  add("inv_gamma_log",
170  DOUBLE_T, // result
171  vector_types[i], vector_types[j], vector_types[k]); // args
172 add_unary("inv_logit");
173 add("inv_wishart_log",DOUBLE_T, MATRIX_T,DOUBLE_T,MATRIX_T);
174 add("inverse",MATRIX_T,MATRIX_T);
175 add_binary("lbeta");
176 add_unary("lgamma");
177 add("lkj_corr_cholesky_log",DOUBLE_T, MATRIX_T,DOUBLE_T);
178 add("lkj_corr_log",DOUBLE_T, MATRIX_T,DOUBLE_T);
179 add("lkj_cov_log",DOUBLE_T, MATRIX_T,VECTOR_T,VECTOR_T,DOUBLE_T);
180 add("lmgamma",DOUBLE_T,INT_T,DOUBLE_T);
181 for (size_t i = 0; i < primitive_types.size(); ++i) {
182  add("logical_negation",INT_T,primitive_types[i]);
183  for (size_t j = 0; j < primitive_types.size(); ++j) {
184  add("logical_or",INT_T,primitive_types[i], primitive_types[j]);
185  add("logical_and",INT_T,primitive_types[i], primitive_types[j]);
186  add("logical_eq",INT_T,primitive_types[i], primitive_types[j]);
187  add("logical_neq",INT_T,primitive_types[i], primitive_types[j]);
188  add("logical_lt",INT_T,primitive_types[i], primitive_types[j]);
189  add("logical_lte",INT_T,primitive_types[i], primitive_types[j]);
190  add("logical_gt",INT_T,primitive_types[i], primitive_types[j]);
191  add("logical_gte",INT_T,primitive_types[i], primitive_types[j]);
192  }
193 }
194 add_unary("log");
195 add("log",VECTOR_T,VECTOR_T);
196 add("log",ROW_VECTOR_T,ROW_VECTOR_T);
197 add("log",MATRIX_T,MATRIX_T);
198 add("log_determinant",DOUBLE_T,MATRIX_T);
199 add("log_sum_exp",DOUBLE_T, expr_type(DOUBLE_T,1U));
200 add_binary("log_sum_exp");
201 add_nullary("log10");
202 add_unary("log10");
203 add_unary("log1m");
204 add_unary("log1p");
205 add_unary("log1p_exp");
206 add_unary("log_inv_logit");
207 add_unary("log1m_inv_logit");
208 add_nullary("log2");
209 add_unary("log2");
210 for (size_t i = 0; i < vector_types.size(); ++i)
211  for (size_t j = 0; j < vector_types.size(); ++j)
212  for (size_t k = 0; k < vector_types.size(); ++k)
213  add("logistic_log",
214  DOUBLE_T, // result
215  vector_types[i], vector_types[j], vector_types[k]); // args
216 add_unary("logit");
217 add_ternary("lognormal_cdf");
218 for (size_t i = 0; i < vector_types.size(); ++i)
219  for (size_t j = 0; j < vector_types.size(); ++j)
220  for (size_t k = 0; k < vector_types.size(); ++k)
221  add("lognormal_log",
222  DOUBLE_T, // result
223  vector_types[i], vector_types[j], vector_types[k]); // args
224 add("max",INT_T,expr_type(INT_T,1));
225 add("max",DOUBLE_T,expr_type(DOUBLE_T,1));
226 add("max",DOUBLE_T,VECTOR_T);
227 add("max",DOUBLE_T,ROW_VECTOR_T);
228 add("max",DOUBLE_T,MATRIX_T);
229 add("max",INT_T,INT_T,INT_T);
230 add("mdivide_left",VECTOR_T,MATRIX_T,VECTOR_T);
231 add("mdivide_left",MATRIX_T,MATRIX_T,MATRIX_T);
232 add("mdivide_right",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
233 add("mdivide_right",MATRIX_T,MATRIX_T,MATRIX_T);
234 add("mdivide_left_tri_low",MATRIX_T,MATRIX_T,MATRIX_T);
235 add("mdivide_left_tri_low",VECTOR_T,MATRIX_T,VECTOR_T);
236 add("mdivide_right_tri_low",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
237 add("mdivide_right_tri_low",MATRIX_T,MATRIX_T,MATRIX_T);
238 add("mean",DOUBLE_T,expr_type(DOUBLE_T,1));
239 add("mean",DOUBLE_T,VECTOR_T);
240 add("mean",DOUBLE_T,ROW_VECTOR_T);
241 add("mean",DOUBLE_T,MATRIX_T);
242 add("min",INT_T,expr_type(INT_T,1));
243 add("min",DOUBLE_T,expr_type(DOUBLE_T,1));
244 add("min",DOUBLE_T,VECTOR_T);
245 add("min",DOUBLE_T,ROW_VECTOR_T);
246 add("min",DOUBLE_T,MATRIX_T);
247 add("min",INT_T,INT_T,INT_T);
248 add("minus",DOUBLE_T,DOUBLE_T);
249 add("minus",VECTOR_T,VECTOR_T);
250 add("minus",ROW_VECTOR_T,ROW_VECTOR_T);
251 add("minus",MATRIX_T,MATRIX_T);
252 add("multi_normal_cholesky_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
253 add("multi_normal_prec_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
254 add("multi_normal_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
255 add("multi_student_t_log",DOUBLE_T, VECTOR_T,DOUBLE_T,VECTOR_T,MATRIX_T);
256 add("multinomial_log",DOUBLE_T, expr_type(INT_T,1U), VECTOR_T);
257 add("multiply",DOUBLE_T,DOUBLE_T,DOUBLE_T);
258 add("multiply",VECTOR_T,VECTOR_T,DOUBLE_T);
259 add("multiply",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
260 add("multiply",MATRIX_T,MATRIX_T,DOUBLE_T);
261 add("multiply",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
262 add("multiply",MATRIX_T,VECTOR_T,ROW_VECTOR_T);
263 add("multiply",VECTOR_T,MATRIX_T,VECTOR_T);
264 add("multiply",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
265 add("multiply",MATRIX_T,MATRIX_T,MATRIX_T);
266 add("multiply",VECTOR_T,DOUBLE_T,VECTOR_T);
267 add("multiply",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
268 add("multiply",MATRIX_T,DOUBLE_T,MATRIX_T);
269 add("multiply_lower_tri_self_transpose",MATRIX_T,MATRIX_T);
270 add("tcrossprod",MATRIX_T,MATRIX_T);
271 add("crossprod",MATRIX_T,MATRIX_T);
272 add_binary("multiply_log");
273 for (size_t i = 0; i < int_vector_types.size(); ++i)
274  for (size_t j = 0; j < vector_types.size(); ++j)
275  for (size_t k = 0; k < vector_types.size(); ++k)
276  add("neg_binomial_log",DOUBLE_T,int_vector_types[i],vector_types[j],vector_types[k]);
277 add_nullary("negative_epsilon");
278 add_nullary("negative_infinity");
279 add_ternary("normal_cdf"); // not vectorizing yet!
280 for (size_t i = 0; i < vector_types.size(); ++i)
281  for (size_t j = 0; j < vector_types.size(); ++j)
282  for (size_t k = 0; k < vector_types.size(); ++k)
283  add("normal_log",
284  DOUBLE_T, // result
285  vector_types[i], vector_types[j], vector_types[k]); // args
286 add_nullary("not_a_number");
287 add("ordered_logistic_log",DOUBLE_T,INT_T,DOUBLE_T,VECTOR_T);
288 for (size_t i = 0; i < vector_types.size(); ++i)
289  for (size_t j = 0; j < vector_types.size(); ++j)
290  for (size_t k = 0; k < vector_types.size(); ++k)
291  add("pareto_log",
292  DOUBLE_T, // result
293  vector_types[i], vector_types[j], vector_types[k]); // args
294 add_unary("Phi");
295 add_unary("Phi_approx");
296 add_nullary("pi");
297 for (size_t i = 0; i < int_vector_types.size(); ++i) {
298  for (size_t j = 0; j < vector_types.size(); ++j) {
299  add("poisson_log",DOUBLE_T, int_vector_types[i],vector_types[j]);
300  add("poisson_log_log",DOUBLE_T, int_vector_types[i],vector_types[j]);
301  }
302  }
303 add_nullary("positive_infinity");
304 add_binary("pow");
305 add("prod",INT_T,expr_type(INT_T,1));
306 add("prod",DOUBLE_T,expr_type(DOUBLE_T,1));
307 add("prod",DOUBLE_T,VECTOR_T);
308 add("prod",DOUBLE_T,ROW_VECTOR_T);
309 add("prod",DOUBLE_T,MATRIX_T);
310 add_unary("round");
311 add("row",ROW_VECTOR_T,MATRIX_T,INT_T);
312 add("rows",INT_T,VECTOR_T);
313 add("rows",INT_T,ROW_VECTOR_T);
314 add("rows",INT_T,MATRIX_T);
315 for (size_t i = 0; i < vector_types.size(); ++i)
316  for (size_t j = 0; j < vector_types.size(); ++j)
317  for (size_t k = 0; k < vector_types.size(); ++k)
318  add("scaled_inv_chi_square_log",
319  DOUBLE_T, // result
320  vector_types[i], vector_types[j], vector_types[k]); // args
321 add("sd",DOUBLE_T,expr_type(DOUBLE_T,1));
322 add("sd",DOUBLE_T,VECTOR_T);
323 add("sd",DOUBLE_T,ROW_VECTOR_T);
324 add("sd",DOUBLE_T,MATRIX_T);
325 add_unary("sin");
326 add("singular_values",VECTOR_T,MATRIX_T);
327 add_unary("sinh");
328 add("softmax",VECTOR_T,VECTOR_T);
329 add_unary("sqrt");
330 add_nullary("sqrt2");
331 add_unary("square");
332 add_unary("step");
333 for (size_t i = 0; i < vector_types.size(); ++i)
334  for (size_t j = 0; j < vector_types.size(); ++j)
335  for (size_t k = 0; k < vector_types.size(); ++k)
336  for (size_t l = 0; l < vector_types.size(); ++l)
337  add("student_t_log",
338  DOUBLE_T, // result
339  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
340 add("subtract",VECTOR_T,VECTOR_T,VECTOR_T);
341 add("subtract",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
342 add("subtract",MATRIX_T,MATRIX_T,MATRIX_T);
343 add("subtract",VECTOR_T,VECTOR_T,DOUBLE_T);
344 add("subtract",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
345 add("subtract",MATRIX_T,MATRIX_T,DOUBLE_T);
346 add("subtract",VECTOR_T,DOUBLE_T,VECTOR_T);
347 add("subtract",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
348 add("subtract",MATRIX_T,DOUBLE_T,MATRIX_T);
349 add("sum",INT_T,expr_type(INT_T,1));
350 add("sum",DOUBLE_T,expr_type(DOUBLE_T,1));
351 add("sum",DOUBLE_T,VECTOR_T);
352 add("sum",DOUBLE_T,ROW_VECTOR_T);
353 add("sum",DOUBLE_T,MATRIX_T);
354 add_unary("tan");
355 add_unary("tanh");
356 add_unary("tgamma");
357 add("trace",DOUBLE_T,MATRIX_T);
358 add("transpose",ROW_VECTOR_T,VECTOR_T);
359 add("transpose",VECTOR_T,ROW_VECTOR_T);
360 add("transpose",MATRIX_T,MATRIX_T);
361 add_unary("trunc");
362 for (size_t i = 0; i < vector_types.size(); ++i)
363  for (size_t j = 0; j < vector_types.size(); ++j)
364  for (size_t k = 0; k < vector_types.size(); ++k)
365  add("uniform_log",
366  DOUBLE_T, // result
367  vector_types[i], vector_types[j], vector_types[k]); // args
368 add("variance",DOUBLE_T,expr_type(DOUBLE_T,1));
369 add("variance",DOUBLE_T,VECTOR_T);
370 add("variance",DOUBLE_T,ROW_VECTOR_T);
371 add("variance",DOUBLE_T,MATRIX_T);
372 for (size_t i = 0; i < vector_types.size(); ++i)
373  for (size_t j = 0; j < vector_types.size(); ++j)
374  for (size_t k = 0; k < vector_types.size(); ++k)
375  add("weibull_log",
376  DOUBLE_T, // result
377  vector_types[i], vector_types[j], vector_types[k]); // args
378 add_ternary("weibull_cdf");
379 add("wishart_log",DOUBLE_T, MATRIX_T,DOUBLE_T,MATRIX_T);
380 
381 
382 // dims() is polymorphic by size
383 for (size_t i = 0; i < 8; ++i) {
384  add("dims",expr_type(INT_T,1),expr_type(INT_T,i));
385  add("dims",expr_type(INT_T,1),expr_type(DOUBLE_T,i));
386  add("dims",expr_type(INT_T,1),expr_type(VECTOR_T,i));
387  add("dims",expr_type(INT_T,1),expr_type(ROW_VECTOR_T,i));
388  add("dims",expr_type(INT_T,1),expr_type(MATRIX_T,i));
389 }
390 // size() is polymorphic over arrays, so start i at 1
391 for (size_t i = 1; i < 8; ++i) {
392  add("size",INT_T,expr_type(INT_T,i));
393  add("size",INT_T,expr_type(DOUBLE_T,i));
394  add("size",INT_T,expr_type(VECTOR_T,i));
395  add("size",INT_T,expr_type(ROW_VECTOR_T,i));
396  add("size",INT_T,expr_type(MATRIX_T,i));
397 }
398 //------------------------------------------------------------
399 
400 add("trunc_normal_log",DOUBLE_T, DOUBLE_T,DOUBLE_T,DOUBLE_T,DOUBLE_T,DOUBLE_T);
401 
     [ Stan Home Page ] © 2011–2013, Stan Development Team.