Automatic Differentiation
 
Loading...
Searching...
No Matches
elt_function_cl.hpp
Go to the documentation of this file.
1#ifndef STAN_MATH_OPENCL_KERNEL_GENERATOR_ELT_FUNCTION_CL_HPP
2#define STAN_MATH_OPENCL_KERNEL_GENERATOR_ELT_FUNCTION_CL_HPP
3#ifdef STAN_OPENCL
4
5#include <stan/math/prim/meta.hpp>
6#include <stan/math/opencl/kernels/device_functions/binomial_coefficient_log.hpp>
7#include <stan/math/opencl/kernels/device_functions/beta.hpp>
8#include <stan/math/opencl/kernels/device_functions/digamma.hpp>
9#include <stan/math/opencl/kernels/device_functions/erfcx.hpp>
10#include <stan/math/opencl/kernels/device_functions/inv_logit.hpp>
11#include <stan/math/opencl/kernels/device_functions/inv_Phi.hpp>
12#include <stan/math/opencl/kernels/device_functions/inv_square.hpp>
13#include <stan/math/opencl/kernels/device_functions/lbeta.hpp>
14#include <stan/math/opencl/kernels/device_functions/lgamma_stirling.hpp>
15#include <stan/math/opencl/kernels/device_functions/lgamma_stirling_diff.hpp>
16#include <stan/math/opencl/kernels/device_functions/lmultiply.hpp>
17#include <stan/math/opencl/kernels/device_functions/log_inv_logit.hpp>
18#include <stan/math/opencl/kernels/device_functions/log_inv_logit_diff.hpp>
19#include <stan/math/opencl/kernels/device_functions/log_diff_exp.hpp>
20#include <stan/math/opencl/kernels/device_functions/log1m.hpp>
21#include <stan/math/opencl/kernels/device_functions/log1m_exp.hpp>
22#include <stan/math/opencl/kernels/device_functions/log1m_inv_logit.hpp>
23#include <stan/math/opencl/kernels/device_functions/log1p_exp.hpp>
24#include <stan/math/opencl/kernels/device_functions/logit.hpp>
25#include <stan/math/opencl/kernels/device_functions/multiply_log.hpp>
26#include <stan/math/opencl/kernels/device_functions/Phi.hpp>
27#include <stan/math/opencl/kernels/device_functions/Phi_approx.hpp>
28#include <stan/math/opencl/kernels/device_functions/std_normal_lcdf.hpp>
29#include <stan/math/opencl/kernels/device_functions/trigamma.hpp>
30#include <stan/math/opencl/matrix_cl_view.hpp>
31#include <stan/math/opencl/kernel_generator/common_return_scalar.hpp>
32#include <stan/math/opencl/kernel_generator/type_str.hpp>
33#include <stan/math/opencl/kernel_generator/name_generator.hpp>
34#include <stan/math/opencl/kernel_generator/operation_cl.hpp>
35#include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
36#include <array>
37#include <string>
38#include <type_traits>
39#include <set>
40#include <utility>
41
42namespace stan {
43namespace math {
44
55template <typename Derived, typename Scal, typename... T>
56class elt_function_cl : public operation_cl<Derived, Scal, T...> {
57 public:
58 using Scalar = Scal;
59 using base = operation_cl<Derived, Scalar, T...>;
60 using base::var_name_;
61
67 elt_function_cl(const std::string& fun, T&&... args) // NOLINT
68 : base(std::forward<T>(args)...), fun_(fun) {}
69
78 inline kernel_parts generate(
79 const std::string& row_index_name, const std::string& col_index_name,
80 const bool view_handled,
81 std::conditional_t<false, T, const std::string&>... var_names_arg) const {
82 kernel_parts res{};
83
84 for (const char* incl : base::derived().includes) {
85 res.includes += incl;
86 }
87 std::array<std::string, sizeof...(T)> var_names_arg_arr
88 = {(var_names_arg + ", ")...};
89 std::string var_names_list = std::accumulate(
90 var_names_arg_arr.begin(), var_names_arg_arr.end(), std::string());
91 res.body = type_str<Scalar>() + " " + var_name_ + " = " + fun_ + "((double)"
92 + var_names_list.substr(0, var_names_list.size() - 2) + ");\n";
93 return res;
94 }
95
96 protected:
97 std::string fun_;
98};
99
106#define ADD_BINARY_FUNCTION_WITH_INCLUDES(fun, ...) \
107 template <typename T1, typename T2> \
108 class fun##_ : public elt_function_cl<fun##_<T1, T2>, double, T1, T2> { \
109 using base = elt_function_cl<fun##_<T1, T2>, double, T1, T2>; \
110 using base::arguments_; \
111 \
112 public: \
113 using base::rows; \
114 using base::cols; \
115 static const std::vector<const char*> includes; \
116 explicit fun##_(T1&& a, T2&& b) \
117 : base(#fun, std::forward<T1>(a), std::forward<T2>(b)) { \
118 if (a.rows() != base::dynamic && b.rows() != base::dynamic) { \
119 check_size_match(#fun, "Rows of ", "a", a.rows(), "rows of ", "b", \
120 b.rows()); \
121 } \
122 if (a.cols() != base::dynamic && b.cols() != base::dynamic) { \
123 check_size_match(#fun, "Columns of ", "a", a.cols(), "columns of ", \
124 "b", b.cols()); \
125 } \
126 } \
127 inline auto deep_copy() const { \
128 auto&& arg1_copy = this->template get_arg<0>().deep_copy(); \
129 auto&& arg2_copy = this->template get_arg<1>().deep_copy(); \
130 return fun##_<std::remove_reference_t<decltype(arg1_copy)>, \
131 std::remove_reference_t<decltype(arg2_copy)>>{ \
132 std::move(arg1_copy), std::move(arg2_copy)}; \
133 } \
134 inline std::pair<int, int> extreme_diagonals() const { \
135 return {-rows() + 1, cols() - 1}; \
136 } \
137 }; \
138 \
139 template <typename T1, typename T2, \
140 require_all_kernel_expressions_t<T1, T2>* = nullptr, \
141 require_any_not_stan_scalar_t<T1, T2>* = nullptr> \
142 inline fun##_<as_operation_cl_t<T1>, as_operation_cl_t<T2>> fun(T1&& a, \
143 T2&& b) { \
144 return fun##_<as_operation_cl_t<T1>, as_operation_cl_t<T2>>( \
145 as_operation_cl(std::forward<T1>(a)), \
146 as_operation_cl(std::forward<T2>(b))); \
147 } \
148 template <typename T1, typename T2> \
149 const std::vector<const char*> fun##_<T1, T2>::includes{__VA_ARGS__};
150
157#define ADD_UNARY_FUNCTION_WITH_INCLUDES(fun, ...) \
158 template <typename T> \
159 class fun##_ : public elt_function_cl<fun##_<T>, double, T> { \
160 using base = elt_function_cl<fun##_<T>, double, T>; \
161 using base::arguments_; \
162 \
163 public: \
164 using base::rows; \
165 using base::cols; \
166 static const std::vector<const char*> includes; \
167 explicit fun##_(T&& a) : base(#fun, std::forward<T>(a)) {} \
168 inline auto deep_copy() const { \
169 auto&& arg_copy = this->template get_arg<0>().deep_copy(); \
170 return fun##_<std::remove_reference_t<decltype(arg_copy)>>{ \
171 std::move(arg_copy)}; \
172 } \
173 inline std::pair<int, int> extreme_diagonals() const { \
174 return {-rows() + 1, cols() - 1}; \
175 } \
176 }; \
177 \
178 template <typename T, typename Cond \
179 = require_all_kernel_expressions_and_none_scalar_t<T>> \
180 inline fun##_<as_operation_cl_t<T>> fun(T&& a) { \
181 return fun##_<as_operation_cl_t<T>>(as_operation_cl(std::forward<T>(a))); \
182 } \
183 template <typename T> \
184 const std::vector<const char*> fun##_<T>::includes{__VA_ARGS__};
185
191#define ADD_UNARY_FUNCTION(fun) ADD_UNARY_FUNCTION_WITH_INCLUDES(fun)
192
199#define ADD_UNARY_FUNCTION_PASS_ZERO(fun) \
200 template <typename T> \
201 class fun##_ : public elt_function_cl<fun##_<T>, double, T> { \
202 using base = elt_function_cl<fun##_<T>, double, T>; \
203 using base::arguments_; \
204 \
205 public: \
206 using base::rows; \
207 using base::cols; \
208 static constexpr auto view_transitivness = std::make_tuple(true); \
209 static const std::vector<const char*> includes; \
210 explicit fun##_(T&& a) : base(#fun, std::forward<T>(a)) {} \
211 inline auto deep_copy() const { \
212 auto&& arg_copy = this->template get_arg<0>().deep_copy(); \
213 return fun##_<std::remove_reference_t<decltype(arg_copy)>>{ \
214 std::move(arg_copy)}; \
215 } \
216 }; \
217 \
218 template <typename T, typename Cond \
219 = require_all_kernel_expressions_and_none_scalar_t<T>> \
220 inline fun##_<as_operation_cl_t<T>> fun(T&& a) { \
221 return fun##_<as_operation_cl_t<T>>(as_operation_cl(std::forward<T>(a))); \
222 } \
223 template <typename T> \
224 const std::vector<const char*> fun##_<T>::includes{};
225
232#define ADD_CLASSIFICATION_FUNCTION(fun, ...) \
233 template <typename T> \
234 class fun##_ : public elt_function_cl<fun##_<T>, bool, T> { \
235 using base = elt_function_cl<fun##_<T>, bool, T>; \
236 using base::arguments_; \
237 \
238 public: \
239 using base::rows; \
240 using base::cols; \
241 static constexpr auto view_transitivness = std::make_tuple(true); \
242 static const std::vector<const char*> includes; \
243 explicit fun##_(T&& a) : base(#fun, std::forward<T>(a)) {} \
244 inline auto deep_copy() const { \
245 auto&& arg_copy = this->template get_arg<0>().deep_copy(); \
246 return fun##_<std::remove_reference_t<decltype(arg_copy)>>{ \
247 std::move(arg_copy)}; \
248 } \
249 inline std::pair<int, int> extreme_diagonals() const { \
250 return __VA_ARGS__; \
251 } \
252 }; \
253 \
254 template <typename T, typename Cond \
255 = require_all_kernel_expressions_and_none_scalar_t<T>> \
256 inline fun##_<as_operation_cl_t<T>> fun(T&& a) { \
257 return fun##_<as_operation_cl_t<T>>(as_operation_cl(std::forward<T>(a))); \
258 } \
259 template <typename T> \
260 const std::vector<const char*> fun##_<T>::includes{};
261
262ADD_UNARY_FUNCTION(rsqrt)
263ADD_UNARY_FUNCTION_PASS_ZERO(sqrt)
264ADD_UNARY_FUNCTION_PASS_ZERO(cbrt)
265
266ADD_UNARY_FUNCTION(exp)
267ADD_UNARY_FUNCTION(exp2)
268ADD_UNARY_FUNCTION_PASS_ZERO(expm1)
269
270ADD_UNARY_FUNCTION(log)
271ADD_UNARY_FUNCTION(log2)
272ADD_UNARY_FUNCTION(log10)
273ADD_UNARY_FUNCTION_PASS_ZERO(log1p)
274
275ADD_UNARY_FUNCTION_PASS_ZERO(sin)
276ADD_UNARY_FUNCTION_PASS_ZERO(sinh)
277ADD_UNARY_FUNCTION(cos)
278ADD_UNARY_FUNCTION(cosh)
279ADD_UNARY_FUNCTION_PASS_ZERO(tan)
280ADD_UNARY_FUNCTION_PASS_ZERO(tanh)
281ADD_UNARY_FUNCTION_PASS_ZERO(asin)
282ADD_UNARY_FUNCTION_PASS_ZERO(asinh)
283ADD_UNARY_FUNCTION(acos)
284ADD_UNARY_FUNCTION(acosh)
285ADD_UNARY_FUNCTION_PASS_ZERO(atan)
286ADD_UNARY_FUNCTION_PASS_ZERO(atanh)
287
288ADD_UNARY_FUNCTION(tgamma)
289ADD_UNARY_FUNCTION(lgamma)
290ADD_UNARY_FUNCTION_PASS_ZERO(erf)
291ADD_UNARY_FUNCTION(erfc)
292
293ADD_UNARY_FUNCTION_PASS_ZERO(floor)
294ADD_UNARY_FUNCTION_PASS_ZERO(round)
295ADD_UNARY_FUNCTION_PASS_ZERO(ceil)
296ADD_UNARY_FUNCTION_PASS_ZERO(fabs)
297ADD_UNARY_FUNCTION_PASS_ZERO(trunc)
298
299ADD_UNARY_FUNCTION_WITH_INCLUDES(digamma,
300 opencl_kernels::digamma_device_function)
301ADD_UNARY_FUNCTION_WITH_INCLUDES(erfcx, opencl_kernels::erfcx_device_function)
302ADD_UNARY_FUNCTION_WITH_INCLUDES(log1m, opencl_kernels::log1m_device_function)
303ADD_UNARY_FUNCTION_WITH_INCLUDES(log_inv_logit,
304 opencl_kernels::log1p_exp_device_function,
305 opencl_kernels::log_inv_logit_device_function)
306ADD_UNARY_FUNCTION_WITH_INCLUDES(log1m_exp,
307 opencl_kernels::log1m_exp_device_function)
308ADD_UNARY_FUNCTION_WITH_INCLUDES(log1p_exp,
309 opencl_kernels::log1p_exp_device_function)
310ADD_UNARY_FUNCTION_WITH_INCLUDES(inv_square,
311 opencl_kernels::inv_square_device_function)
312ADD_UNARY_FUNCTION_WITH_INCLUDES(inv_logit,
313 opencl_kernels::inv_logit_device_function)
314ADD_UNARY_FUNCTION_WITH_INCLUDES(logit, opencl_kernels::log1m_device_function,
315 opencl_kernels::logit_device_function)
316ADD_UNARY_FUNCTION_WITH_INCLUDES(Phi, opencl_kernels::phi_device_function)
317ADD_UNARY_FUNCTION_WITH_INCLUDES(Phi_approx,
318 opencl_kernels::inv_logit_device_function,
319 opencl_kernels::phi_approx_device_function)
320ADD_UNARY_FUNCTION_WITH_INCLUDES(
321 std_normal_lcdf_scaled_impl,
322 opencl_kernels::std_normal_lcdf_device_function)
323ADD_UNARY_FUNCTION_WITH_INCLUDES(
324 std_normal_lcdf_dscaled_impl,
325 opencl_kernels::std_normal_lcdf_device_function)
326ADD_UNARY_FUNCTION_WITH_INCLUDES(inv_Phi, opencl_kernels::log1m_device_function,
327 opencl_kernels::phi_device_function,
328 opencl_kernels::inv_phi_device_function)
329ADD_UNARY_FUNCTION_WITH_INCLUDES(
330 log1m_inv_logit, opencl_kernels::log1p_exp_device_function,
331 opencl_kernels::log1m_inv_logit_device_function)
332ADD_UNARY_FUNCTION_WITH_INCLUDES(trigamma,
333 opencl_kernels::trigamma_device_function)
334ADD_UNARY_FUNCTION_WITH_INCLUDES(
335 square,
336 "\n#ifndef STAN_MATH_OPENCL_KERNELS_DEVICE_FUNCTIONS_SQUARE\n"
337 "#define STAN_MATH_OPENCL_KERNELS_DEVICE_FUNCTIONS_SQUARE\n"
338 "double square(double x){return x*x;}\n"
339 "#endif\n")
340
341ADD_CLASSIFICATION_FUNCTION(isfinite, {-rows() + 1, cols() - 1})
342ADD_CLASSIFICATION_FUNCTION(isinf,
343 this->template get_arg<0>().extreme_diagonals())
344ADD_CLASSIFICATION_FUNCTION(isnan,
345 this->template get_arg<0>().extreme_diagonals())
346
347ADD_BINARY_FUNCTION_WITH_INCLUDES(fdim)
348ADD_BINARY_FUNCTION_WITH_INCLUDES(fmax)
349ADD_BINARY_FUNCTION_WITH_INCLUDES(fmin)
350ADD_BINARY_FUNCTION_WITH_INCLUDES(fmod)
351ADD_BINARY_FUNCTION_WITH_INCLUDES(hypot)
352ADD_BINARY_FUNCTION_WITH_INCLUDES(ldexp)
353ADD_BINARY_FUNCTION_WITH_INCLUDES(pow)
354ADD_BINARY_FUNCTION_WITH_INCLUDES(copysign)
355
356ADD_BINARY_FUNCTION_WITH_INCLUDES(
357 erfcx_derivative, stan::math::opencl_kernels::erfcx_device_function)
358ADD_BINARY_FUNCTION_WITH_INCLUDES(
359 beta, stan::math::opencl_kernels::beta_device_function)
360ADD_BINARY_FUNCTION_WITH_INCLUDES(
361 binomial_coefficient_log,
362 stan::math::opencl_kernels::lgamma_stirling_device_function,
363 stan::math::opencl_kernels::lgamma_stirling_diff_device_function,
364 stan::math::opencl_kernels::lbeta_device_function,
365 stan::math::opencl_kernels::binomial_coefficient_log_device_function)
366template <typename T1, typename T2>
367class lbeta_ : public elt_function_cl<lbeta_<T1, T2>, double, T1, T2> {
368 using base = elt_function_cl<lbeta_<T1, T2>, double, T1, T2>;
369 using base::arguments_;
370
371 public:
372 using base::cols;
373 using base::rows;
374 static const std::vector<const char*> includes;
375 explicit lbeta_(T1&& a, T2&& b)
376 : base("stan_lbeta", std::forward<T1>(a), std::forward<T2>(b)) {
377 if (a.rows() != base::dynamic && b.rows() != base::dynamic) {
378 check_size_match("lbeta", "Rows of ", "a", a.rows(), "rows of ", "b",
379 b.rows());
380 }
381 if (a.cols() != base::dynamic && b.cols() != base::dynamic) {
382 check_size_match("lbeta", "Columns of ", "a", a.cols(), "columns of ",
383 "b", b.cols());
384 }
385 }
386 inline auto deep_copy() const {
387 auto&& arg1_copy = this->template get_arg<0>().deep_copy();
388 auto&& arg2_copy = this->template get_arg<1>().deep_copy();
389 return lbeta_<std::remove_reference_t<decltype(arg1_copy)>,
390 std::remove_reference_t<decltype(arg2_copy)>>{
391 std::move(arg1_copy), std::move(arg2_copy)};
392 }
393 inline std::pair<int, int> extreme_diagonals() const {
394 return {-rows() + 1, cols() - 1};
395 }
396};
397
398template <typename T1, typename T2,
399 require_all_kernel_expressions_t<T1, T2>* = nullptr,
400 require_any_not_stan_scalar_t<T1, T2>* = nullptr>
401inline lbeta_<as_operation_cl_t<T1>, as_operation_cl_t<T2>> lbeta(T1&& a,
402 T2&& b) {
403 return lbeta_<as_operation_cl_t<T1>, as_operation_cl_t<T2>>(
404 as_operation_cl(std::forward<T1>(a)),
405 as_operation_cl(std::forward<T2>(b)));
406}
407
408template <typename T1, typename T2>
409const std::vector<const char*> lbeta_<T1, T2>::includes{
410 stan::math::opencl_kernels::lgamma_stirling_device_function,
411 stan::math::opencl_kernels::lgamma_stirling_diff_device_function,
412 stan::math::opencl_kernels::lbeta_device_function};
413ADD_BINARY_FUNCTION_WITH_INCLUDES(
414 log_inv_logit_diff, opencl_kernels::log1p_exp_device_function,
415 opencl_kernels::log1m_exp_device_function,
416 opencl_kernels::log_inv_logit_diff_device_function)
417ADD_BINARY_FUNCTION_WITH_INCLUDES(log_diff_exp,
418 opencl_kernels::log1m_exp_device_function,
419 opencl_kernels::log_diff_exp_device_function)
420ADD_BINARY_FUNCTION_WITH_INCLUDES(
421 multiply_log, stan::math::opencl_kernels::multiply_log_device_function)
422ADD_BINARY_FUNCTION_WITH_INCLUDES(
423 lmultiply, stan::math::opencl_kernels::lmultiply_device_function)
424
425#undef ADD_BINARY_FUNCTION_WITH_INCLUDES
426#undef ADD_UNARY_FUNCTION_WITH_INCLUDES
427#undef ADD_UNARY_FUNCTION
428#undef ADD_UNARY_FUNCTION_PASS_ZERO
429#undef ADD_CLASSIFICATION_FUNCTION
430
432} // namespace math
433} // namespace stan
434#endif
435#endif
as_operation_cl.hpp
stan::math::elt_function_cl::fun_
std::string fun_
Definition elt_function_cl.hpp:97
stan::math::elt_function_cl::elt_function_cl
elt_function_cl(const std::string &fun, T &&... args)
Constructor.
Definition elt_function_cl.hpp:67
stan::math::elt_function_cl::var_name_
std::string var_name_
Definition operation_cl.hpp:111
stan::math::elt_function_cl::Scalar
Scal Scalar
Definition elt_function_cl.hpp:58
stan::math::elt_function_cl::generate
kernel_parts generate(const std::string &row_index_name, const std::string &col_index_name, const bool view_handled, std::conditional_t< false, T, const std::string & >... var_names_arg) const
Generates kernel code for this expression.
Definition elt_function_cl.hpp:78
stan::math::elt_function_cl
Represents an element-wise function in kernel generator expressions.
Definition elt_function_cl.hpp:56
stan::math::operation_cl::derived
Derived & derived()
Casts the instance into its derived type.
Definition operation_cl.hpp:119
stan::math::operation_cl::var_name_
std::string var_name_
Definition operation_cl.hpp:111
stan::math::operation_cl
Base for all kernel generator operations.
Definition operation_cl.hpp:103
common_return_scalar.hpp
stan::math::rsqrt
rsqrt_< as_operation_cl_t< T > > rsqrt(T &&a)
Definition elt_function_cl.hpp:262
ADD_UNARY_FUNCTION
#define ADD_UNARY_FUNCTION(fun)
Generates a class and function for a general unary function that is defined by OpenCL.
Definition elt_function_cl.hpp:191
ADD_UNARY_FUNCTION_PASS_ZERO
#define ADD_UNARY_FUNCTION_PASS_ZERO(fun)
Generates a class and function for an unary function, defined by OpenCL with special property that it...
Definition elt_function_cl.hpp:199
ADD_UNARY_FUNCTION_WITH_INCLUDES
#define ADD_UNARY_FUNCTION_WITH_INCLUDES(fun,...)
Generates a class and function for a general unary function that is defined by OpenCL or in the inclu...
Definition elt_function_cl.hpp:157
stan::math::std_normal_lcdf_dscaled_impl
std_normal_lcdf_dscaled_impl_< as_operation_cl_t< T > > std_normal_lcdf_dscaled_impl(T &&a)
Definition elt_function_cl.hpp:325
stan::math::std_normal_lcdf_scaled_impl
std_normal_lcdf_scaled_impl_< as_operation_cl_t< T > > std_normal_lcdf_scaled_impl(T &&a)
Definition elt_function_cl.hpp:322
matrix_cl_view.hpp
name_generator.hpp
stan::math::acos
fvar< T > acos(const fvar< T > &x)
Definition acos.hpp:16
stan::math::sin
fvar< T > sin(const fvar< T > &x)
Definition sin.hpp:16
stan::math::acosh
fvar< T > acosh(const fvar< T > &x)
Definition acosh.hpp:16
stan::math::logit
fvar< T > logit(const fvar< T > &x)
Definition logit.hpp:14
stan::math::expm1
fvar< T > expm1(const fvar< T > &x)
Definition expm1.hpp:14
stan::math::atanh
fvar< T > atanh(const fvar< T > &x)
Return inverse hyperbolic tangent of specified value.
Definition atanh.hpp:26
stan::math::inv_square
fvar< T > inv_square(const fvar< T > &x)
Definition inv_square.hpp:13
stan::math::exp2
fvar< T > exp2(const fvar< T > &x)
Definition exp2.hpp:14
stan::math::log2
constexpr double log2()
Return natural logarithm of two.
Definition log2.hpp:17
stan::math::log1m_exp
fvar< T > log1m_exp(const fvar< T > &x)
Return the natural logarithm of one minus the exponentiation of the specified argument.
Definition log1m_exp.hpp:22
stan::math::asinh
fvar< T > asinh(const fvar< T > &x)
Definition asinh.hpp:16
stan::math::cosh
fvar< T > cosh(const fvar< T > &x)
Definition cosh.hpp:16
stan::math::log
fvar< T > log(const fvar< T > &x)
Definition log.hpp:18
stan::math::erf
fvar< T > erf(const fvar< T > &x)
Definition erf.hpp:16
stan::math::inv_logit
auto inv_logit(T &&x)
Returns the inverse logit function applied to the argument.
Definition inv_logit.hpp:20
stan::math::Phi_approx
fvar< T > Phi_approx(const fvar< T > &x)
Return an approximation of the unit normal cumulative distribution function (CDF).
Definition Phi_approx.hpp:25
stan::math::log_inv_logit
fvar< T > log_inv_logit(const fvar< T > &x)
Definition log_inv_logit.hpp:14
stan::math::erfcx
fvar< T > erfcx(const fvar< T > &x)
Return the scaled complementary error function of the argument.
Definition erfcx.hpp:26
stan::math::cbrt
fvar< T > cbrt(const fvar< T > &x)
Return cube root of specified argument.
Definition cbrt.hpp:20
stan::math::sinh
fvar< T > sinh(const fvar< T > &x)
Definition sinh.hpp:15
stan::math::log1p_exp
fvar< T > log1p_exp(const fvar< T > &x)
Definition log1p_exp.hpp:14
stan::math::sqrt
fvar< T > sqrt(const fvar< T > &x)
Definition sqrt.hpp:18
stan::math::atan
fvar< T > atan(const fvar< T > &x)
Definition atan.hpp:16
stan::math::trigamma
fvar< T > trigamma(const fvar< T > &u)
Return the value of the trigamma function at the specified argument (i.e., the second derivative of t...
Definition trigamma.hpp:25
stan::math::tan
fvar< T > tan(const fvar< T > &x)
Definition tan.hpp:16
stan::math::Phi
fvar< T > Phi(const fvar< T > &x)
Definition Phi.hpp:16
stan::math::erfc
fvar< T > erfc(const fvar< T > &x)
Definition erfc.hpp:16
stan::math::log1p
fvar< T > log1p(const fvar< T > &x)
Definition log1p.hpp:12
stan::math::inv_Phi
fvar< T > inv_Phi(const fvar< T > &p)
Definition inv_Phi.hpp:16
stan::math::floor
fvar< T > floor(const fvar< T > &x)
Definition floor.hpp:13
stan::math::lgamma
fvar< T > lgamma(const fvar< T > &x)
Return the natural logarithm of the gamma function applied to the specified argument.
Definition lgamma.hpp:21
stan::math::log10
static constexpr double log10()
Returns the natural logarithm of ten.
Definition constants.hpp:228
stan::math::tanh
fvar< T > tanh(const fvar< T > &x)
Definition tanh.hpp:15
stan::math::cos
fvar< T > cos(const fvar< T > &x)
Definition cos.hpp:16
stan::math::round
fvar< T > round(const fvar< T > &x)
Return the closest integer to the specified argument, with halfway cases rounded away from zero.
Definition round.hpp:24
stan::math::tgamma
fvar< T > tgamma(const fvar< T > &x)
Return the result of applying the gamma function to the specified argument.
Definition tgamma.hpp:21
stan::math::asin
fvar< T > asin(const fvar< T > &x)
Definition asin.hpp:16
stan::math::ceil
fvar< T > ceil(const fvar< T > &x)
Definition ceil.hpp:13
stan::math::log1m
fvar< T > log1m(const fvar< T > &x)
Definition log1m.hpp:12
stan::math::log1m_inv_logit
fvar< T > log1m_inv_logit(const fvar< T > &x)
Return the natural logarithm of one minus the inverse logit of the specified argument.
Definition log1m_inv_logit.hpp:22
stan::math::digamma
fvar< T > digamma(const fvar< T > &x)
Return the derivative of the log gamma function at the specified argument.
Definition digamma.hpp:23
stan::math::square
fvar< T > square(const fvar< T > &x)
Definition square.hpp:12
stan::math::trunc
fvar< T > trunc(const fvar< T > &x)
Return the nearest integral value that is not larger in magnitude than the specified argument.
Definition trunc.hpp:20
stan::math::exp
fvar< T > exp(const fvar< T > &x)
Definition exp.hpp:15
stan
The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation ...
Definition unit_vector_constrain.hpp:15
std
STL namespace.
Phi.hpp
Phi_approx.hpp
beta.hpp
binomial_coefficient_log.hpp
digamma.hpp
erfcx.hpp
inv_Phi.hpp
inv_logit.hpp
inv_square.hpp
lbeta.hpp
lgamma_stirling.hpp
lgamma_stirling_diff.hpp
lmultiply.hpp
log1m.hpp
log1m_exp.hpp
log1m_inv_logit.hpp
log1p_exp.hpp
log_diff_exp.hpp
log_inv_logit.hpp
log_inv_logit_diff.hpp
logit.hpp
multiply_log.hpp
std_normal_lcdf.hpp
trigamma.hpp
operation_cl.hpp
stan::math::kernel_parts::includes
std::string includes
Definition operation_cl.hpp:33
stan::math::kernel_parts
Parts of an OpenCL kernel, generated by an expression.
Definition operation_cl.hpp:32
type_str.hpp