Automatic Differentiation
 
Loading...
Searching...
No Matches
logistic_lcdf.hpp
Go to the documentation of this file.
1#ifndef STAN_MATH_PRIM_PROB_LOGISTIC_LCDF_HPP
2#define STAN_MATH_PRIM_PROB_LOGISTIC_LCDF_HPP
3
17#include <cmath>
18
19namespace stan {
20namespace math {
21
22template <typename T_y, typename T_loc, typename T_scale,
24 T_y, T_loc, T_scale>* = nullptr>
26 const T_scale& sigma) {
27 using T_partials_return = partials_return_t<T_y, T_loc, T_scale>;
28 using std::exp;
29 using std::log;
30 using T_y_ref = ref_type_t<T_y>;
31 using T_mu_ref = ref_type_t<T_loc>;
32 using T_sigma_ref = ref_type_t<T_scale>;
33 static constexpr const char* function = "logistic_lcdf";
34 check_consistent_sizes(function, "Random variable", y, "Location parameter",
35 mu, "Scale parameter", sigma);
36 T_y_ref y_ref = y;
37 T_mu_ref mu_ref = mu;
38 T_sigma_ref sigma_ref = sigma;
39 check_not_nan(function, "Random variable", y_ref);
40 check_finite(function, "Location parameter", mu_ref);
41 check_positive_finite(function, "Scale parameter", sigma_ref);
42
43 if (size_zero(y, mu, sigma)) {
44 return 0;
45 }
46
47 T_partials_return P(0.0);
48 auto ops_partials = make_partials_propagator(y_ref, mu_ref, sigma_ref);
49
50 scalar_seq_view<T_y_ref> y_vec(y_ref);
51 scalar_seq_view<T_mu_ref> mu_vec(mu_ref);
52 scalar_seq_view<T_sigma_ref> sigma_vec(sigma_ref);
53 size_t N = max_size(y, mu, sigma);
54
55 // Explicit return for extreme values
56 // The gradients are technically ill-defined, but treated as zero
57 for (size_t i = 0; i < stan::math::size(y); i++) {
58 if (y_vec.val(i) == NEGATIVE_INFTY) {
59 return ops_partials.build(NEGATIVE_INFTY);
60 }
61 }
62
63 for (size_t n = 0; n < N; n++) {
64 // Explicit results for extreme values
65 // The gradients are technically ill-defined, but treated as zero
66 if (y_vec.val(n) == INFTY) {
67 continue;
68 }
69
70 const T_partials_return y_dbl = y_vec.val(n);
71 const T_partials_return mu_dbl = mu_vec.val(n);
72 const T_partials_return sigma_dbl = sigma_vec.val(n);
73 const T_partials_return sigma_inv_vec = 1.0 / sigma_vec.val(n);
74
75 // TODO(Andrew) Further simplify derivatives and log-scale below
76 const T_partials_return Pn = inv_logit((y_dbl - mu_dbl) * sigma_inv_vec);
77 P += log(Pn);
78
80 partials<0>(ops_partials)[n]
81 += exp(logistic_lpdf(y_dbl, mu_dbl, sigma_dbl)) / Pn;
82 }
84 partials<1>(ops_partials)[n]
85 += -exp(logistic_lpdf(y_dbl, mu_dbl, sigma_dbl)) / Pn;
86 }
88 partials<2>(ops_partials)[n]
89 += -(y_dbl - mu_dbl) * sigma_inv_vec
90 * exp(logistic_lpdf(y_dbl, mu_dbl, sigma_dbl)) / Pn;
91 }
92 }
93 return ops_partials.build(P);
94}
95
96} // namespace math
97} // namespace stan
98#endif
scalar_seq_view provides a uniform sequence-like wrapper around either a scalar or a sequence of scal...
require_all_not_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< Types > >... > require_all_not_nonscalar_prim_or_rev_kernel_expression_t
Require none of the types satisfy is_nonscalar_prim_or_rev_kernel_expression.
return_type_t< T_y_cl, T_loc_cl, T_scale_cl > logistic_lcdf(const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
Returns the logistic cumulative distribution function for the given location, and scale.
return_type_t< T_y_cl, T_loc_cl, T_scale_cl > logistic_lpdf(const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
The log of a logistic density for y with the specified location and scale parameters.
typename return_type< Ts... >::type return_type_t
Convenience type for the return type of the specified template parameters.
int64_t size(const T &m)
Returns the size (number of the elements) of a matrix_cl or var_value<matrix_cl<T>>.
Definition size.hpp:19
bool size_zero(const T &x)
Returns 1 if input is of length 0, returns 0 otherwise.
Definition size_zero.hpp:19
fvar< T > log(const fvar< T > &x)
Definition log.hpp:15
static constexpr double NEGATIVE_INFTY
Negative infinity.
Definition constants.hpp:51
void check_consistent_sizes(const char *)
Trivial no input case, this function is a no-op.
void check_finite(const char *function, const char *name, const T_y &y)
Return true if all values in y are finite.
void check_not_nan(const char *function, const char *name, const T_y &y)
Check if y is not NaN.
fvar< T > inv_logit(const fvar< T > &x)
Returns the inverse logit function applied to the argument.
Definition inv_logit.hpp:20
int64_t max_size(const T1 &x1, const Ts &... xs)
Calculate the size of the largest input.
Definition max_size.hpp:20
auto make_partials_propagator(Ops &&... ops)
Construct an partials_propagator.
void check_positive_finite(const char *function, const char *name, const T_y &y)
Check if y is positive and finite.
static constexpr double INFTY
Positive infinity.
Definition constants.hpp:46
fvar< T > exp(const fvar< T > &x)
Definition exp.hpp:13
typename ref_type_if< true, T >::type ref_type_t
Definition ref_type.hpp:55
typename partials_return_type< Args... >::type partials_return_t
The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation ...
Extends std::true_type when instantiated with zero or more template parameters, all of which extend t...