Automatic Differentiation
 
Loading...
Searching...
No Matches
logistic_cdf.hpp
Go to the documentation of this file.
1#ifndef STAN_MATH_PRIM_PROB_LOGISTIC_CDF_HPP
2#define STAN_MATH_PRIM_PROB_LOGISTIC_CDF_HPP
3
16#include <cmath>
17
18namespace stan {
19namespace math {
20
21// Logistic(y|mu, sigma) [sigma > 0]
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 T_y_ref = ref_type_t<T_y>;
30 using T_mu_ref = ref_type_t<T_loc>;
31 using T_sigma_ref = ref_type_t<T_scale>;
32 static constexpr const char* function = "logistic_cdf";
33 check_consistent_sizes(function, "Random variable", y, "Location parameter",
34 mu, "Scale parameter", sigma);
35 T_y_ref y_ref = y;
36 T_mu_ref mu_ref = mu;
37 T_sigma_ref sigma_ref = sigma;
38 check_not_nan(function, "Random variable", y_ref);
39 check_finite(function, "Location parameter", mu_ref);
40 check_positive_finite(function, "Scale parameter", sigma_ref);
41
42 if (size_zero(y, mu, sigma)) {
43 return 1.0;
44 }
45
46 T_partials_return P(1.0);
47 auto ops_partials = make_partials_propagator(y_ref, mu_ref, sigma_ref);
48
49 scalar_seq_view<T_y_ref> y_vec(y_ref);
50 scalar_seq_view<T_mu_ref> mu_vec(mu_ref);
51 scalar_seq_view<T_sigma_ref> sigma_vec(sigma_ref);
52 size_t N = max_size(y, mu, sigma);
53
54 // Explicit return for extreme values
55 // The gradients are technically ill-defined, but treated as zero
56 for (size_t i = 0; i < stan::math::size(y); i++) {
57 if (y_vec.val(i) == NEGATIVE_INFTY) {
58 return ops_partials.build(0.0);
59 }
60 }
61
62 for (size_t n = 0; n < N; n++) {
63 // Explicit results for extreme values
64 // The gradients are technically ill-defined, but treated as zero
65 if (y_vec.val(n) == INFTY) {
66 continue;
67 }
68
69 const T_partials_return y_dbl = y_vec.val(n);
70 const T_partials_return mu_dbl = mu_vec.val(n);
71 const T_partials_return sigma_dbl = sigma_vec.val(n);
72 const T_partials_return sigma_inv_vec = 1.0 / sigma_vec.val(n);
73
74 // TODO(Andrew) Further simplify derivatives and log scale below
75 const T_partials_return Pn = inv_logit((y_dbl - mu_dbl) * sigma_inv_vec);
76
77 P *= 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
95 for (size_t n = 0; n < stan::math::size(y); ++n) {
96 partials<0>(ops_partials)[n] *= P;
97 }
98 }
100 for (size_t n = 0; n < stan::math::size(mu); ++n) {
101 partials<1>(ops_partials)[n] *= P;
102 }
103 }
105 for (size_t n = 0; n < stan::math::size(sigma); ++n) {
106 partials<2>(ops_partials)[n] *= P;
107 }
108 }
109 return ops_partials.build(P);
110}
111
112} // namespace math
113} // namespace stan
114#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_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.
return_type_t< T_y_cl, T_loc_cl, T_scale_cl > logistic_cdf(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.
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
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...