Stan  1.0
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 add("binomial_log",DOUBLE_T,INT_T,INT_T,DOUBLE_T);
58 add("categorical_log",DOUBLE_T,INT_T,VECTOR_T);
59 for (size_t i = 0; i < vector_types.size(); ++i)
60  for (size_t j = 0; j < vector_types.size(); ++j)
61  for (size_t k = 0; k < vector_types.size(); ++k)
62  add("cauchy_log",
63  DOUBLE_T, // result
64  vector_types[i], vector_types[j], vector_types[k]); // args
65 add_unary("cbrt");
66 add_unary("ceil");
67 add("cholesky_decompose",MATRIX_T,MATRIX_T);
68 for (size_t i = 0; i < vector_types.size(); ++i)
69  for (size_t j = 0; j < vector_types.size(); ++j)
70  add("chi_square_log",
71  DOUBLE_T, // result
72  vector_types[i], vector_types[j]); // args
73 add("block",MATRIX_T,MATRIX_T,INT_T,INT_T,INT_T,INT_T);
74 add("col",VECTOR_T,MATRIX_T,INT_T);
75 add("cols",INT_T,VECTOR_T);
76 add("cols",INT_T,ROW_VECTOR_T);
77 add("cols",INT_T,MATRIX_T);
78 add_unary("cos");
79 add_unary("cosh");
80 add("cumulative_sum", expr_type(DOUBLE_T,1U), expr_type(DOUBLE_T,1U));
81 add("cumulative_sum", VECTOR_T, VECTOR_T);
82 add("cumulative_sum", ROW_VECTOR_T, ROW_VECTOR_T);
83 add("determinant",DOUBLE_T,MATRIX_T);
84 add("diagonal",VECTOR_T,MATRIX_T);
85 add("diag_matrix",MATRIX_T,VECTOR_T);
86 add("dirichlet_log",DOUBLE_T,VECTOR_T,VECTOR_T);
87 add("divide",DOUBLE_T,DOUBLE_T,DOUBLE_T);
88 add("divide",VECTOR_T,VECTOR_T,DOUBLE_T);
89 add("divide",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
90 add("divide",MATRIX_T,MATRIX_T,DOUBLE_T);
91 add("dot_product",DOUBLE_T,VECTOR_T,VECTOR_T);
92 add("dot_product",DOUBLE_T,ROW_VECTOR_T,ROW_VECTOR_T);
93 add("dot_product",DOUBLE_T,VECTOR_T,ROW_VECTOR_T);
94 add("dot_product",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
95 add("dot_product",DOUBLE_T,expr_type(DOUBLE_T,1U),expr_type(DOUBLE_T,1U)); // vectorized
96 add("dot_self",DOUBLE_T,VECTOR_T);
97 add("dot_self",DOUBLE_T,ROW_VECTOR_T);
98 for (size_t i = 0; i < vector_types.size(); ++i)
99  for (size_t j = 0; j < vector_types.size(); ++j)
100  for (size_t k = 0; k < vector_types.size(); ++k)
101  add("double_exponential_log",
102  DOUBLE_T, // result
103  vector_types[i], vector_types[j], vector_types[k]); // args
104 add_nullary("e");
105 add("eigenvalues_sym",VECTOR_T,MATRIX_T);
106 add("eigenvectors_sym",MATRIX_T,MATRIX_T);
107 add("elt_divide",VECTOR_T,VECTOR_T,VECTOR_T);
108 add("elt_divide",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
109 add("elt_divide",MATRIX_T,MATRIX_T,MATRIX_T);
110 add("elt_multiply",VECTOR_T,VECTOR_T,VECTOR_T);
111 add("elt_multiply",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
112 add("elt_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
113 add("diag_pre_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
114 add("diag_pre_multiply",MATRIX_T,VECTOR_T,MATRIX_T);
115 add("diag_pre_multiply",MATRIX_T,ROW_VECTOR_T,MATRIX_T);
116 add("diag_post_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
117 add("diag_post_multiply",MATRIX_T,MATRIX_T,VECTOR_T);
118 add("diag_post_multiply",MATRIX_T,MATRIX_T,ROW_VECTOR_T);
119 add_nullary("epsilon");
120 add_unary("erf");
121 add_unary("erfc");
122 add_unary("exp");
123 add("exp",VECTOR_T,VECTOR_T);
124 add("exp",ROW_VECTOR_T,ROW_VECTOR_T);
125 add("exp",MATRIX_T,MATRIX_T);
126 add_unary("exp2");
127 add_unary("expm1");
128 for (size_t i = 0; i < vector_types.size(); ++i)
129  for (size_t j = 0; j < vector_types.size(); ++j)
130  add("exponential_log",
131  DOUBLE_T, // result
132  vector_types[i], vector_types[j]); // args
133 add_binary("exponential_cdf");
134 add_unary("fabs");
135 add_binary("fdim");
136 add_unary("floor");
137 add_ternary("fma");
138 add_binary("fmax");
139 add_binary("fmin");
140 add_binary("fmod");
141 for (size_t i = 0; i < vector_types.size(); ++i)
142  for (size_t j = 0; j < vector_types.size(); ++j)
143  for (size_t k = 0; k < vector_types.size(); ++k)
144  add("gamma_log",
145  DOUBLE_T, // result
146  vector_types[i], vector_types[j], vector_types[k]); // args
147 //FIXME: add_ternary("gamma_cdf");
148 add("hypergeometric_log",DOUBLE_T, INT_T, INT_T, INT_T, INT_T);
149 add_binary("hypot");
150 add("if_else",DOUBLE_T,INT_T,DOUBLE_T,DOUBLE_T);
151 add("int_step",INT_T,DOUBLE_T);
152 add("int_step",INT_T,INT_T);
153 for (size_t i = 0; i < vector_types.size(); ++i)
154  for (size_t j = 0; j < vector_types.size(); ++j)
155  add("inv_chi_square_log",
156  DOUBLE_T, // result
157  vector_types[i], vector_types[j]); // args
158 add_unary("inv_cloglog");
159 for (size_t i = 0; i < vector_types.size(); ++i)
160  for (size_t j = 0; j < vector_types.size(); ++j)
161  for (size_t k = 0; k < vector_types.size(); ++k)
162  add("inv_gamma_log",
163  DOUBLE_T, // result
164  vector_types[i], vector_types[j], vector_types[k]); // args
165 add_unary("inv_logit");
166 add("inv_wishart_log",DOUBLE_T, MATRIX_T,DOUBLE_T,MATRIX_T);
167 add("inverse",MATRIX_T,MATRIX_T);
168 add_binary("lbeta");
169 add_unary("lgamma");
170 add("lkj_corr_cholesky_log",DOUBLE_T, MATRIX_T,DOUBLE_T);
171 add("lkj_corr_log",DOUBLE_T, MATRIX_T,DOUBLE_T);
172 add("lkj_cov_log",DOUBLE_T, MATRIX_T,VECTOR_T,VECTOR_T,DOUBLE_T);
173 add("lmgamma",DOUBLE_T,INT_T,DOUBLE_T);
174 for (size_t i = 0; i < primitive_types.size(); ++i) {
175  add("logical_negation",INT_T,primitive_types[i]);
176  for (size_t j = 0; j < primitive_types.size(); ++j) {
177  add("logical_or",INT_T,primitive_types[i], primitive_types[j]);
178  add("logical_and",INT_T,primitive_types[i], primitive_types[j]);
179  add("logical_eq",INT_T,primitive_types[i], primitive_types[j]);
180  add("logical_neq",INT_T,primitive_types[i], primitive_types[j]);
181  add("logical_lt",INT_T,primitive_types[i], primitive_types[j]);
182  add("logical_lte",INT_T,primitive_types[i], primitive_types[j]);
183  add("logical_gt",INT_T,primitive_types[i], primitive_types[j]);
184  add("logical_gte",INT_T,primitive_types[i], primitive_types[j]);
185  }
186 }
187 add_unary("log");
188 add("log",VECTOR_T,VECTOR_T);
189 add("log",ROW_VECTOR_T,ROW_VECTOR_T);
190 add("log",MATRIX_T,MATRIX_T);
191 add("log_sum_exp",DOUBLE_T, expr_type(DOUBLE_T,1U));
192 add_binary("log_sum_exp");
193 add_nullary("log10");
194 add_unary("log10");
195 add_unary("log1m");
196 add_unary("log1p");
197 add_unary("log1p_exp");
198 add_unary("log_inv_logit");
199 add_unary("log1m_inv_logit");
200 add_nullary("log2");
201 add_unary("log2");
202 for (size_t i = 0; i < vector_types.size(); ++i)
203  for (size_t j = 0; j < vector_types.size(); ++j)
204  for (size_t k = 0; k < vector_types.size(); ++k)
205  add("logistic_log",
206  DOUBLE_T, // result
207  vector_types[i], vector_types[j], vector_types[k]); // args
208 add_unary("logit");
209 add_ternary("lognormal_cdf");
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("lognormal_log",
214  DOUBLE_T, // result
215  vector_types[i], vector_types[j], vector_types[k]); // args
216 add("max",INT_T,expr_type(INT_T,1));
217 add("max",DOUBLE_T,expr_type(DOUBLE_T,1));
218 add("max",DOUBLE_T,VECTOR_T);
219 add("max",DOUBLE_T,ROW_VECTOR_T);
220 add("max",DOUBLE_T,MATRIX_T);
221 add("max",INT_T,INT_T,INT_T);
222 add("mdivide_left",VECTOR_T,MATRIX_T,VECTOR_T);
223 add("mdivide_left",MATRIX_T,MATRIX_T,MATRIX_T);
224 add("mdivide_right",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
225 add("mdivide_right",MATRIX_T,MATRIX_T,MATRIX_T);
226 add("mdivide_left_tri_low",MATRIX_T,MATRIX_T,MATRIX_T);
227 add("mdivide_left_tri_low",VECTOR_T,MATRIX_T,VECTOR_T);
228 add("mdivide_right_tri_low",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
229 add("mdivide_right_tri_low",MATRIX_T,MATRIX_T,MATRIX_T);
230 add("mean",DOUBLE_T,expr_type(DOUBLE_T,1));
231 add("mean",DOUBLE_T,VECTOR_T);
232 add("mean",DOUBLE_T,ROW_VECTOR_T);
233 add("mean",DOUBLE_T,MATRIX_T);
234 add("min",INT_T,expr_type(INT_T,1));
235 add("min",DOUBLE_T,expr_type(DOUBLE_T,1));
236 add("min",DOUBLE_T,VECTOR_T);
237 add("min",DOUBLE_T,ROW_VECTOR_T);
238 add("min",DOUBLE_T,MATRIX_T);
239 add("min",INT_T,INT_T,INT_T);
240 add("minus",DOUBLE_T,DOUBLE_T);
241 add("minus",VECTOR_T,VECTOR_T);
242 add("minus",ROW_VECTOR_T,ROW_VECTOR_T);
243 add("minus",MATRIX_T,MATRIX_T);
244 add("multi_normal_cholesky_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
245 add("multi_normal_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
246 add("multi_student_t_log",DOUBLE_T, VECTOR_T,DOUBLE_T,VECTOR_T,MATRIX_T);
247 add("multinomial_log",DOUBLE_T, expr_type(INT_T,1U), VECTOR_T);
248 add("multiply",DOUBLE_T,DOUBLE_T,DOUBLE_T);
249 add("multiply",VECTOR_T,VECTOR_T,DOUBLE_T);
250 add("multiply",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
251 add("multiply",MATRIX_T,MATRIX_T,DOUBLE_T);
252 add("multiply",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
253 add("multiply",MATRIX_T,VECTOR_T,ROW_VECTOR_T);
254 add("multiply",VECTOR_T,MATRIX_T,VECTOR_T);
255 add("multiply",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
256 add("multiply",MATRIX_T,MATRIX_T,MATRIX_T);
257 add("multiply",VECTOR_T,DOUBLE_T,VECTOR_T);
258 add("multiply",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
259 add("multiply",MATRIX_T,DOUBLE_T,MATRIX_T);
260 add("multiply_lower_tri_self_transpose",MATRIX_T,MATRIX_T);
261 add("tcrossprod",MATRIX_T,MATRIX_T);
262 add("crossprod",MATRIX_T,MATRIX_T);
263 add_binary("multiply_log");
264 for (size_t i = 0; i < int_vector_types.size(); ++i)
265  for (size_t j = 0; j < vector_types.size(); ++j)
266  for (size_t k = 0; k < vector_types.size(); ++k)
267  add("neg_binomial_log",DOUBLE_T,int_vector_types[i],vector_types[j],vector_types[k]);
268 add_nullary("negative_epsilon");
269 add_nullary("negative_infinity");
270 add_ternary("normal_cdf"); // not vectorizing yet!
271 for (size_t i = 0; i < vector_types.size(); ++i)
272  for (size_t j = 0; j < vector_types.size(); ++j)
273  for (size_t k = 0; k < vector_types.size(); ++k)
274  add("normal_log",
275  DOUBLE_T, // result
276  vector_types[i], vector_types[j], vector_types[k]); // args
277 add_nullary("not_a_number");
278 add("ordered_logistic_log",DOUBLE_T,INT_T,DOUBLE_T,VECTOR_T);
279 for (size_t i = 0; i < vector_types.size(); ++i)
280  for (size_t j = 0; j < vector_types.size(); ++j)
281  for (size_t k = 0; k < vector_types.size(); ++k)
282  add("pareto_log",
283  DOUBLE_T, // result
284  vector_types[i], vector_types[j], vector_types[k]); // args
285 add_unary("Phi");
286 add_nullary("pi");
287 for (size_t i = 0; i < int_vector_types.size(); ++i) {
288  for (size_t j = 0; j < vector_types.size(); ++j) {
289  add("poisson_log",DOUBLE_T, int_vector_types[i],vector_types[j]);
290  add("poisson_log_log",DOUBLE_T, int_vector_types[i],vector_types[j]);
291  }
292  }
293 add_nullary("positive_infinity");
294 add_binary("pow");
295 add("prod",INT_T,expr_type(INT_T,1));
296 add("prod",DOUBLE_T,expr_type(DOUBLE_T,1));
297 add("prod",DOUBLE_T,VECTOR_T);
298 add("prod",DOUBLE_T,ROW_VECTOR_T);
299 add("prod",DOUBLE_T,MATRIX_T);
300 add_unary("round");
301 add("row",ROW_VECTOR_T,MATRIX_T,INT_T);
302 add("rows",INT_T,VECTOR_T);
303 add("rows",INT_T,ROW_VECTOR_T);
304 add("rows",INT_T,MATRIX_T);
305 for (size_t i = 0; i < vector_types.size(); ++i)
306  for (size_t j = 0; j < vector_types.size(); ++j)
307  for (size_t k = 0; k < vector_types.size(); ++k)
308  add("scaled_inv_chi_square_log",
309  DOUBLE_T, // result
310  vector_types[i], vector_types[j], vector_types[k]); // args
311 add("sd",DOUBLE_T,expr_type(DOUBLE_T,1));
312 add("sd",DOUBLE_T,VECTOR_T);
313 add("sd",DOUBLE_T,ROW_VECTOR_T);
314 add("sd",DOUBLE_T,MATRIX_T);
315 add_unary("sin");
316 add("singular_values",VECTOR_T,MATRIX_T);
317 add_unary("sinh");
318 add("softmax",VECTOR_T,VECTOR_T);
319 add_unary("sqrt");
320 add_nullary("sqrt2");
321 add_unary("square");
322 add_unary("step");
323 for (size_t i = 0; i < vector_types.size(); ++i)
324  for (size_t j = 0; j < vector_types.size(); ++j)
325  for (size_t k = 0; k < vector_types.size(); ++k)
326  for (size_t l = 0; l < vector_types.size(); ++l)
327  add("student_t_log",
328  DOUBLE_T, // result
329  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
330 add("subtract",VECTOR_T,VECTOR_T,VECTOR_T);
331 add("subtract",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
332 add("subtract",MATRIX_T,MATRIX_T,MATRIX_T);
333 add("subtract",VECTOR_T,VECTOR_T,DOUBLE_T);
334 add("subtract",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
335 add("subtract",MATRIX_T,MATRIX_T,DOUBLE_T);
336 add("subtract",VECTOR_T,DOUBLE_T,VECTOR_T);
337 add("subtract",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
338 add("subtract",MATRIX_T,DOUBLE_T,MATRIX_T);
339 add("sum",INT_T,expr_type(INT_T,1));
340 add("sum",DOUBLE_T,expr_type(DOUBLE_T,1));
341 add("sum",DOUBLE_T,VECTOR_T);
342 add("sum",DOUBLE_T,ROW_VECTOR_T);
343 add("sum",DOUBLE_T,MATRIX_T);
344 add_unary("tan");
345 add_unary("tanh");
346 add_unary("tgamma");
347 add("trace",DOUBLE_T,MATRIX_T);
348 add("transpose",ROW_VECTOR_T,VECTOR_T);
349 add("transpose",VECTOR_T,ROW_VECTOR_T);
350 add("transpose",MATRIX_T,MATRIX_T);
351 add_unary("trunc");
352 for (size_t i = 0; i < vector_types.size(); ++i)
353  for (size_t j = 0; j < vector_types.size(); ++j)
354  for (size_t k = 0; k < vector_types.size(); ++k)
355  add("uniform_log",
356  DOUBLE_T, // result
357  vector_types[i], vector_types[j], vector_types[k]); // args
358 add("variance",DOUBLE_T,expr_type(DOUBLE_T,1));
359 add("variance",DOUBLE_T,VECTOR_T);
360 add("variance",DOUBLE_T,ROW_VECTOR_T);
361 add("variance",DOUBLE_T,MATRIX_T);
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("weibull_log",
366  DOUBLE_T, // result
367  vector_types[i], vector_types[j], vector_types[k]); // args
368 add_ternary("weibull_cdf");
369 add("wishart_log",DOUBLE_T, MATRIX_T,DOUBLE_T,MATRIX_T);
370 
371 //------------------------------------------------------------
372 
373 add("trunc_normal_log",DOUBLE_T, DOUBLE_T,DOUBLE_T,DOUBLE_T,DOUBLE_T,DOUBLE_T);
     [ Stan Home Page ] © 2011–2012, Stan Development Team.