Stan  1.3
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
2 // src/stan/gm/ast.hpp
3 
4 std::vector<base_expr_type> base_types;
5 base_types.push_back(INT_T);
6 base_types.push_back(DOUBLE_T);
7 base_types.push_back(VECTOR_T);
8 base_types.push_back(ROW_VECTOR_T);
9 base_types.push_back(MATRIX_T);
10 
11 std::vector<expr_type> vector_types;
12 vector_types.push_back(DOUBLE_T); // scalar
13 vector_types.push_back(expr_type(DOUBLE_T,1U)); // std vector
14 vector_types.push_back(VECTOR_T); // Eigen vector
15 vector_types.push_back(ROW_VECTOR_T); // Eigen row vector
16 
17 std::vector<expr_type> int_vector_types;
18 int_vector_types.push_back(INT_T); // scalar
19 int_vector_types.push_back(expr_type(INT_T,1U)); // std vector
20 
21 std::vector<expr_type> primitive_types;
22 primitive_types.push_back(INT_T);
23 primitive_types.push_back(DOUBLE_T);
24 
25 add_unary("abs");
26 add("abs",INT_T,INT_T);
27 add_unary("acos");
28 add_unary("acosh");
29 add("add",VECTOR_T,VECTOR_T,VECTOR_T);
30 add("add",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
31 add("add",MATRIX_T,MATRIX_T,MATRIX_T);
32 add("add",VECTOR_T,VECTOR_T,DOUBLE_T);
33 add("add",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
34 add("add",MATRIX_T,MATRIX_T,DOUBLE_T);
35 add("add",VECTOR_T,DOUBLE_T,VECTOR_T);
36 add("add",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
37 add("add",MATRIX_T,DOUBLE_T,MATRIX_T);
38 add_unary("asin");
39 add_unary("asinh");
40 add_unary("atan");
41 add_binary("atan2");
42 add_unary("atanh");
43 for (size_t i = 0; i < int_vector_types.size(); ++i)
44  for (size_t j = 0; j < vector_types.size(); ++j)
45  add("bernoulli_log",DOUBLE_T,int_vector_types[i],vector_types[j]);
46 for (size_t i = 0; i < int_vector_types.size(); ++i)
47  for (size_t j = 0; j < vector_types.size(); ++j)
48  add("bernoulli_cdf",DOUBLE_T,int_vector_types[i],vector_types[j]);
49 add("bernoulli_rng",INT_T,DOUBLE_T);
50 for (size_t i = 0; i < int_vector_types.size(); ++i)
51  for (size_t j = 0; j < vector_types.size(); ++j)
52  add("bernoulli_logit_log",DOUBLE_T,int_vector_types[i],vector_types[j]);
53 for (size_t i = 0; i < int_vector_types.size(); i++)
54  for (size_t j = 0; j < int_vector_types.size(); j++)
55  for (size_t k = 0; k < vector_types.size(); k++)
56  for (size_t l = 0; l < vector_types.size(); l++)
57  add("beta_binomial_log",DOUBLE_T, // result
58  int_vector_types[i],int_vector_types[j],vector_types[k],vector_types[l]);
59 add("beta_binomial_rng",INT_T,INT_T,DOUBLE_T,DOUBLE_T);
60 for (size_t i = 0; i < int_vector_types.size(); i++)
61  for (size_t j = 0; j < int_vector_types.size(); j++)
62  for (size_t k = 0; k < vector_types.size(); k++)
63  for (size_t l = 0; l < vector_types.size(); l++)
64  add("beta_binomial_cdf",DOUBLE_T, // result
65  int_vector_types[i],int_vector_types[j],vector_types[k],vector_types[l]);
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("beta_log",
70  DOUBLE_T, // result
71  vector_types[i], vector_types[j], vector_types[k]); // args
72 for (size_t i = 0; i < vector_types.size(); ++i)
73  for (size_t j = 0; j < vector_types.size(); ++j)
74  for (size_t k = 0; k < vector_types.size(); ++k)
75  add("beta_cdf",
76  DOUBLE_T, // result
77  vector_types[i], vector_types[j], vector_types[k]); // args
78 add_binary("beta_rng");
79 add("binary_log_loss",DOUBLE_T,INT_T,DOUBLE_T);
80 add_binary("binomial_coefficient_log");
81 for (size_t i = 0; i < int_vector_types.size(); ++i)
82  for (size_t j = 0; j < int_vector_types.size(); ++j)
83  for (size_t k = 0; k < vector_types.size(); ++k)
84  add("binomial_log",DOUBLE_T,int_vector_types[i],int_vector_types[j],vector_types[k]);
85 add("binomial_rng",INT_T,INT_T,DOUBLE_T);
86 for (size_t i = 0; i < int_vector_types.size(); ++i)
87  for (size_t j = 0; j < int_vector_types.size(); ++j)
88  for (size_t k = 0; k < vector_types.size(); ++k)
89  add("binomial_cdf",DOUBLE_T,int_vector_types[i],int_vector_types[j],vector_types[k]);
90 for (size_t i = 0; i < int_vector_types.size(); ++i)
91  for (size_t j = 0; j < int_vector_types.size(); ++j)
92  for (size_t k = 0; k < vector_types.size(); ++k)
93  add("binomial_logit_log",DOUBLE_T,int_vector_types[i],int_vector_types[j],vector_types[k]);
94 add("categorical_log",DOUBLE_T,INT_T,VECTOR_T);
95 add("categorical_rng",INT_T,VECTOR_T);
96 for (size_t i = 0; i < vector_types.size(); ++i)
97  for (size_t j = 0; j < vector_types.size(); ++j)
98  for (size_t k = 0; k < vector_types.size(); ++k)
99  add("cauchy_log",
100  DOUBLE_T, // result
101  vector_types[i], vector_types[j], vector_types[k]); // args
102 add_binary("cauchy_rng");
103 for (size_t i = 0; i < vector_types.size(); ++i)
104  for (size_t j = 0; j < vector_types.size(); ++j)
105  for (size_t k = 0; k < vector_types.size(); ++k)
106  add("cauchy_cdf",
107  DOUBLE_T, // result
108  vector_types[i], vector_types[j], vector_types[k]); // args
109 add_unary("cbrt");
110 add_unary("ceil");
111 add("cholesky_decompose",MATRIX_T,MATRIX_T);
112 for (size_t i = 0; i < vector_types.size(); ++i)
113  for (size_t j = 0; j < vector_types.size(); ++j)
114  add("chi_square_log",
115  DOUBLE_T, // result
116  vector_types[i], vector_types[j]); // args
117 add_unary("chi_square_rng");
118 add("block",MATRIX_T,MATRIX_T,INT_T,INT_T,INT_T,INT_T);
119 add("col",VECTOR_T,MATRIX_T,INT_T);
120 add("cols",INT_T,VECTOR_T);
121 add("cols",INT_T,ROW_VECTOR_T);
122 add("cols",INT_T,MATRIX_T);
123 add_unary("cos");
124 add_unary("cosh");
125 add("cumulative_sum", expr_type(DOUBLE_T,1U), expr_type(DOUBLE_T,1U));
126 add("cumulative_sum", VECTOR_T, VECTOR_T);
127 add("cumulative_sum", ROW_VECTOR_T, ROW_VECTOR_T);
128 add("determinant",DOUBLE_T,MATRIX_T);
129 add("diagonal",VECTOR_T,MATRIX_T);
130 add("diag_matrix",MATRIX_T,VECTOR_T);
131 add("dirichlet_log",DOUBLE_T,VECTOR_T,VECTOR_T);
132 add("dirichlet_rng",VECTOR_T,VECTOR_T);
133 add("divide",DOUBLE_T,DOUBLE_T,DOUBLE_T);
134 add("divide",VECTOR_T,VECTOR_T,DOUBLE_T);
135 add("divide",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
136 add("divide",MATRIX_T,MATRIX_T,DOUBLE_T);
137 add("columns_dot_product",ROW_VECTOR_T,MATRIX_T,MATRIX_T);
138 add("rows_dot_product",VECTOR_T,MATRIX_T,MATRIX_T);
139 add("dist",DOUBLE_T,VECTOR_T,VECTOR_T);
140 add("dist",DOUBLE_T,ROW_VECTOR_T,ROW_VECTOR_T);
141 add("dist",DOUBLE_T,VECTOR_T,ROW_VECTOR_T);
142 add("dist",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
143 add("squared_dist",DOUBLE_T,VECTOR_T,VECTOR_T);
144 add("squared_dist",DOUBLE_T,ROW_VECTOR_T,ROW_VECTOR_T);
145 add("squared_dist",DOUBLE_T,VECTOR_T,ROW_VECTOR_T);
146 add("squared_dist",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
147 add("dot_product",DOUBLE_T,VECTOR_T,VECTOR_T);
148 add("dot_product",DOUBLE_T,ROW_VECTOR_T,ROW_VECTOR_T);
149 add("dot_product",DOUBLE_T,VECTOR_T,ROW_VECTOR_T);
150 add("dot_product",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
151 add("dot_product",DOUBLE_T,expr_type(DOUBLE_T,1U),expr_type(DOUBLE_T,1U)); // vectorized
152 add("dot_self",DOUBLE_T,VECTOR_T);
153 add("dot_self",DOUBLE_T,ROW_VECTOR_T);
154 for (size_t i = 0; i < vector_types.size(); ++i)
155  for (size_t j = 0; j < vector_types.size(); ++j)
156  for (size_t k = 0; k < vector_types.size(); ++k)
157  add("double_exponential_log",
158  DOUBLE_T, // result
159  vector_types[i], vector_types[j], vector_types[k]); // args
160 add_binary("double_exponential_rng");
161 add_nullary("e");
162 add("eigenvalues_sym",VECTOR_T,MATRIX_T);
163 add("eigenvectors_sym",MATRIX_T,MATRIX_T);
164 add("elt_divide",VECTOR_T,VECTOR_T,VECTOR_T);
165 add("elt_divide",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
166 add("elt_divide",MATRIX_T,MATRIX_T,MATRIX_T);
167 add("elt_multiply",VECTOR_T,VECTOR_T,VECTOR_T);
168 add("elt_multiply",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
169 add("elt_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
170 add("diag_pre_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
171 add("diag_pre_multiply",MATRIX_T,VECTOR_T,MATRIX_T);
172 add("diag_pre_multiply",MATRIX_T,ROW_VECTOR_T,MATRIX_T);
173 add("diag_post_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
174 add("diag_post_multiply",MATRIX_T,MATRIX_T,VECTOR_T);
175 add("diag_post_multiply",MATRIX_T,MATRIX_T,ROW_VECTOR_T);
176 add_nullary("epsilon");
177 add_unary("erf");
178 add_unary("erfc");
179 add_unary("exp");
180 add("exp",VECTOR_T,VECTOR_T);
181 add("exp",ROW_VECTOR_T,ROW_VECTOR_T);
182 add("exp",MATRIX_T,MATRIX_T);
183 add_unary("exp2");
184 add_unary("expm1");
185 for (size_t i = 0; i < vector_types.size(); ++i)
186  for (size_t j = 0; j < vector_types.size(); ++j)
187  add("exponential_log",
188  DOUBLE_T, // result
189  vector_types[i], vector_types[j]); // args
190 add_binary("exponential_cdf");
191 add_unary("exponential_rng");
192 for (size_t i = 0; i < vector_types.size(); ++i) {
193  for (size_t j = 0; j < vector_types.size(); ++j) {
194  for (size_t k = 0; k < vector_types.size(); ++k) {
195  for (size_t l = 0; l < vector_types.size(); ++l) {
196  add("exp_mod_normal_log",
197  DOUBLE_T, // result
198  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
199  add("exp_mod_normal_cdf",
200  DOUBLE_T, // result
201  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
202  }
203  }
204  }
205 }
206 add_ternary("exp_mod_normal_rng");
207 add_unary("fabs");
208 add_binary("fdim");
209 add_unary("floor");
210 add_ternary("fma");
211 add_binary("fmax");
212 add_binary("fmin");
213 add_binary("fmod");
214 for (size_t i = 0; i < vector_types.size(); ++i)
215  for (size_t j = 0; j < vector_types.size(); ++j)
216  for (size_t k = 0; k < vector_types.size(); ++k)
217  add("gamma_log",
218  DOUBLE_T, // result
219  vector_types[i], vector_types[j], vector_types[k]); // args
220 //FIXME: add_ternary("gamma_cdf");
221 add_binary("gamma_rng");
222 for (size_t i = 0; i < vector_types.size(); ++i) {
223  for (size_t j = 0; j < vector_types.size(); ++j) {
224  for (size_t k = 0; k < vector_types.size(); ++k) {
225  add("gumbel_cdf",
226  DOUBLE_T, // result
227  vector_types[i], vector_types[j], vector_types[k]); // args
228  add("gumbel_log",
229  DOUBLE_T, // result
230  vector_types[i], vector_types[j], vector_types[k]); // args
231  }
232  }
233 }
234 add_binary("gumbel_rng");
235 add("hypergeometric_log",DOUBLE_T, INT_T,INT_T,INT_T,INT_T);
236 add("hypergeometric_rng",INT_T, INT_T,INT_T,INT_T);
237 add_binary("hypot");
238 add("if_else",DOUBLE_T,INT_T,DOUBLE_T,DOUBLE_T);
239 add("int_step",INT_T,DOUBLE_T);
240 add("int_step",INT_T,INT_T);
241 for (size_t i = 0; i < vector_types.size(); ++i)
242  for (size_t j = 0; j < vector_types.size(); ++j)
243  add("inv_chi_square_log",
244  DOUBLE_T, // result
245  vector_types[i], vector_types[j]); // args
246 for (size_t i = 0; i < vector_types.size(); ++i)
247  for (size_t j = 0; j < vector_types.size(); ++j)
248  add("inv_chi_square_cdf",
249  DOUBLE_T, // result
250  vector_types[i], vector_types[j]); // args
251 add_unary("inv_chi_square_rng");
252 add_unary("inv_cloglog");
253 for (size_t i = 0; i < vector_types.size(); ++i)
254  for (size_t j = 0; j < vector_types.size(); ++j)
255  for (size_t k = 0; k < vector_types.size(); ++k)
256  add("inv_gamma_log",
257  DOUBLE_T, // result
258  vector_types[i], vector_types[j], vector_types[k]); // args
259 for (size_t i = 0; i < vector_types.size(); ++i)
260  for (size_t j = 0; j < vector_types.size(); ++j)
261  for (size_t k = 0; k < vector_types.size(); ++k)
262  add("inv_gamma_cdf",
263  DOUBLE_T, // result
264  vector_types[i], vector_types[j], vector_types[k]); // args
265 add_binary("inv_gamma_rng");
266 add_unary("inv_logit");
267 add("inv_wishart_log",DOUBLE_T, MATRIX_T,DOUBLE_T,MATRIX_T);
268 add("inv_wishart_rng",MATRIX_T,DOUBLE_T,MATRIX_T);
269 add("inverse",MATRIX_T,MATRIX_T);
270 add_binary("lbeta");
271 add_unary("lgamma");
272 add("lkj_corr_cholesky_log",DOUBLE_T, MATRIX_T,DOUBLE_T);
273 add("lkj_corr_cholesky_rng",MATRIX_T,INT_T,DOUBLE_T);
274 add("lkj_corr_log",DOUBLE_T, MATRIX_T,DOUBLE_T);
275 add("lkj_corr_rng",MATRIX_T,INT_T,DOUBLE_T);
276 add("lkj_cov_log",DOUBLE_T, MATRIX_T,VECTOR_T,VECTOR_T,DOUBLE_T);
277 add("lmgamma",DOUBLE_T,INT_T,DOUBLE_T);
278 for (size_t i = 0; i < primitive_types.size(); ++i) {
279  add("logical_negation",INT_T,primitive_types[i]);
280  for (size_t j = 0; j < primitive_types.size(); ++j) {
281  add("logical_or",INT_T,primitive_types[i], primitive_types[j]);
282  add("logical_and",INT_T,primitive_types[i], primitive_types[j]);
283  add("logical_eq",INT_T,primitive_types[i], primitive_types[j]);
284  add("logical_neq",INT_T,primitive_types[i], primitive_types[j]);
285  add("logical_lt",INT_T,primitive_types[i], primitive_types[j]);
286  add("logical_lte",INT_T,primitive_types[i], primitive_types[j]);
287  add("logical_gt",INT_T,primitive_types[i], primitive_types[j]);
288  add("logical_gte",INT_T,primitive_types[i], primitive_types[j]);
289  }
290 }
291 add_unary("log");
292 add("log",VECTOR_T,VECTOR_T);
293 add("log",ROW_VECTOR_T,ROW_VECTOR_T);
294 add("log",MATRIX_T,MATRIX_T);
295 add("log_determinant",DOUBLE_T,MATRIX_T);
296 add("log_sum_exp",DOUBLE_T, expr_type(DOUBLE_T,1U));
297 add_binary("log_sum_exp");
298 add_nullary("log10");
299 add_unary("log10");
300 add_unary("log1m");
301 add_unary("log1p");
302 add_unary("log1p_exp");
303 add_unary("log_inv_logit");
304 add_unary("log1m_inv_logit");
305 add_nullary("log2");
306 add_unary("log2");
307 for (size_t i = 0; i < vector_types.size(); ++i)
308  for (size_t j = 0; j < vector_types.size(); ++j)
309  for (size_t k = 0; k < vector_types.size(); ++k)
310  add("logistic_log",
311  DOUBLE_T, // result
312  vector_types[i], vector_types[j], vector_types[k]); // args
313 for (size_t i = 0; i < vector_types.size(); ++i)
314  for (size_t j = 0; j < vector_types.size(); ++j)
315  for (size_t k = 0; k < vector_types.size(); ++k)
316  add("logistic_cdf",
317  DOUBLE_T, // result
318  vector_types[i], vector_types[j], vector_types[k]); // args
319 add_binary("logistic_rng");
320 add_unary("logit");
321 add_ternary("lognormal_cdf");
322 for (size_t i = 0; i < vector_types.size(); ++i)
323  for (size_t j = 0; j < vector_types.size(); ++j)
324  for (size_t k = 0; k < vector_types.size(); ++k)
325  add("lognormal_log",
326  DOUBLE_T, // result
327  vector_types[i], vector_types[j], vector_types[k]); // args
328 add_binary("lognormal_rng");
329 add("max",INT_T,expr_type(INT_T,1));
330 add("max",DOUBLE_T,expr_type(DOUBLE_T,1));
331 add("max",DOUBLE_T,VECTOR_T);
332 add("max",DOUBLE_T,ROW_VECTOR_T);
333 add("max",DOUBLE_T,MATRIX_T);
334 add("max",INT_T,INT_T,INT_T);
335 add("mdivide_left",VECTOR_T,MATRIX_T,VECTOR_T);
336 add("mdivide_left",MATRIX_T,MATRIX_T,MATRIX_T);
337 add("mdivide_right",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
338 add("mdivide_right",MATRIX_T,MATRIX_T,MATRIX_T);
339 add("mdivide_left_tri_low",MATRIX_T,MATRIX_T,MATRIX_T);
340 add("mdivide_left_tri_low",VECTOR_T,MATRIX_T,VECTOR_T);
341 add("mdivide_right_tri_low",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
342 add("mdivide_right_tri_low",MATRIX_T,MATRIX_T,MATRIX_T);
343 add("mean",DOUBLE_T,expr_type(DOUBLE_T,1));
344 add("mean",DOUBLE_T,VECTOR_T);
345 add("mean",DOUBLE_T,ROW_VECTOR_T);
346 add("mean",DOUBLE_T,MATRIX_T);
347 add("min",INT_T,expr_type(INT_T,1));
348 add("min",DOUBLE_T,expr_type(DOUBLE_T,1));
349 add("min",DOUBLE_T,VECTOR_T);
350 add("min",DOUBLE_T,ROW_VECTOR_T);
351 add("min",DOUBLE_T,MATRIX_T);
352 add("min",INT_T,INT_T,INT_T);
353 add("minus",DOUBLE_T,DOUBLE_T);
354 add("minus",VECTOR_T,VECTOR_T);
355 add("minus",ROW_VECTOR_T,ROW_VECTOR_T);
356 add("minus",MATRIX_T,MATRIX_T);
357 add("multi_gp_log",DOUBLE_T,MATRIX_T,MATRIX_T,VECTOR_T);
358 add("multi_normal_cholesky_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
359 add("multi_normal_prec_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
360 add("multi_normal_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
361 add("multi_normal_rng",VECTOR_T,VECTOR_T,MATRIX_T);
362 add("multi_student_t_log",DOUBLE_T, VECTOR_T,DOUBLE_T,VECTOR_T,MATRIX_T);
363 add("multi_student_t_rng",VECTOR_T, DOUBLE_T,VECTOR_T,MATRIX_T);
364 add("multinomial_log",DOUBLE_T, expr_type(INT_T,1U), VECTOR_T);
365 add("multinomial_rng",expr_type(INT_T,1U), VECTOR_T, INT_T);
366 add("multiply",DOUBLE_T,DOUBLE_T,DOUBLE_T);
367 add("multiply",VECTOR_T,VECTOR_T,DOUBLE_T);
368 add("multiply",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
369 add("multiply",MATRIX_T,MATRIX_T,DOUBLE_T);
370 add("multiply",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
371 add("multiply",MATRIX_T,VECTOR_T,ROW_VECTOR_T);
372 add("multiply",VECTOR_T,MATRIX_T,VECTOR_T);
373 add("multiply",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
374 add("multiply",MATRIX_T,MATRIX_T,MATRIX_T);
375 add("multiply",VECTOR_T,DOUBLE_T,VECTOR_T);
376 add("multiply",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
377 add("multiply",MATRIX_T,DOUBLE_T,MATRIX_T);
378 add("multiply_lower_tri_self_transpose",MATRIX_T,MATRIX_T);
379 add("tcrossprod",MATRIX_T,MATRIX_T);
380 add("crossprod",MATRIX_T,MATRIX_T);
381 add_binary("multiply_log");
382 for (size_t i = 0; i < int_vector_types.size(); ++i)
383  for (size_t j = 0; j < vector_types.size(); ++j)
384  for (size_t k = 0; k < vector_types.size(); ++k)
385  add("neg_binomial_log",DOUBLE_T,int_vector_types[i],vector_types[j],vector_types[k]);
386 add("neg_binomial_rng",INT_T,DOUBLE_T,DOUBLE_T);
387 for (size_t i = 0; i < int_vector_types.size(); ++i)
388  for (size_t j = 0; j < vector_types.size(); ++j)
389  for (size_t k = 0; k < vector_types.size(); ++k)
390  add("neg_binomial_cdf",DOUBLE_T,int_vector_types[i],vector_types[j],vector_types[k]);
391 add_nullary("negative_epsilon");
392 add_nullary("negative_infinity");
393 add_binary("normal_rng");
394 add_ternary("normal_cdf"); // not vectorizing yet!
395 for (size_t i = 0; i < vector_types.size(); ++i)
396  for (size_t j = 0; j < vector_types.size(); ++j)
397  for (size_t k = 0; k < vector_types.size(); ++k)
398  add("normal_log",
399  DOUBLE_T, // result
400  vector_types[i], vector_types[j], vector_types[k]); // args
401 add_nullary("not_a_number");
402 add("ordered_logistic_log",DOUBLE_T,INT_T,DOUBLE_T,VECTOR_T);
403 add("ordered_logistic_rng",INT_T,DOUBLE_T,VECTOR_T);
404 add_binary("owens_t");
405 for (size_t i = 0; i < vector_types.size(); ++i)
406  for (size_t j = 0; j < vector_types.size(); ++j)
407  for (size_t k = 0; k < vector_types.size(); ++k)
408  add("pareto_log",
409  DOUBLE_T, // result
410  vector_types[i], vector_types[j], vector_types[k]); // args
411 for (size_t i = 0; i < vector_types.size(); ++i)
412  for (size_t j = 0; j < vector_types.size(); ++j)
413  for (size_t k = 0; k < vector_types.size(); ++k)
414  add("pareto_cdf",
415  DOUBLE_T, // result
416  vector_types[i], vector_types[j], vector_types[k]); // args
417 add_binary("pareto_rng");
418 add_unary("Phi");
419 add_unary("Phi_approx");
420 add_nullary("pi");
421 for (size_t i = 0; i < int_vector_types.size(); ++i)
422  for (size_t j = 0; j < vector_types.size(); ++j)
423  add("poisson_log",DOUBLE_T, int_vector_types[i],vector_types[j]);
424 add("poisson_rng",INT_T,DOUBLE_T);
425 for (size_t i = 0; i < int_vector_types.size(); ++i)
426  for (size_t j = 0; j < vector_types.size(); ++j)
427  add("poisson_cdf",DOUBLE_T, int_vector_types[i],vector_types[j]);
428 for (size_t i = 0; i < int_vector_types.size(); ++i)
429  for (size_t j = 0; j < vector_types.size(); ++j)
430  add("poisson_log_log",DOUBLE_T, int_vector_types[i],vector_types[j]);
431 add_nullary("positive_infinity");
432 add_binary("pow");
433 add("prod",INT_T,expr_type(INT_T,1));
434 add("prod",DOUBLE_T,expr_type(DOUBLE_T,1));
435 add("prod",DOUBLE_T,VECTOR_T);
436 add("prod",DOUBLE_T,ROW_VECTOR_T);
437 add("prod",DOUBLE_T,MATRIX_T);
438 for (size_t i = 0; i < base_types.size(); ++i) {
439  add("rep_array",expr_type(base_types[i],1), base_types[i], INT_T);
440  add("rep_array",expr_type(base_types[i],2), base_types[i], INT_T,INT_T);
441  add("rep_array",expr_type(base_types[i],3), base_types[i], INT_T,INT_T,INT_T);
442  for (size_t j = 1; j <= 3; ++j) {
443  add("rep_array",expr_type(base_types[i],j + 1), expr_type(base_types[i],j), INT_T);
444  add("rep_array",expr_type(base_types[i],j + 2), expr_type(base_types[i],j), INT_T,INT_T);
445  add("rep_array",expr_type(base_types[i],j + 3), expr_type(base_types[i],j), INT_T,INT_T,INT_T);
446  }
447 }
448 add("rep_matrix", MATRIX_T, DOUBLE_T, INT_T,INT_T);
449 add("rep_matrix", MATRIX_T, VECTOR_T, INT_T);
450 add("rep_matrix", MATRIX_T, ROW_VECTOR_T, INT_T);
451 add("rep_row_vector", ROW_VECTOR_T, DOUBLE_T, INT_T);
452 add("rep_vector", VECTOR_T, DOUBLE_T, INT_T);
453 add_unary("round");
454 add("row",ROW_VECTOR_T,MATRIX_T,INT_T);
455 add("rows",INT_T,VECTOR_T);
456 add("rows",INT_T,ROW_VECTOR_T);
457 add("rows",INT_T,MATRIX_T);
458 for (size_t i = 0; i < vector_types.size(); ++i)
459  for (size_t j = 0; j < vector_types.size(); ++j)
460  for (size_t k = 0; k < vector_types.size(); ++k)
461  add("scaled_inv_chi_square_log",
462  DOUBLE_T, // result
463  vector_types[i], vector_types[j], vector_types[k]); // args
464 for (size_t i = 0; i < vector_types.size(); ++i)
465  for (size_t j = 0; j < vector_types.size(); ++j)
466  for (size_t k = 0; k < vector_types.size(); ++k)
467  add("scaled_inv_chi_square_cdf",
468  DOUBLE_T, // result
469  vector_types[i], vector_types[j], vector_types[k]); // args
470 add_binary("scaled_inv_chi_square_rng");
471 add("sd",DOUBLE_T,expr_type(DOUBLE_T,1));
472 add("sd",DOUBLE_T,VECTOR_T);
473 add("sd",DOUBLE_T,ROW_VECTOR_T);
474 add("sd",DOUBLE_T,MATRIX_T);
475 add_unary("sin");
476 add("singular_values",VECTOR_T,MATRIX_T);
477 add_unary("sinh");
478 for (size_t i = 0; i < vector_types.size(); ++i) {
479  for (size_t j = 0; j < vector_types.size(); ++j) {
480  for (size_t k = 0; k < vector_types.size(); ++k) {
481  for (size_t l = 0; l < vector_types.size(); ++l) {
482  add("skew_normal_log",
483  DOUBLE_T, // result
484  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
485  add("skew_normal_cdf",
486  DOUBLE_T, // result
487  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
488  }
489  }
490  }
491 }
492 add_ternary("skew_normal_rng");
493 add("softmax",VECTOR_T,VECTOR_T);
494 add_unary("sqrt");
495 add_nullary("sqrt2");
496 add_unary("square");
497 add_unary("step");
498 for (size_t i = 0; i < vector_types.size(); ++i) {
499  for (size_t j = 0; j < vector_types.size(); ++j) {
500  for (size_t k = 0; k < vector_types.size(); ++k) {
501  for (size_t l = 0; l < vector_types.size(); ++l) {
502  add("student_t_log",
503  DOUBLE_T, // result
504  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
505  add("student_t_cdf",
506  DOUBLE_T, // result
507  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
508  }
509  }
510  }
511 }
512 add_ternary("student_t_rng");
513 add("subtract",VECTOR_T,VECTOR_T,VECTOR_T);
514 add("subtract",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
515 add("subtract",MATRIX_T,MATRIX_T,MATRIX_T);
516 add("subtract",VECTOR_T,VECTOR_T,DOUBLE_T);
517 add("subtract",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
518 add("subtract",MATRIX_T,MATRIX_T,DOUBLE_T);
519 add("subtract",VECTOR_T,DOUBLE_T,VECTOR_T);
520 add("subtract",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
521 add("subtract",MATRIX_T,DOUBLE_T,MATRIX_T);
522 add("sum",INT_T,expr_type(INT_T,1));
523 add("sum",DOUBLE_T,expr_type(DOUBLE_T,1));
524 add("sum",DOUBLE_T,VECTOR_T);
525 add("sum",DOUBLE_T,ROW_VECTOR_T);
526 add("sum",DOUBLE_T,MATRIX_T);
527 add_unary("tan");
528 add_unary("tanh");
529 add_unary("tgamma");
530 add("trace",DOUBLE_T,MATRIX_T);
531 add("transpose",ROW_VECTOR_T,VECTOR_T);
532 add("transpose",VECTOR_T,ROW_VECTOR_T);
533 add("transpose",MATRIX_T,MATRIX_T);
534 add_unary("trunc");
535 for (size_t i = 0; i < vector_types.size(); ++i)
536  for (size_t j = 0; j < vector_types.size(); ++j)
537  for (size_t k = 0; k < vector_types.size(); ++k)
538  add("uniform_log",
539  DOUBLE_T, // result
540  vector_types[i], vector_types[j], vector_types[k]); // args
541 add_binary("uniform_rng");
542 add("variance",DOUBLE_T,expr_type(DOUBLE_T,1));
543 add("variance",DOUBLE_T,VECTOR_T);
544 add("variance",DOUBLE_T,ROW_VECTOR_T);
545 add("variance",DOUBLE_T,MATRIX_T);
546 for (size_t i = 0; i < vector_types.size(); ++i)
547  for (size_t j = 0; j < vector_types.size(); ++j)
548  for (size_t k = 0; k < vector_types.size(); ++k)
549  add("weibull_log",
550  DOUBLE_T, // result
551  vector_types[i], vector_types[j], vector_types[k]); // args
552 add_ternary("weibull_cdf");
553 add_binary("weibull_rng");
554 add("wishart_log",DOUBLE_T, MATRIX_T,DOUBLE_T,MATRIX_T);
555 add("wishart_rng",MATRIX_T, DOUBLE_T,MATRIX_T);
556 
557 // dims() is polymorphic by size
558 for (size_t i = 0; i < 8; ++i) {
559  add("dims",expr_type(INT_T,1),expr_type(INT_T,i));
560  add("dims",expr_type(INT_T,1),expr_type(DOUBLE_T,i));
561  add("dims",expr_type(INT_T,1),expr_type(VECTOR_T,i));
562  add("dims",expr_type(INT_T,1),expr_type(ROW_VECTOR_T,i));
563  add("dims",expr_type(INT_T,1),expr_type(MATRIX_T,i));
564 }
565 // size() is polymorphic over arrays, so start i at 1
566 for (size_t i = 1; i < 8; ++i) {
567  add("size",INT_T,expr_type(INT_T,i));
568  add("size",INT_T,expr_type(DOUBLE_T,i));
569  add("size",INT_T,expr_type(VECTOR_T,i));
570  add("size",INT_T,expr_type(ROW_VECTOR_T,i));
571  add("size",INT_T,expr_type(MATRIX_T,i));
572 }
573 //------------------------------------------------------------
574 
575 add("trunc_normal_log",DOUBLE_T, DOUBLE_T,DOUBLE_T,DOUBLE_T,DOUBLE_T,DOUBLE_T);
576 
     [ Stan Home Page ] © 2011–2013, Stan Development Team.