Stan  2.5.0
probability, sampling & optimization
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
inv_gamma.hpp
Go to the documentation of this file.
1 #ifndef STAN__PROB__DISTRIBUTIONS__UNIVARIATE__CONTINUOUS__INV_GAMMA_HPP
2 #define STAN__PROB__DISTRIBUTIONS__UNIVARIATE__CONTINUOUS__INV_GAMMA_HPP
3 
4 #include <boost/random/gamma_distribution.hpp>
5 #include <boost/random/variate_generator.hpp>
6 
7 #include <stan/agrad/partials_vari.hpp>
8 #include <stan/math/error_handling.hpp>
9 #include <stan/math/constants.hpp>
10 #include <stan/math/functions/multiply_log.hpp>
11 #include <stan/math/functions/value_of.hpp>
12 #include <stan/meta/traits.hpp>
13 #include <stan/prob/constants.hpp>
14 #include <stan/prob/traits.hpp>
15 #include <stan/prob/internal_math.hpp>
16 
17 namespace stan {
18 
19  namespace prob {
20 
37  template <bool propto,
38  typename T_y, typename T_shape, typename T_scale>
39  typename return_type<T_y,T_shape,T_scale>::type
40  inv_gamma_log(const T_y& y, const T_shape& alpha, const T_scale& beta) {
41  static const char* function = "stan::prob::inv_gamma_log(%1%)";
42 
43  using stan::is_constant_struct;
44  using stan::math::check_not_nan;
45  using stan::math::check_positive_finite;
46  using boost::math::tools::promote_args;
47  using stan::math::check_consistent_sizes;
48  using stan::math::value_of;
49 
50  // check if any vectors are zero length
51  if (!(stan::length(y)
52  && stan::length(alpha)
53  && stan::length(beta)))
54  return 0.0;
55 
56  // set up return value accumulator
57  double logp(0.0);
58 
59  check_not_nan(function, y, "Random variable", &logp);
60  check_positive_finite(function, alpha, "Shape parameter", &logp);
61  check_positive_finite(function, beta, "Scale parameter", &logp);
62  check_consistent_sizes(function,
63  y,alpha,beta,
64  "Random variable","Shape parameter",
65  "Scale parameter",
66  &logp);
67 
68  // check if no variables are involved and prop-to
69  if (!include_summand<propto,T_y,T_shape,T_scale>::value)
70  return 0.0;
71 
72  // set up template expressions wrapping scalars into vector views
73  VectorView<const T_y> y_vec(y);
74  VectorView<const T_shape> alpha_vec(alpha);
75  VectorView<const T_scale> beta_vec(beta);
76 
77  for (size_t n = 0; n < length(y); n++) {
78  const double y_dbl = value_of(y_vec[n]);
79  if (y_dbl <= 0)
80  return LOG_ZERO;
81  }
82 
83  size_t N = max_size(y, alpha, beta);
84  agrad::OperandsAndPartials<T_y, T_shape, T_scale>
85  operands_and_partials(y, alpha, beta);
86 
87  using boost::math::lgamma;
88  using stan::math::multiply_log;
89  using boost::math::digamma;
90 
91  DoubleVectorView<include_summand<propto,T_y,T_shape>::value,
92  is_vector<T_y>::value>
93  log_y(length(y));
94  DoubleVectorView<include_summand<propto,T_y,T_scale>::value,
95  is_vector<T_y>::value>
96  inv_y(length(y));
97  for(size_t n = 0; n < length(y); n++) {
98  if (include_summand<propto,T_y,T_shape>::value)
99  if (value_of(y_vec[n]) > 0)
100  log_y[n] = log(value_of(y_vec[n]));
101  if (include_summand<propto,T_y,T_scale>::value)
102  inv_y[n] = 1.0 / value_of(y_vec[n]);
103  }
104 
105  DoubleVectorView<include_summand<propto,T_shape>::value,
106  is_vector<T_shape>::value>
107  lgamma_alpha(length(alpha));
108  DoubleVectorView<!is_constant_struct<T_shape>::value,
109  is_vector<T_shape>::value>
110  digamma_alpha(length(alpha));
111  for (size_t n = 0; n < length(alpha); n++) {
112  if (include_summand<propto,T_shape>::value)
113  lgamma_alpha[n] = lgamma(value_of(alpha_vec[n]));
114  if (!is_constant_struct<T_shape>::value)
115  digamma_alpha[n] = digamma(value_of(alpha_vec[n]));
116  }
117 
118  DoubleVectorView<include_summand<propto,T_shape,T_scale>::value,
119  is_vector<T_scale>::value>
120  log_beta(length(beta));
121  if (include_summand<propto,T_shape,T_scale>::value)
122  for (size_t n = 0; n < length(beta); n++)
123  log_beta[n] = log(value_of(beta_vec[n]));
124 
125  for (size_t n = 0; n < N; n++) {
126  // pull out values of arguments
127  const double alpha_dbl = value_of(alpha_vec[n]);
128  const double beta_dbl = value_of(beta_vec[n]);
129 
130  if (include_summand<propto,T_shape>::value)
131  logp -= lgamma_alpha[n];
132  if (include_summand<propto,T_shape,T_scale>::value)
133  logp += alpha_dbl * log_beta[n];
134  if (include_summand<propto,T_y,T_shape>::value)
135  logp -= (alpha_dbl+1.0) * log_y[n];
136  if (include_summand<propto,T_y,T_scale>::value)
137  logp -= beta_dbl * inv_y[n];
138 
139  // gradients
140  if (!is_constant<typename is_vector<T_y>::type>::value)
141  operands_and_partials.d_x1[n]
142  += -(alpha_dbl+1) * inv_y[n] + beta_dbl * inv_y[n] * inv_y[n];
143  if (!is_constant<typename is_vector<T_shape>::type>::value)
144  operands_and_partials.d_x2[n]
145  += -digamma_alpha[n] + log_beta[n] - log_y[n];
146  if (!is_constant<typename is_vector<T_scale>::type>::value)
147  operands_and_partials.d_x3[n] += alpha_dbl / beta_dbl - inv_y[n];
148  }
149  return operands_and_partials.to_var(logp);
150  }
151 
152  template <typename T_y, typename T_shape, typename T_scale>
153  inline
154  typename return_type<T_y,T_shape,T_scale>::type
155  inv_gamma_log(const T_y& y, const T_shape& alpha, const T_scale& beta) {
156  return inv_gamma_log<false>(y,alpha,beta);
157  }
158 
175  template <typename T_y, typename T_shape, typename T_scale>
176  typename return_type<T_y,T_shape,T_scale>::type
177  inv_gamma_cdf(const T_y& y, const T_shape& alpha, const T_scale& beta) {
178 
179  // Size checks
180  if (!(stan::length(y) && stan::length(alpha) && stan::length(beta)))
181  return 1.0;
182 
183  // Error checks
184  static const char* function = "stan::prob::inv_gamma_cdf(%1%)";
185 
186  using stan::math::check_positive_finite;
187  using stan::math::check_not_nan;
188  using stan::math::check_consistent_sizes;
189  using stan::math::check_greater_or_equal;
190  using stan::math::check_less_or_equal;
191  using stan::math::check_nonnegative;
192  using stan::math::value_of;
193  using boost::math::tools::promote_args;
194 
195  double P(1.0);
196 
197  check_positive_finite(function, alpha, "Shape parameter", &P);
198  check_positive_finite(function, beta, "Scale parameter", &P);
199  check_not_nan(function, y, "Random variable", &P);
200  check_nonnegative(function, y, "Random variable", &P);
201  check_consistent_sizes(function, y, alpha, beta,
202  "Random variable", "Shape parameter",
203  "Scale Parameter",
204  &P);
205 
206  // Wrap arguments in vectors
207  VectorView<const T_y> y_vec(y);
208  VectorView<const T_shape> alpha_vec(alpha);
209  VectorView<const T_scale> beta_vec(beta);
210  size_t N = max_size(y, alpha, beta);
211 
212  agrad::OperandsAndPartials<T_y, T_shape, T_scale>
213  operands_and_partials(y, alpha, beta);
214 
215  // Explicit return for extreme values
216  // The gradients are technically ill-defined, but treated as zero
217 
218  for (size_t i = 0; i < stan::length(y); i++) {
219  if (value_of(y_vec[i]) == 0)
220  return operands_and_partials.to_var(0.0);
221  }
222 
223  // Compute CDF and its gradients
224  using boost::math::gamma_p_derivative;
225  using boost::math::gamma_q;
226  using boost::math::digamma;
227  using boost::math::tgamma;
228 
229  // Cache a few expensive function calls if nu is a parameter
230  DoubleVectorView<!is_constant_struct<T_shape>::value,
231  is_vector<T_shape>::value>
232  gamma_vec(stan::length(alpha));
233  DoubleVectorView<!is_constant_struct<T_shape>::value,
234  is_vector<T_shape>::value>
235  digamma_vec(stan::length(alpha));
236 
237  if (!is_constant_struct<T_shape>::value) {
238  for (size_t i = 0; i < stan::length(alpha); i++) {
239  const double alpha_dbl = value_of(alpha_vec[i]);
240  gamma_vec[i] = tgamma(alpha_dbl);
241  digamma_vec[i] = digamma(alpha_dbl);
242  }
243  }
244 
245  // Compute vectorized CDF and gradient
246  for (size_t n = 0; n < N; n++) {
247  // Explicit results for extreme values
248  // The gradients are technically ill-defined, but treated as zero
249  if (value_of(y_vec[n]) == std::numeric_limits<double>::infinity())
250  continue;
251 
252  // Pull out values
253  const double y_dbl = value_of(y_vec[n]);
254  const double y_inv_dbl = 1.0 / y_dbl;
255  const double alpha_dbl = value_of(alpha_vec[n]);
256  const double beta_dbl = value_of(beta_vec[n]);
257 
258  // Compute
259  const double Pn = gamma_q(alpha_dbl, beta_dbl * y_inv_dbl);
260 
261  P *= Pn;
262 
263  if (!is_constant_struct<T_y>::value)
264  operands_and_partials.d_x1[n]
265  += beta_dbl * y_inv_dbl * y_inv_dbl
266  * gamma_p_derivative(alpha_dbl, beta_dbl * y_inv_dbl)
267  / Pn;
268  if (!is_constant_struct<T_shape>::value)
269  operands_and_partials.d_x2[n]
270  += stan::math::gradRegIncGamma(alpha_dbl, beta_dbl
271  * y_inv_dbl, gamma_vec[n],
272  digamma_vec[n]) / Pn;
273  if (!is_constant_struct<T_scale>::value)
274  operands_and_partials.d_x3[n]
275  += - y_inv_dbl * gamma_p_derivative(alpha_dbl,
276  beta_dbl * y_inv_dbl) / Pn;
277  }
278 
279  if (!is_constant_struct<T_y>::value)
280  for (size_t n = 0; n < stan::length(y); ++n)
281  operands_and_partials.d_x1[n] *= P;
282  if (!is_constant_struct<T_shape>::value)
283  for (size_t n = 0; n < stan::length(alpha); ++n)
284  operands_and_partials.d_x2[n] *= P;
285  if (!is_constant_struct<T_scale>::value)
286  for (size_t n = 0; n < stan::length(beta); ++n)
287  operands_and_partials.d_x3[n] *= P;
288 
289  return operands_and_partials.to_var(P);
290  }
291 
292  template <typename T_y, typename T_shape, typename T_scale>
293  typename return_type<T_y,T_shape,T_scale>::type
294  inv_gamma_cdf_log(const T_y& y, const T_shape& alpha, const T_scale& beta) {
295 
296  // Size checks
297  if (!(stan::length(y) && stan::length(alpha) && stan::length(beta)))
298  return 0.0;
299 
300  // Error checks
301  static const char* function = "stan::prob::inv_gamma_cdf_log(%1%)";
302 
303  using stan::math::check_positive_finite;
304  using stan::math::check_not_nan;
305  using stan::math::check_consistent_sizes;
306  using stan::math::check_greater_or_equal;
307  using stan::math::check_less_or_equal;
308  using stan::math::check_nonnegative;
309  using stan::math::value_of;
310  using boost::math::tools::promote_args;
311 
312  double P(0.0);
313 
314  check_positive_finite(function, alpha, "Shape parameter", &P);
315  check_positive_finite(function, beta, "Scale parameter", &P);
316  check_not_nan(function, y, "Random variable", &P);
317  check_nonnegative(function, y, "Random variable", &P);
318  check_consistent_sizes(function, y, alpha, beta,
319  "Random variable", "Shape parameter",
320  "Scale Parameter",
321  &P);
322 
323  // Wrap arguments in vectors
324  VectorView<const T_y> y_vec(y);
325  VectorView<const T_shape> alpha_vec(alpha);
326  VectorView<const T_scale> beta_vec(beta);
327  size_t N = max_size(y, alpha, beta);
328 
329  agrad::OperandsAndPartials<T_y, T_shape, T_scale>
330  operands_and_partials(y, alpha, beta);
331 
332  // Explicit return for extreme values
333  // The gradients are technically ill-defined, but treated as zero
334 
335  for (size_t i = 0; i < stan::length(y); i++) {
336  if (value_of(y_vec[i]) == 0)
337  return operands_and_partials.to_var(stan::math::negative_infinity());
338  }
339 
340  // Compute cdf_log and its gradients
341  using boost::math::gamma_p_derivative;
342  using boost::math::gamma_q;
343  using boost::math::digamma;
344  using boost::math::tgamma;
345 
346  // Cache a few expensive function calls if nu is a parameter
347  DoubleVectorView<!is_constant_struct<T_shape>::value,
348  is_vector<T_shape>::value>
349  gamma_vec(stan::length(alpha));
350  DoubleVectorView<!is_constant_struct<T_shape>::value,
351  is_vector<T_shape>::value>
352  digamma_vec(stan::length(alpha));
353 
354  if (!is_constant_struct<T_shape>::value) {
355  for (size_t i = 0; i < stan::length(alpha); i++) {
356  const double alpha_dbl = value_of(alpha_vec[i]);
357  gamma_vec[i] = tgamma(alpha_dbl);
358  digamma_vec[i] = digamma(alpha_dbl);
359  }
360  }
361 
362  // Compute vectorized cdf_log and gradient
363  for (size_t n = 0; n < N; n++) {
364  // Explicit results for extreme values
365  // The gradients are technically ill-defined, but treated as zero
366  if (value_of(y_vec[n]) == std::numeric_limits<double>::infinity())
367  continue;
368 
369  // Pull out values
370  const double y_dbl = value_of(y_vec[n]);
371  const double y_inv_dbl = 1.0 / y_dbl;
372  const double alpha_dbl = value_of(alpha_vec[n]);
373  const double beta_dbl = value_of(beta_vec[n]);
374 
375  // Compute
376  const double Pn = gamma_q(alpha_dbl, beta_dbl * y_inv_dbl);
377 
378  P += log(Pn);
379 
380  if (!is_constant_struct<T_y>::value)
381  operands_and_partials.d_x1[n]
382  += beta_dbl * y_inv_dbl * y_inv_dbl
383  * gamma_p_derivative(alpha_dbl, beta_dbl * y_inv_dbl)
384  / Pn;
385  if (!is_constant_struct<T_shape>::value)
386  operands_and_partials.d_x2[n]
387  += stan::math::gradRegIncGamma(alpha_dbl, beta_dbl
388  * y_inv_dbl, gamma_vec[n],
389  digamma_vec[n]) / Pn;
390  if (!is_constant_struct<T_scale>::value)
391  operands_and_partials.d_x3[n]
392  += - y_inv_dbl * gamma_p_derivative(alpha_dbl,
393  beta_dbl * y_inv_dbl) / Pn;
394  }
395 
396  return operands_and_partials.to_var(P);
397  }
398 
399  template <typename T_y, typename T_shape, typename T_scale>
400  typename return_type<T_y,T_shape,T_scale>::type
401  inv_gamma_ccdf_log(const T_y& y, const T_shape& alpha, const T_scale& beta) {
402 
403  // Size checks
404  if (!(stan::length(y) && stan::length(alpha) && stan::length(beta)))
405  return 0.0;
406 
407  // Error checks
408  static const char* function = "stan::prob::inv_gamma_ccdf_log(%1%)";
409 
410  using stan::math::check_positive_finite;
411  using stan::math::check_not_nan;
412  using stan::math::check_consistent_sizes;
413  using stan::math::check_greater_or_equal;
414  using stan::math::check_less_or_equal;
415  using stan::math::check_nonnegative;
416  using stan::math::value_of;
417  using boost::math::tools::promote_args;
418 
419  double P(0.0);
420 
421  check_positive_finite(function, alpha, "Shape parameter", &P);
422  check_positive_finite(function, beta, "Scale parameter", &P);
423  check_not_nan(function, y, "Random variable", &P);
424  check_nonnegative(function, y, "Random variable", &P);
425  check_consistent_sizes(function, y, alpha, beta,
426  "Random variable", "Shape parameter",
427  "Scale Parameter",
428  &P);
429 
430  // Wrap arguments in vectors
431  VectorView<const T_y> y_vec(y);
432  VectorView<const T_shape> alpha_vec(alpha);
433  VectorView<const T_scale> beta_vec(beta);
434  size_t N = max_size(y, alpha, beta);
435 
436  agrad::OperandsAndPartials<T_y, T_shape, T_scale>
437  operands_and_partials(y, alpha, beta);
438 
439  // Explicit return for extreme values
440  // The gradients are technically ill-defined, but treated as zero
441 
442  for (size_t i = 0; i < stan::length(y); i++) {
443  if (value_of(y_vec[i]) == 0)
444  return operands_and_partials.to_var(0.0);
445  }
446 
447  // Compute ccdf_log and its gradients
448  using boost::math::gamma_p_derivative;
449  using boost::math::gamma_q;
450  using boost::math::digamma;
451  using boost::math::tgamma;
452 
453  // Cache a few expensive function calls if nu is a parameter
454  DoubleVectorView<!is_constant_struct<T_shape>::value,
455  is_vector<T_shape>::value>
456  gamma_vec(stan::length(alpha));
457  DoubleVectorView<!is_constant_struct<T_shape>::value,
458  is_vector<T_shape>::value>
459  digamma_vec(stan::length(alpha));
460 
461  if (!is_constant_struct<T_shape>::value) {
462  for (size_t i = 0; i < stan::length(alpha); i++) {
463  const double alpha_dbl = value_of(alpha_vec[i]);
464  gamma_vec[i] = tgamma(alpha_dbl);
465  digamma_vec[i] = digamma(alpha_dbl);
466  }
467  }
468 
469  // Compute vectorized ccdf_log and gradient
470  for (size_t n = 0; n < N; n++) {
471  // Explicit results for extreme values
472  // The gradients are technically ill-defined, but treated as zero
473  if (value_of(y_vec[n]) == std::numeric_limits<double>::infinity())
474  return operands_and_partials.to_var(stan::math::negative_infinity());
475 
476  // Pull out values
477  const double y_dbl = value_of(y_vec[n]);
478  const double y_inv_dbl = 1.0 / y_dbl;
479  const double alpha_dbl = value_of(alpha_vec[n]);
480  const double beta_dbl = value_of(beta_vec[n]);
481 
482  // Compute
483  const double Pn = 1.0 - gamma_q(alpha_dbl, beta_dbl * y_inv_dbl);
484 
485  P += log(Pn);
486 
487  if (!is_constant_struct<T_y>::value)
488  operands_and_partials.d_x1[n]
489  -= beta_dbl * y_inv_dbl * y_inv_dbl
490  * gamma_p_derivative(alpha_dbl, beta_dbl * y_inv_dbl)
491  / Pn;
492  if (!is_constant_struct<T_shape>::value)
493  operands_and_partials.d_x2[n]
494  -= stan::math::gradRegIncGamma(alpha_dbl, beta_dbl
495  * y_inv_dbl, gamma_vec[n],
496  digamma_vec[n]) / Pn;
497  if (!is_constant_struct<T_scale>::value)
498  operands_and_partials.d_x3[n]
499  -= - y_inv_dbl * gamma_p_derivative(alpha_dbl,
500  beta_dbl * y_inv_dbl) / Pn;
501  }
502 
503  return operands_and_partials.to_var(P);
504  }
505 
506  template <class RNG>
507  inline double
508  inv_gamma_rng(const double alpha,
509  const double beta,
510  RNG& rng) {
511  using boost::variate_generator;
512  using boost::random::gamma_distribution;
513 
514  static const char* function = "stan::prob::inv_gamma_rng(%1%)";
515 
516  using stan::math::check_positive_finite;
517 
518  check_positive_finite(function, alpha, "Shape parameter", (double*)0);
519  check_positive_finite(function, beta, "Scale parameter", (double*)0);
520 
521  variate_generator<RNG&, gamma_distribution<> >
522  gamma_rng(rng, gamma_distribution<>(alpha, 1 / beta));
523  return 1 / gamma_rng();
524  }
525  }
526 }
527 
528 #endif
stan::prob::inv_gamma_cdf_log
return_type< T_y, T_shape, T_scale >::type inv_gamma_cdf_log(const T_y &y, const T_shape &alpha, const T_scale &beta)
Definition: inv_gamma.hpp:294
stan::is_constant
Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the ...
Definition: traits.hpp:43
multiply_log.hpp
stan::agrad::tgamma
fvar< T > tgamma(const fvar< T > &x)
Definition: tgamma.hpp:15
stan::is_vector::type
T type
Definition: traits.hpp:85
stan::agrad::OperandsAndPartials::to_var
T_return_type to_var(double logp)
Definition: partials_vari.hpp:138
stan::math::check_positive_finite
bool check_positive_finite(const char *function, const T_y &y, const char *name, T_result *result)
Definition: check_positive_finite.hpp:12
error_handling.hpp
stan::math::multiply_log
boost::math::tools::promote_args< T_a, T_b >::type multiply_log(const T_a a, const T_b b)
Calculated the value of the first argument times log of the second argument while behaving properly w...
Definition: multiply_log.hpp:51
stan::length
size_t length(const T &)
Definition: traits.hpp:159
stan::DoubleVectorView
DoubleVectorView allocates double values to be used as intermediate values.
Definition: traits.hpp:358
partials_vari.hpp
stan::agrad::value_of
T value_of(const fvar< T > &v)
Return the value of the specified variable.
Definition: value_of.hpp:16
stan::prob::inv_gamma_cdf
return_type< T_y, T_shape, T_scale >::type inv_gamma_cdf(const T_y &y, const T_shape &alpha, const T_scale &beta)
The CDF of an inverse gamma density for y with the specified shape and scale parameters.
Definition: inv_gamma.hpp:177
stan::is_vector
Definition: traits.hpp:83
stan::agrad::lgamma
fvar< T > lgamma(const fvar< T > &x)
Definition: lgamma.hpp:15
stan::agrad::OperandsAndPartials
A variable implementation that stores operands and derivatives with respect to the variable...
Definition: partials_vari.hpp:76
stan::return_type::type
boost::math::tools::promote_args< typename scalar_type< T1 >::type, typename scalar_type< T2 >::type, typename scalar_type< T3 >::type, typename scalar_type< T4 >::type, typename scalar_type< T5 >::type, typename scalar_type< T6 >::type >::type type
Definition: traits.hpp:406
stan::is_constant_struct
Metaprogram to determine if a type has a base scalar type that can be assigned to type double...
Definition: traits.hpp:57
stan::math::value_of
double value_of(const T x)
Return the value of the specified scalar argument converted to a double value.
Definition: value_of.hpp:24
stan::prob::include_summand
Template metaprogram to calculate whether a summand needs to be included in a proportional (log) prob...
Definition: traits.hpp:35
stan::prob::inv_gamma_log
return_type< T_y, T_shape, T_scale >::type inv_gamma_log(const T_y &y, const T_shape &alpha, const T_scale &beta)
The log of an inverse gamma density for y with the specified shape and scale parameters.
Definition: inv_gamma.hpp:40
stan::agrad::gamma_q
fvar< T > gamma_q(const fvar< T > &x1, const fvar< T > &x2)
Definition: gamma_q.hpp:15
stan::agrad::OperandsAndPartials::d_x2
VectorView< double *, is_vector< T2 >::value, is_constant_struct< T2 >::value > d_x2
Definition: partials_vari.hpp:83
stan::math::gradRegIncGamma
double gradRegIncGamma(double a, double z, double g, double dig, double precision=1e-6)
Definition: internal_math.hpp:181
stan::math::check_nonnegative
bool check_nonnegative(const char *function, const T_y &y, const char *name, T_result *result)
Definition: check_nonnegative.hpp:52
stan::prob::inv_gamma_rng
double inv_gamma_rng(const double alpha, const double beta, RNG &rng)
Definition: inv_gamma.hpp:508
stan::math::check_consistent_sizes
bool check_consistent_sizes(const char *function, const T1 &x1, const T2 &x2, const char *name1, const char *name2, T_result *result)
Definition: check_consistent_sizes.hpp:13
stan::max_size
size_t max_size(const T1 &x1, const T2 &x2)
Definition: traits.hpp:191
stan::prob::inv_gamma_ccdf_log
return_type< T_y, T_shape, T_scale >::type inv_gamma_ccdf_log(const T_y &y, const T_shape &alpha, const T_scale &beta)
Definition: inv_gamma.hpp:401
internal_math.hpp
stan::math::check_less_or_equal
bool check_less_or_equal(const char *function, const T_y &y, const T_high &high, const char *name, T_result *result)
Definition: check_less_or_equal.hpp:52
stan::math::check_not_nan
bool check_not_nan(const char *function, const T_y &y, const char *name, T_result *result)
Checks if the variable y is nan.
Definition: check_not_nan.hpp:56
stan::agrad::digamma
fvar< T > digamma(const fvar< T > &x)
Definition: digamma.hpp:16
value_of.hpp
stan::agrad::OperandsAndPartials::d_x1
VectorView< double *, is_vector< T1 >::value, is_constant_struct< T1 >::value > d_x1
Definition: partials_vari.hpp:82
stan::agrad::OperandsAndPartials::d_x3
VectorView< double *, is_vector< T3 >::value, is_constant_struct< T3 >::value > d_x3
Definition: partials_vari.hpp:84
stan::agrad::log
fvar< T > log(const fvar< T > &x)
Definition: log.hpp:15
stan::VectorView
VectorView is a template metaprogram that takes its argument and allows it to be used like a vector...
Definition: traits.hpp:275
stan::prob::gamma_rng
double gamma_rng(const double alpha, const double beta, RNG &rng)
Definition: gamma.hpp:491
stan::math::check_greater_or_equal
bool check_greater_or_equal(const char *function, const T_y &y, const T_low &low, const char *name, T_result *result)
Definition: check_greater_or_equal.hpp:58
stan::math::negative_infinity
double negative_infinity()
Return negative infinity.
Definition: constants.hpp:123
     [ Stan Home Page ] © 2011–2014, Stan Development Team.