Stan  2.5.0
probability, sampling & optimization
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
pareto_type_2.hpp
Go to the documentation of this file.
1 #ifndef STAN__PROB__DISTRIBUTIONS__UNIVARIATE__CONTINUOUS__PARETO_TYPE_2_HPP
2 #define STAN__PROB__DISTRIBUTIONS__UNIVARIATE__CONTINUOUS__PARETO_TYPE_2_HPP
3 
4 #include <boost/random/variate_generator.hpp>
5 #include <stan/prob/distributions/univariate/continuous/uniform.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/value_of.hpp>
11 #include <stan/math/functions/log1m.hpp>
12 #include <stan/meta/traits.hpp>
13 #include <stan/prob/constants.hpp>
14 #include <stan/prob/traits.hpp>
15 
16 
17 namespace stan {
18  namespace prob {
19 
20  // pareto_type_2(y|lambda,alpha) [y >= 0; lambda > 0; alpha > 0]
21  template <bool propto,
22  typename T_y, typename T_loc, typename T_scale, typename T_shape>
23  typename return_type<T_y,T_loc,T_scale,T_shape>::type
24  pareto_type_2_log(const T_y& y, const T_loc& mu, const T_scale& lambda,
25  const T_shape& alpha) {
26  static const char* function = "stan::prob::pareto_type_2_log(%1%)";
27 
28  using std::log;
29  using stan::math::value_of;
30  using stan::math::check_finite;
31  using stan::math::check_greater_or_equal;
32  using stan::math::check_positive_finite;
33  using stan::math::check_nonnegative;
34  using stan::math::check_not_nan;
35  using stan::math::check_consistent_sizes;
36 
37  // check if any vectors are zero length
38  if (!(stan::length(y)
39  && stan::length(mu)
40  && stan::length(lambda)
41  && stan::length(alpha)))
42  return 0.0;
43 
44  // set up return value accumulator
45  double logp(0.0);
46 
47  // validate args (here done over var, which should be OK)
48  check_greater_or_equal(function, y, mu, "Random variable", &logp);
49  check_not_nan(function, y, "Random variable", &logp);
50  check_positive_finite(function, lambda, "Scale parameter", &logp);
51  check_positive_finite(function, alpha, "Shape parameter", &logp);
52  check_consistent_sizes(function,
53  y,lambda,alpha,
54  "Random variable","Scale parameter",
55  "Shape parameter",
56  &logp);
57 
58  // check if no variables are involved and prop-to
59  if (!include_summand<propto,T_y,T_scale,T_shape>::value)
60  return 0.0;
61 
62  VectorView<const T_y> y_vec(y);
63  VectorView<const T_loc> mu_vec(mu);
64  VectorView<const T_scale> lambda_vec(lambda);
65  VectorView<const T_shape> alpha_vec(alpha);
66  size_t N = max_size(y, mu, lambda, alpha);
67 
68  // set up template expressions wrapping scalars into vector views
69  agrad::OperandsAndPartials<T_y,T_loc,T_scale,T_shape>
70  operands_and_partials(y, mu, lambda, alpha);
71 
72  DoubleVectorView<include_summand<propto,T_y,T_loc,T_scale,T_shape>::value,
73  is_vector<T_y>::value> log1p_scaled_diff(N);
74  if (include_summand<propto,T_y,T_loc,T_scale,T_shape>::value)
75  for (size_t n = 0; n < N; n++)
76  log1p_scaled_diff[n] = log1p((value_of(y_vec[n])
77  - value_of(mu_vec[n]))
78  / value_of(lambda_vec[n]));
79 
80  DoubleVectorView<include_summand<propto,T_scale>::value,
81  is_vector<T_scale>::value> log_lambda(length(lambda));
82  if (include_summand<propto,T_scale>::value)
83  for (size_t n = 0; n < length(lambda); n++)
84  log_lambda[n] = log(value_of(lambda_vec[n]));
85 
86  DoubleVectorView<include_summand<propto,T_shape>::value,
87  is_vector<T_shape>::value> log_alpha(length(alpha));
88  if (include_summand<propto,T_shape>::value)
89  for (size_t n = 0; n < length(alpha); n++)
90  log_alpha[n] = log(value_of(alpha_vec[n]));
91 
92  DoubleVectorView<!is_constant_struct<T_shape>::value,
93  is_vector<T_shape>::value> inv_alpha(length(alpha));
94  if (!is_constant_struct<T_shape>::value)
95  for (size_t n = 0; n < length(alpha); n++)
96  inv_alpha[n] = 1 / value_of(alpha_vec[n]);
97 
98  for (size_t n = 0; n < N; n++) {
99  const double y_dbl = value_of(y_vec[n]);
100  const double mu_dbl = value_of(mu_vec[n]);
101  const double lambda_dbl = value_of(lambda_vec[n]);
102  const double alpha_dbl = value_of(alpha_vec[n]);
103  const double sum_dbl = lambda_dbl + y_dbl + mu_dbl;
104  const double inv_sum = 1.0 / sum_dbl;
105  const double alpha_div_sum = alpha_dbl / sum_dbl;
106  const double deriv_1_2 = inv_sum + alpha_div_sum;
107 
108  // // log probability
109  if (include_summand<propto,T_shape>::value)
110  logp += log_alpha[n];
111  if (include_summand<propto,T_scale>::value)
112  logp -= log_lambda[n];
113  if (include_summand<propto,T_y,T_scale,T_shape>::value)
114  logp -= (alpha_dbl + 1.0) * log1p_scaled_diff[n];
115 
116  // gradients
117  if (!is_constant_struct<T_y>::value)
118  operands_and_partials.d_x1[n] -= deriv_1_2;
119  if (!is_constant_struct<T_loc>::value)
120  operands_and_partials.d_x2[n] += deriv_1_2;
121  if (!is_constant_struct<T_scale>::value)
122  operands_and_partials.d_x3[n] -= alpha_div_sum * (mu_dbl - y_dbl)
123  / lambda_dbl + inv_sum;
124  if (!is_constant_struct<T_shape>::value)
125  operands_and_partials.d_x4[n] += inv_alpha[n] - log1p_scaled_diff[n];
126  }
127  return operands_and_partials.to_var(logp);
128  }
129 
130  template <typename T_y, typename T_loc, typename T_scale, typename T_shape>
131  inline
132  typename return_type<T_y,T_loc,T_scale,T_shape>::type
133  pareto_type_2_log(const T_y& y, const T_loc& mu,
134  const T_scale& lambda, const T_shape& alpha) {
135  return pareto_type_2_log<false>(y,mu,lambda,alpha);
136  }
137 
138  template <typename T_y, typename T_loc, typename T_scale, typename T_shape>
139  typename return_type<T_y, T_loc, T_scale, T_shape>::type
140  pareto_type_2_cdf(const T_y& y, const T_loc& mu,
141  const T_scale& lambda, const T_shape& alpha) {
142 
143  // Check sizes
144  // Size checks
145  if ( !( stan::length(y)
146  && stan::length(mu)
147  && stan::length(lambda)
148  && stan::length(alpha) ) )
149  return 1.0;
150 
151  // Check errors
152  static const char* function = "stan::prob::pareto_type_2_cdf(%1%)";
153 
154  using stan::math::check_greater_or_equal;
155  using stan::math::check_finite;
156  using stan::math::check_positive_finite;
157  using stan::math::check_not_nan;
158  using stan::math::check_greater_or_equal;
159  using stan::math::check_consistent_sizes;
160  using stan::math::check_nonnegative;
161  using stan::math::value_of;
162 
163  double P(1.0);
164 
165  check_greater_or_equal(function, y, mu, "Random variable", &P);
166  check_not_nan(function, y, "Random variable", &P);
167  check_nonnegative(function, y, "Random variable", &P);
168  check_positive_finite(function, lambda, "Scale parameter", &P);
169  check_positive_finite(function, alpha, "Shape parameter", &P);
170  check_consistent_sizes(function, y, lambda, alpha,
171  "Random variable", "Scale parameter",
172  "Shape parameter", &P);
173 
174  // Wrap arguments in vectors
175  VectorView<const T_y> y_vec(y);
176  VectorView<const T_loc> mu_vec(mu);
177  VectorView<const T_scale> lambda_vec(lambda);
178  VectorView<const T_shape> alpha_vec(alpha);
179  size_t N = max_size(y, mu, lambda, alpha);
180 
181  agrad::OperandsAndPartials<T_y, T_loc, T_scale, T_shape>
182  operands_and_partials(y, mu, lambda, alpha);
183 
184  DoubleVectorView<true, is_vector<T_y>::value
185  || is_vector<T_loc>::value
186  || is_vector<T_scale>::value
187  || is_vector<T_shape>::value>
188  p1_pow_alpha(N);
189 
190  DoubleVectorView<!is_constant_struct<T_y>::value
191  || !is_constant_struct<T_loc>::value
192  || !is_constant_struct<T_scale>::value,
193  is_vector<T_y>::value
194  || is_vector<T_loc>::value
195  || is_vector<T_scale>::value
196  || is_vector<T_shape>::value>
197  grad_1_2(N);
198 
199  DoubleVectorView<!is_constant_struct<T_shape>::value,
200  is_vector<T_y>::value
201  || is_vector<T_loc>::value
202  || is_vector<T_scale>::value
203  || is_vector<T_shape>::value>
204  grad_3(N);
205 
206  for (size_t i = 0; i < N; i++) {
207  const double lambda_dbl = value_of(lambda_vec[i]);
208  const double alpha_dbl = value_of(alpha_vec[i]);
209  const double temp = 1 + (value_of(y_vec[i])
210  - value_of(mu_vec[i]))
211  / lambda_dbl;
212  p1_pow_alpha[i] = pow(temp, -alpha_dbl);
213 
214  if (!is_constant_struct<T_y>::value
215  || !is_constant_struct<T_loc>::value
216  || !is_constant_struct<T_scale>::value)
217  grad_1_2[i] = p1_pow_alpha[i] / temp * alpha_dbl / lambda_dbl;
218 
219  if (!is_constant_struct<T_shape>::value)
220  grad_3[i] = log(temp) * p1_pow_alpha[i];
221  }
222 
223  // Compute vectorized CDF and its gradients
224 
225  for (size_t n = 0; n < N; n++) {
226 
227  // Pull out values
228  const double y_dbl = value_of(y_vec[n]);
229  const double mu_dbl = value_of(mu_vec[n]);
230  const double lambda_dbl = value_of(lambda_vec[n]);
231 
232  const double Pn = 1.0 - p1_pow_alpha[n];
233 
234  // Compute
235  P *= Pn;
236 
237  if (!is_constant_struct<T_y>::value)
238  operands_and_partials.d_x1[n] += grad_1_2[n] / Pn;
239  if (!is_constant_struct<T_loc>::value)
240  operands_and_partials.d_x2[n] -= grad_1_2[n] / Pn;
241  if (!is_constant_struct<T_scale>::value)
242  operands_and_partials.d_x3[n] += (mu_dbl - y_dbl)
243  * grad_1_2[n] / lambda_dbl / Pn;
244  if (!is_constant_struct<T_shape>::value)
245  operands_and_partials.d_x4[n] += grad_3[n] / Pn;
246  }
247 
248  if (!is_constant_struct<T_y>::value) {
249  for(size_t n = 0; n < stan::length(y); ++n)
250  operands_and_partials.d_x1[n] *= P;
251  }
252  if (!is_constant_struct<T_loc>::value) {
253  for(size_t n = 0; n < stan::length(mu); ++n)
254  operands_and_partials.d_x2[n] *= P;
255  }
256  if (!is_constant_struct<T_scale>::value) {
257  for(size_t n = 0; n < stan::length(lambda); ++n)
258  operands_and_partials.d_x3[n] *= P;
259  }
260  if (!is_constant_struct<T_shape>::value) {
261  for(size_t n = 0; n < stan::length(alpha); ++n)
262  operands_and_partials.d_x4[n] *= P;
263  }
264 
265  return operands_and_partials.to_var(P);
266  }
267 
268  template <typename T_y, typename T_loc, typename T_scale, typename T_shape>
269  typename return_type<T_y, T_loc, T_scale, T_shape>::type
270  pareto_type_2_cdf_log(const T_y& y, const T_loc& mu,
271  const T_scale& lambda, const T_shape& alpha) {
272 
273  // Check sizes
274  // Size checks
275  if ( !( stan::length(y)
276  && stan::length(mu)
277  && stan::length(lambda)
278  && stan::length(alpha) ) )
279  return 0.0;
280 
281  // Check errors
282  static const char* function = "stan::prob::pareto_type_2_cdf_log(%1%)";
283 
284  using stan::math::check_greater_or_equal;
285  using stan::math::check_finite;
286  using stan::math::check_positive_finite;
287  using stan::math::check_not_nan;
288  using stan::math::check_greater_or_equal;
289  using stan::math::check_consistent_sizes;
290  using stan::math::check_nonnegative;
291  using stan::math::value_of;
292  using stan::math::log1m;
293 
294  double P(0.0);
295 
296  check_greater_or_equal(function, y, mu, "Random variable", &P);
297  check_not_nan(function, y, "Random variable", &P);
298  check_nonnegative(function, y, "Random variable", &P);
299  check_positive_finite(function, lambda, "Scale parameter", &P);
300  check_positive_finite(function, alpha, "Shape parameter", &P);
301  check_consistent_sizes(function, y, lambda, alpha,
302  "Random variable", "Scale parameter",
303  "Shape parameter", &P);
304 
305  // Wrap arguments in vectors
306  VectorView<const T_y> y_vec(y);
307  VectorView<const T_loc> mu_vec(mu);
308  VectorView<const T_scale> lambda_vec(lambda);
309  VectorView<const T_shape> alpha_vec(alpha);
310  size_t N = max_size(y, mu, lambda, alpha);
311 
312  agrad::OperandsAndPartials<T_y, T_loc, T_scale, T_shape>
313  operands_and_partials(y, mu, lambda, alpha);
314 
315  DoubleVectorView<true,
316  is_vector<T_y>::value
317  || is_vector<T_loc>::value
318  || is_vector<T_scale>::value
319  || is_vector<T_shape>::value>
320  cdf_log(N);
321 
322  DoubleVectorView<true,
323  is_vector<T_y>::value
324  || is_vector<T_loc>::value
325  || is_vector<T_scale>::value
326  || is_vector<T_shape>::value>
327  inv_p1_pow_alpha_minus_one(N);
328 
329  DoubleVectorView<!is_constant_struct<T_shape>::value,
330  is_vector<T_y>::value
331  || is_vector<T_loc>::value
332  || is_vector<T_scale>::value
333  || is_vector<T_shape>::value>
334  log_1p_y_over_lambda(N);
335 
336  for (size_t i = 0; i < N; i++) {
337  const double temp = 1.0 + (value_of(y_vec[i])
338  - value_of(mu_vec[i]))
339  / value_of(lambda_vec[i]);
340  const double p1_pow_alpha = pow(temp, value_of(alpha_vec[i]));
341  cdf_log[i] = log1m(1.0 / p1_pow_alpha);
342 
343  inv_p1_pow_alpha_minus_one[i] = 1.0 / (p1_pow_alpha - 1.0);
344 
345  if (!is_constant_struct<T_shape>::value)
346  log_1p_y_over_lambda[i] = log(temp);
347  }
348 
349  // Compute vectorized CDF and its gradients
350 
351  for (size_t n = 0; n < N; n++) {
352  // Pull out values
353  const double y_dbl = value_of(y_vec[n]);
354  const double mu_dbl = value_of(mu_vec[n]);
355  const double lambda_dbl = value_of(lambda_vec[n]);
356  const double alpha_dbl = value_of(alpha_vec[n]);
357 
358  const double grad_1_2 = alpha_dbl
359  * inv_p1_pow_alpha_minus_one[n] / (lambda_dbl - mu_dbl + y_dbl);
360 
361  // Compute
362  P += cdf_log[n];
363 
364  if (!is_constant_struct<T_y>::value)
365  operands_and_partials.d_x1[n] += grad_1_2;
366  if (!is_constant_struct<T_loc>::value)
367  operands_and_partials.d_x2[n] -= grad_1_2;
368  if (!is_constant_struct<T_scale>::value)
369  operands_and_partials.d_x3[n] += (mu_dbl - y_dbl) * grad_1_2
370  / lambda_dbl;
371  if (!is_constant_struct<T_shape>::value)
372  operands_and_partials.d_x4[n] += log_1p_y_over_lambda[n]
373  * inv_p1_pow_alpha_minus_one[n];
374  }
375 
376  return operands_and_partials.to_var(P);
377  }
378 
379  template <typename T_y, typename T_loc, typename T_scale, typename T_shape>
380  typename return_type<T_y, T_loc, T_scale, T_shape>::type
381  pareto_type_2_ccdf_log(const T_y& y, const T_loc& mu,
382  const T_scale& lambda, const T_shape& alpha) {
383 
384  // Check sizes
385  // Size checks
386  if ( !( stan::length(y)
387  && stan::length(mu)
388  && stan::length(lambda)
389  && stan::length(alpha) ) )
390  return 0.0;
391 
392  // Check errors
393  static const char* function = "stan::prob::pareto_type_2_ccdf_log(%1%)";
394 
395  using stan::math::check_greater_or_equal;
396  using stan::math::check_positive_finite;
397  using stan::math::check_not_nan;
398  using stan::math::check_greater_or_equal;
399  using stan::math::check_consistent_sizes;
400  using stan::math::check_nonnegative;
401  using stan::math::value_of;
402 
403  double P(0.0);
404 
405  check_greater_or_equal(function, y, mu, "Random variable", &P);
406  check_not_nan(function, y, "Random variable", &P);
407  check_nonnegative(function, y, "Random variable", &P);
408  check_positive_finite(function, lambda, "Scale parameter", &P);
409  check_positive_finite(function, alpha, "Shape parameter", &P);
410  check_consistent_sizes(function, y, lambda, alpha,
411  "Random variable", "Scale parameter",
412  "Shape parameter", &P);
413 
414  // Wrap arguments in vectors
415  VectorView<const T_y> y_vec(y);
416  VectorView<const T_loc> mu_vec(mu);
417  VectorView<const T_scale> lambda_vec(lambda);
418  VectorView<const T_shape> alpha_vec(alpha);
419  size_t N = max_size(y, mu, lambda, alpha);
420 
421  agrad::OperandsAndPartials<T_y, T_loc, T_scale, T_shape>
422  operands_and_partials(y, mu, lambda, alpha);
423 
424  DoubleVectorView<true,
425  is_vector<T_y>::value
426  || is_vector<T_loc>::value
427  || is_vector<T_scale>::value
428  || is_vector<T_shape>::value>
429  ccdf_log(N);
430 
431  DoubleVectorView<!is_constant_struct<T_y>::value
432  || !is_constant_struct<T_loc>::value
433  || !is_constant_struct<T_scale>::value
434  || !is_constant_struct<T_shape>::value,
435  is_vector<T_y>::value
436  || is_vector<T_loc>::value
437  || is_vector<T_scale>::value
438  || is_vector<T_shape>::value>
439  a_over_lambda_plus_y(N);
440 
441  DoubleVectorView<!is_constant_struct<T_shape>::value,
442  is_vector<T_y>::value
443  || is_vector<T_loc>::value
444  || is_vector<T_scale>::value
445  || is_vector<T_shape>::value>
446  log_1p_y_over_lambda(N);
447 
448  for (size_t i = 0; i < N; i++) {
449  const double y_dbl = value_of(y_vec[i]);
450  const double mu_dbl = value_of(mu_vec[i]);
451  const double lambda_dbl = value_of(lambda_vec[i]);
452  const double alpha_dbl = value_of(alpha_vec[i]);
453  const double temp = 1.0 + (y_dbl - mu_dbl) / lambda_dbl;
454  const double log_temp = log(temp);
455 
456  ccdf_log[i] = -alpha_dbl * log_temp;
457 
458  if (!is_constant_struct<T_y>::value
459  || !is_constant_struct<T_loc>::value
460  || !is_constant_struct<T_scale>::value
461  || !is_constant_struct<T_shape>::value)
462  a_over_lambda_plus_y[i] = alpha_dbl / (y_dbl - mu_dbl + lambda_dbl);
463 
464  if (!is_constant_struct<T_shape>::value)
465  log_1p_y_over_lambda[i] = log_temp;
466  }
467 
468  // Compute vectorized CDF and its gradients
469 
470  for (size_t n = 0; n < N; n++) {
471  // Pull out values
472  const double y_dbl = value_of(y_vec[n]);
473  const double mu_dbl = value_of(mu_vec[n]);
474  const double lambda_dbl = value_of(lambda_vec[n]);
475 
476  // Compute
477  P += ccdf_log[n];
478 
479  if (!is_constant_struct<T_y>::value)
480  operands_and_partials.d_x1[n] -= a_over_lambda_plus_y[n];
481  if (!is_constant_struct<T_loc>::value)
482  operands_and_partials.d_x2[n] += a_over_lambda_plus_y[n];
483  if (!is_constant_struct<T_scale>::value)
484  operands_and_partials.d_x3[n] += a_over_lambda_plus_y[n]
485  * (y_dbl - mu_dbl) / lambda_dbl;
486  if (!is_constant_struct<T_shape>::value)
487  operands_and_partials.d_x4[n] -= log_1p_y_over_lambda[n];
488  }
489 
490  return operands_and_partials.to_var(P);
491  }
492 
493  template <class RNG>
494  inline double
495  pareto_type_2_rng(const double mu,
496  const double lambda,
497  const double alpha,
498  RNG& rng) {
499  static const char* function = "stan::prob::pareto_type_2_rng(%1%)";
500 
501  stan::math::check_positive(function, lambda, "scale parameter",
502  (double*)0);
503 
504  double uniform_01 = stan::prob::uniform_rng(0.0, 1.0, rng);
505 
506 
507  return (std::pow(1.0 - uniform_01, -1.0 / alpha) - 1.0) * lambda + mu;
508  }
509  }
510 }
511 #endif
stan::agrad::log1m
fvar< T > log1m(const fvar< T > &x)
Definition: log1m.hpp:16
stan::prob::pareto_type_2_ccdf_log
return_type< T_y, T_loc, T_scale, T_shape >::type pareto_type_2_ccdf_log(const T_y &y, const T_loc &mu, const T_scale &lambda, const T_shape &alpha)
Definition: pareto_type_2.hpp:381
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
stan::agrad::pow
fvar< T > pow(const fvar< T > &x1, const fvar< T > &x2)
Definition: pow.hpp:17
stan::prob::pareto_type_2_rng
double pareto_type_2_rng(const double mu, const double lambda, const double alpha, RNG &rng)
Definition: pareto_type_2.hpp:495
error_handling.hpp
stan::prob::pareto_type_2_cdf_log
return_type< T_y, T_loc, T_scale, T_shape >::type pareto_type_2_cdf_log(const T_y &y, const T_loc &mu, const T_scale &lambda, const T_shape &alpha)
Definition: pareto_type_2.hpp:270
stan::prob::pareto_type_2_cdf
return_type< T_y, T_loc, T_scale, T_shape >::type pareto_type_2_cdf(const T_y &y, const T_loc &mu, const T_scale &lambda, const T_shape &alpha)
Definition: pareto_type_2.hpp:140
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
stan::math::check_finite
bool check_finite(const char *function, const T_y &y, const char *name, T_result *result)
Checks if the variable y is finite.
Definition: check_finite.hpp:52
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::is_vector
Definition: traits.hpp:83
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::agrad::OperandsAndPartials::d_x2
VectorView< double *, is_vector< T2 >::value, is_constant_struct< T2 >::value > d_x2
Definition: partials_vari.hpp:83
stan::prob::uniform_rng
double uniform_rng(const double alpha, const double beta, RNG &rng)
Definition: uniform.hpp:339
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::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::math::check_positive
bool check_positive(const char *function, const T_y &y, const char *name, T_result *result)
Definition: check_positive.hpp:54
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::OperandsAndPartials::d_x4
VectorView< double *, is_vector< T4 >::value, is_constant_struct< T4 >::value > d_x4
Definition: partials_vari.hpp:85
value_of.hpp
stan::prob::pareto_type_2_log
return_type< T_y, T_loc, T_scale, T_shape >::type pareto_type_2_log(const T_y &y, const T_loc &mu, const T_scale &lambda, const T_shape &alpha)
Definition: pareto_type_2.hpp:24
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::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::agrad::log1p
fvar< T > log1p(const fvar< T > &x)
Definition: log1p.hpp:16
stan::math::log1m
boost::math::tools::promote_args< T >::type log1m(T x)
Return the natural logarithm of one minus the specified value.
Definition: log1m.hpp:40
     [ Stan Home Page ] © 2011–2014, Stan Development Team.