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 
10 add_unary("abs");
11 add("abs",INT_T,INT_T);
12 add_unary("acos");
13 add_unary("acosh");
14 add("add",VECTOR_T,VECTOR_T,VECTOR_T);
15 add("add",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
16 add("add",MATRIX_T,MATRIX_T,MATRIX_T);
17 add("add",VECTOR_T,VECTOR_T,DOUBLE_T);
18 add("add",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
19 add("add",MATRIX_T,MATRIX_T,DOUBLE_T);
20 add("add",VECTOR_T,DOUBLE_T,VECTOR_T);
21 add("add",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
22 add("add",MATRIX_T,DOUBLE_T,MATRIX_T);
23 add_unary("asin");
24 add_unary("asinh");
25 add_unary("atan");
26 add_binary("atan2");
27 add_unary("atanh");
28 for (size_t i = 0; i < vector_types.size(); ++i) {
29  add("bernoulli_log",DOUBLE_T,INT_T,vector_types[i]);
30  add("bernoulli_log",DOUBLE_T,expr_type(INT_T,1U),vector_types[i]);
31 }
32 for (size_t i = 0; i < vector_types.size(); ++i) {
33  add("bernoulli_logit_log",DOUBLE_T,INT_T,vector_types[i]);
34  add("bernoulli_logit_log",DOUBLE_T,expr_type(INT_T,1U),vector_types[i]);
35 }
36 add("beta_binomial_log",DOUBLE_T,INT_T,INT_T,DOUBLE_T,DOUBLE_T);
37 for (size_t i = 0; i < vector_types.size(); ++i)
38  for (size_t j = 0; j < vector_types.size(); ++j)
39  for (size_t k = 0; k < vector_types.size(); ++k)
40  add("beta_log",
41  DOUBLE_T, // result
42  vector_types[i], vector_types[j], vector_types[k]); // args
43 add("binary_log_loss",DOUBLE_T,INT_T,DOUBLE_T);
44 add_binary("binomial_coefficient_log");
45 add("binomial_log",DOUBLE_T,INT_T,INT_T,DOUBLE_T);
46 add("categorical_log",DOUBLE_T,INT_T,VECTOR_T);
47 for (size_t i = 0; i < vector_types.size(); ++i)
48  for (size_t j = 0; j < vector_types.size(); ++j)
49  for (size_t k = 0; k < vector_types.size(); ++k)
50  add("cauchy_log",
51  DOUBLE_T, // result
52  vector_types[i], vector_types[j], vector_types[k]); // args
53 add_unary("cbrt");
54 add_unary("ceil");
55 add("cholesky_decompose",MATRIX_T,MATRIX_T);
56 for (size_t i = 0; i < vector_types.size(); ++i)
57  for (size_t j = 0; j < vector_types.size(); ++j)
58  add("chi_square_log",
59  DOUBLE_T, // result
60  vector_types[i], vector_types[j]); // args
61 add("col",VECTOR_T,MATRIX_T,INT_T);
62 add("cols",INT_T,VECTOR_T);
63 add("cols",INT_T,ROW_VECTOR_T);
64 add("cols",INT_T,MATRIX_T);
65 add_unary("cos");
66 add_unary("cosh");
67 add("determinant",DOUBLE_T,MATRIX_T);
68 add("diagonal",VECTOR_T,MATRIX_T);
69 add("diag_matrix",MATRIX_T,VECTOR_T);
70 add("dirichlet_log",DOUBLE_T,VECTOR_T,VECTOR_T);
71 add("divide",DOUBLE_T,DOUBLE_T,DOUBLE_T);
72 add("divide",VECTOR_T,VECTOR_T,DOUBLE_T);
73 add("divide",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
74 add("divide",MATRIX_T,MATRIX_T,DOUBLE_T);
75 add("dot_product",DOUBLE_T,VECTOR_T,VECTOR_T);
76 add("dot_product",DOUBLE_T,ROW_VECTOR_T,ROW_VECTOR_T);
77 add("dot_product",DOUBLE_T,VECTOR_T,ROW_VECTOR_T);
78 add("dot_product",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
79 add("dot_product",DOUBLE_T,expr_type(DOUBLE_T,1U),expr_type(DOUBLE_T,1U)); // vectorized
80 add("dot_self",DOUBLE_T,VECTOR_T);
81 add("dot_self",DOUBLE_T,ROW_VECTOR_T);
82 for (size_t i = 0; i < vector_types.size(); ++i)
83  for (size_t j = 0; j < vector_types.size(); ++j)
84  for (size_t k = 0; k < vector_types.size(); ++k)
85  add("double_exponential_log",
86  DOUBLE_T, // result
87  vector_types[i], vector_types[j], vector_types[k]); // args
88 add_nullary("e");
89 add("eigenvalues",VECTOR_T,MATRIX_T);
90 add("eigenvalues_sym",VECTOR_T,MATRIX_T);
91 add("eigenvectors",MATRIX_T,MATRIX_T);
92 add("eigenvectors_sym",MATRIX_T,MATRIX_T);
93 add("elt_divide",VECTOR_T,VECTOR_T,VECTOR_T);
94 add("elt_divide",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
95 add("elt_divide",MATRIX_T,MATRIX_T,MATRIX_T);
96 add("elt_multiply",VECTOR_T,VECTOR_T,VECTOR_T);
97 add("elt_multiply",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
98 add("elt_multiply",MATRIX_T,MATRIX_T,MATRIX_T);
99 add_nullary("epsilon");
100 add_unary("erf");
101 add_unary("erfc");
102 add_unary("exp");
103 add("exp",VECTOR_T,VECTOR_T);
104 add("exp",ROW_VECTOR_T,ROW_VECTOR_T);
105 add("exp",MATRIX_T,MATRIX_T);
106 add_unary("exp2");
107 add_unary("expm1");
108 for (size_t i = 0; i < vector_types.size(); ++i)
109  for (size_t j = 0; j < vector_types.size(); ++j)
110  add("exponential_log",
111  DOUBLE_T, // result
112  vector_types[i], vector_types[j]); // args
113 add_binary("exponential_cdf");
114 add_unary("fabs");
115 add_binary("fdim");
116 add_unary("floor");
117 add_ternary("fma");
118 add_binary("fmax");
119 add_binary("fmin");
120 add_binary("fmod");
121 for (size_t i = 0; i < vector_types.size(); ++i)
122  for (size_t j = 0; j < vector_types.size(); ++j)
123  for (size_t k = 0; k < vector_types.size(); ++k)
124  add("gamma_log",
125  DOUBLE_T, // result
126  vector_types[i], vector_types[j], vector_types[k]); // args
127 //FIXME: add_ternary("gamma_cdf");
128 add("hypergeometric_log",DOUBLE_T, INT_T, INT_T, INT_T, INT_T);
129 add_binary("hypot");
130 add("if_else",DOUBLE_T,INT_T,DOUBLE_T,DOUBLE_T);
131 add("int_step",INT_T,DOUBLE_T);
132 add("int_step",INT_T,INT_T);
133 for (size_t i = 0; i < vector_types.size(); ++i)
134  for (size_t j = 0; j < vector_types.size(); ++j)
135  add("inv_chi_square_log",
136  DOUBLE_T, // result
137  vector_types[i], vector_types[j]); // args
138 add_unary("inv_cloglog");
139 for (size_t i = 0; i < vector_types.size(); ++i)
140  for (size_t j = 0; j < vector_types.size(); ++j)
141  for (size_t k = 0; k < vector_types.size(); ++k)
142  add("inv_gamma_log",
143  DOUBLE_T, // result
144  vector_types[i], vector_types[j], vector_types[k]); // args
145 add_unary("inv_logit");
146 add("inv_wishart_log",DOUBLE_T, MATRIX_T,DOUBLE_T,MATRIX_T);
147 add("inverse",MATRIX_T,MATRIX_T);
148 add_binary("lbeta");
149 add_unary("lgamma");
150 add("lkj_corr_cholesky_log",DOUBLE_T, MATRIX_T,DOUBLE_T);
151 add("lkj_corr_log",DOUBLE_T, MATRIX_T,DOUBLE_T);
152 add("lkj_cov_log",DOUBLE_T, MATRIX_T,VECTOR_T,VECTOR_T,DOUBLE_T);
153 add("lmgamma",DOUBLE_T,INT_T,DOUBLE_T);
154 add_unary("log");
155 add("log",VECTOR_T,VECTOR_T);
156 add("log",ROW_VECTOR_T,ROW_VECTOR_T);
157 add("log",MATRIX_T,MATRIX_T);
158 add("log_sum_exp",DOUBLE_T, expr_type(DOUBLE_T,1U));
159 add_binary("log_sum_exp");
160 add_nullary("log10");
161 add_unary("log10");
162 add_unary("log1m");
163 add_unary("log1p");
164 add_unary("log1p_exp");
165 add_nullary("log2");
166 add_unary("log2");
167 for (size_t i = 0; i < vector_types.size(); ++i)
168  for (size_t j = 0; j < vector_types.size(); ++j)
169  for (size_t k = 0; k < vector_types.size(); ++k)
170  add("logistic_log",
171  DOUBLE_T, // result
172  vector_types[i], vector_types[j], vector_types[k]); // args
173 add_unary("logit");
174 add_ternary("lognormal_cdf");
175 for (size_t i = 0; i < vector_types.size(); ++i)
176  for (size_t j = 0; j < vector_types.size(); ++j)
177  for (size_t k = 0; k < vector_types.size(); ++k)
178  add("lognormal_log",
179  DOUBLE_T, // result
180  vector_types[i], vector_types[j], vector_types[k]); // args
181 add("max",INT_T,expr_type(INT_T,1));
182 add("max",DOUBLE_T,expr_type(DOUBLE_T,1));
183 add("max",DOUBLE_T,VECTOR_T);
184 add("max",DOUBLE_T,ROW_VECTOR_T);
185 add("max",DOUBLE_T,MATRIX_T);
186 add("max",INT_T,INT_T,INT_T);
187 add("mdivide_left",VECTOR_T,MATRIX_T,VECTOR_T);
188 add("mdivide_left",MATRIX_T,MATRIX_T,MATRIX_T);
189 add("mdivide_right",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
190 add("mdivide_right",MATRIX_T,MATRIX_T,MATRIX_T);
191 add("mdivide_left_tri_low",MATRIX_T,MATRIX_T,MATRIX_T);
192 add("mdivide_left_tri_low",VECTOR_T,MATRIX_T,VECTOR_T);
193 add("mdivide_right_tri_low",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
194 add("mdivide_right_tri_low",MATRIX_T,MATRIX_T,MATRIX_T);
195 add("mean",DOUBLE_T,expr_type(DOUBLE_T,1));
196 add("mean",DOUBLE_T,VECTOR_T);
197 add("mean",DOUBLE_T,ROW_VECTOR_T);
198 add("mean",DOUBLE_T,MATRIX_T);
199 add("min",INT_T,expr_type(INT_T,1));
200 add("min",DOUBLE_T,expr_type(DOUBLE_T,1));
201 add("min",DOUBLE_T,VECTOR_T);
202 add("min",DOUBLE_T,ROW_VECTOR_T);
203 add("min",DOUBLE_T,MATRIX_T);
204 add("min",INT_T,INT_T,INT_T);
205 add("minus",DOUBLE_T,DOUBLE_T);
206 add("minus",VECTOR_T,VECTOR_T);
207 add("minus",ROW_VECTOR_T,ROW_VECTOR_T);
208 add("minus",MATRIX_T,MATRIX_T);
209 add("multi_normal_cholesky_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
210 add("multi_normal_log",DOUBLE_T, VECTOR_T,VECTOR_T,MATRIX_T);
211 add("multi_student_t_log",DOUBLE_T, VECTOR_T,DOUBLE_T,VECTOR_T,MATRIX_T);
212 add("multinomial_log",DOUBLE_T, expr_type(INT_T,1U), VECTOR_T);
213 add("multiply",DOUBLE_T,DOUBLE_T,DOUBLE_T);
214 add("multiply",VECTOR_T,VECTOR_T,DOUBLE_T);
215 add("multiply",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
216 add("multiply",MATRIX_T,MATRIX_T,DOUBLE_T);
217 add("multiply",DOUBLE_T,ROW_VECTOR_T,VECTOR_T);
218 add("multiply",MATRIX_T,VECTOR_T,ROW_VECTOR_T);
219 add("multiply",VECTOR_T,MATRIX_T,VECTOR_T);
220 add("multiply",ROW_VECTOR_T,ROW_VECTOR_T,MATRIX_T);
221 add("multiply",MATRIX_T,MATRIX_T,MATRIX_T);
222 add("multiply",VECTOR_T,DOUBLE_T,VECTOR_T);
223 add("multiply",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
224 add("multiply",MATRIX_T,DOUBLE_T,MATRIX_T);
225 add("multiply_lower_tri_self_transpose",MATRIX_T,MATRIX_T);
226 add("tcrossprod",MATRIX_T,MATRIX_T);
227 add("crossprod",MATRIX_T,MATRIX_T);
228 add_binary("multiply_log");
229 add("neg_binomial_log",DOUBLE_T, INT_T,DOUBLE_T,DOUBLE_T);
230 add_nullary("negative_epsilon");
231 add_nullary("negative_infinity");
232 add_ternary("normal_cdf"); // not vectorizing yet!
233 for (size_t i = 0; i < vector_types.size(); ++i)
234  for (size_t j = 0; j < vector_types.size(); ++j)
235  for (size_t k = 0; k < vector_types.size(); ++k)
236  add("normal_log",
237  DOUBLE_T, // result
238  vector_types[i], vector_types[j], vector_types[k]); // args
239 add_nullary("not_a_number");
240 add("ordered_logistic_log",DOUBLE_T,INT_T,DOUBLE_T,VECTOR_T);
241 for (size_t i = 0; i < vector_types.size(); ++i)
242  for (size_t j = 0; j < vector_types.size(); ++j)
243  for (size_t k = 0; k < vector_types.size(); ++k)
244  add("pareto_log",
245  DOUBLE_T, // result
246  vector_types[i], vector_types[j], vector_types[k]); // args
247 add_unary("Phi");
248 add_nullary("pi");
249 add("poisson_log",DOUBLE_T, INT_T,DOUBLE_T);
250 add_nullary("positive_infinity");
251 add_binary("pow");
252 
253 add("prod",INT_T,expr_type(INT_T,1));
254 add("prod",DOUBLE_T,expr_type(DOUBLE_T,1));
255 add("prod",DOUBLE_T,VECTOR_T);
256 add("prod",DOUBLE_T,ROW_VECTOR_T);
257 add("prod",DOUBLE_T,MATRIX_T);
258 add_unary("round");
259 add("row",ROW_VECTOR_T,MATRIX_T,INT_T);
260 add("rows",INT_T,VECTOR_T);
261 add("rows",INT_T,ROW_VECTOR_T);
262 add("rows",INT_T,MATRIX_T);
263 for (size_t i = 0; i < vector_types.size(); ++i)
264  for (size_t j = 0; j < vector_types.size(); ++j)
265  for (size_t k = 0; k < vector_types.size(); ++k)
266  add("scaled_inv_chi_square_log",
267  DOUBLE_T, // result
268  vector_types[i], vector_types[j], vector_types[k]); // args
269 add("sd",DOUBLE_T,expr_type(DOUBLE_T,1));
270 add("sd",DOUBLE_T,VECTOR_T);
271 add("sd",DOUBLE_T,ROW_VECTOR_T);
272 add("sd",DOUBLE_T,MATRIX_T);
273 add_unary("sin");
274 add("singular_values",VECTOR_T,MATRIX_T);
275 add_unary("sinh");
276 add("softmax",VECTOR_T,VECTOR_T);
277 add_unary("sqrt");
278 add_nullary("sqrt2");
279 add_unary("square");
280 add_unary("step");
281 for (size_t i = 0; i < vector_types.size(); ++i)
282  for (size_t j = 0; j < vector_types.size(); ++j)
283  for (size_t k = 0; k < vector_types.size(); ++k)
284  for (size_t l = 0; l < vector_types.size(); ++l)
285  add("student_t_log",
286  DOUBLE_T, // result
287  vector_types[i], vector_types[j], vector_types[k], vector_types[l]); // args
288 add("subtract",VECTOR_T,VECTOR_T,VECTOR_T);
289 add("subtract",ROW_VECTOR_T,ROW_VECTOR_T,ROW_VECTOR_T);
290 add("subtract",MATRIX_T,MATRIX_T,MATRIX_T);
291 add("subtract",VECTOR_T,VECTOR_T,DOUBLE_T);
292 add("subtract",ROW_VECTOR_T,ROW_VECTOR_T,DOUBLE_T);
293 add("subtract",MATRIX_T,MATRIX_T,DOUBLE_T);
294 add("subtract",VECTOR_T,DOUBLE_T,VECTOR_T);
295 add("subtract",ROW_VECTOR_T,DOUBLE_T,ROW_VECTOR_T);
296 add("subtract",MATRIX_T,DOUBLE_T,MATRIX_T);
297 add("sum",INT_T,expr_type(INT_T,1));
298 add("sum",DOUBLE_T,expr_type(DOUBLE_T,1));
299 add("sum",DOUBLE_T,VECTOR_T);
300 add("sum",DOUBLE_T,ROW_VECTOR_T);
301 add("sum",DOUBLE_T,MATRIX_T);
302 add_unary("tan");
303 add_unary("tanh");
304 add_unary("tgamma");
305 add("trace",DOUBLE_T,MATRIX_T);
306 add("transpose",ROW_VECTOR_T,VECTOR_T);
307 add("transpose",VECTOR_T,ROW_VECTOR_T);
308 add("transpose",MATRIX_T,MATRIX_T);
309 add_unary("trunc");
310 for (size_t i = 0; i < vector_types.size(); ++i)
311  for (size_t j = 0; j < vector_types.size(); ++j)
312  for (size_t k = 0; k < vector_types.size(); ++k)
313  add("uniform_log",
314  DOUBLE_T, // result
315  vector_types[i], vector_types[j], vector_types[k]); // args
316 add("variance",DOUBLE_T,expr_type(DOUBLE_T,1));
317 add("variance",DOUBLE_T,VECTOR_T);
318 add("variance",DOUBLE_T,ROW_VECTOR_T);
319 add("variance",DOUBLE_T,MATRIX_T);
320 for (size_t i = 0; i < vector_types.size(); ++i)
321  for (size_t j = 0; j < vector_types.size(); ++j)
322  for (size_t k = 0; k < vector_types.size(); ++k)
323  add("weibull_log",
324  DOUBLE_T, // result
325  vector_types[i], vector_types[j], vector_types[k]); // args
326 add_ternary("weibull_cdf");
327 add("wishart_log",DOUBLE_T, MATRIX_T,DOUBLE_T,MATRIX_T);
328 
329 //------------------------------------------------------------
330 
331 add("trunc_normal_log",DOUBLE_T, DOUBLE_T,DOUBLE_T,DOUBLE_T,DOUBLE_T,DOUBLE_T);
     [ Stan Home Page ] © 2011–2012, Stan Development Team.