1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
10 #define _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
11 
12 #include <__config>
13 #include <__random/normal_distribution.h>
14 #include <cmath>
15 #include <iosfwd>
16 #include <limits>
17 
18 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
19 #  pragma GCC system_header
20 #endif
21 
22 _LIBCPP_PUSH_MACROS
23 #include <__undef_macros>
24 
25 _LIBCPP_BEGIN_NAMESPACE_STD
26 
27 #ifdef _LIBCPP_ABI_OLD_LOGNORMAL_DISTRIBUTION
28 
29 template<class _RealType = double>
30 class _LIBCPP_TEMPLATE_VIS lognormal_distribution
31 {
32 public:
33     // types
34     typedef _RealType result_type;
35 
36     class _LIBCPP_TEMPLATE_VIS param_type
37     {
38         normal_distribution<result_type> __nd_;
39     public:
40         typedef lognormal_distribution distribution_type;
41 
42         _LIBCPP_INLINE_VISIBILITY
43         explicit param_type(result_type __m = 0, result_type __s = 1)
44             : __nd_(__m, __s) {}
45 
46         _LIBCPP_INLINE_VISIBILITY
47         result_type m() const {return __nd_.mean();}
48         _LIBCPP_INLINE_VISIBILITY
49         result_type s() const {return __nd_.stddev();}
50 
51         friend _LIBCPP_INLINE_VISIBILITY
52             bool operator==(const param_type& __x, const param_type& __y)
53             {return __x.__nd_ == __y.__nd_;}
54         friend _LIBCPP_INLINE_VISIBILITY
55             bool operator!=(const param_type& __x, const param_type& __y)
56             {return !(__x == __y);}
57         friend class lognormal_distribution;
58 
59         template <class _CharT, class _Traits, class _RT>
60         friend
61         basic_ostream<_CharT, _Traits>&
62         operator<<(basic_ostream<_CharT, _Traits>& __os,
63                    const lognormal_distribution<_RT>& __x);
64 
65         template <class _CharT, class _Traits, class _RT>
66         friend
67         basic_istream<_CharT, _Traits>&
68         operator>>(basic_istream<_CharT, _Traits>& __is,
69                    lognormal_distribution<_RT>& __x);
70     };
71 
72 private:
73     param_type __p_;
74 
75 public:
76     // constructor and reset functions
77 #ifndef _LIBCPP_CXX03_LANG
78     _LIBCPP_INLINE_VISIBILITY
79     lognormal_distribution() : lognormal_distribution(0) {}
80     _LIBCPP_INLINE_VISIBILITY
81     explicit lognormal_distribution(result_type __m, result_type __s = 1)
82         : __p_(param_type(__m, __s)) {}
83 #else
84     _LIBCPP_INLINE_VISIBILITY
85     explicit lognormal_distribution(result_type __m = 0,
86                                     result_type __s = 1)
87         : __p_(param_type(__m, __s)) {}
88 #endif
89     _LIBCPP_INLINE_VISIBILITY
90     explicit lognormal_distribution(const param_type& __p)
91         : __p_(__p) {}
92     _LIBCPP_INLINE_VISIBILITY
93     void reset() {__p_.__nd_.reset();}
94 
95     // generating functions
96     template<class _URNG>
97         _LIBCPP_INLINE_VISIBILITY
98         result_type operator()(_URNG& __g)
99         {return (*this)(__g, __p_);}
100     template<class _URNG>
101         _LIBCPP_INLINE_VISIBILITY
102         result_type operator()(_URNG& __g, const param_type& __p)
103         {return _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
104 
105     // property functions
106     _LIBCPP_INLINE_VISIBILITY
107     result_type m() const {return __p_.m();}
108     _LIBCPP_INLINE_VISIBILITY
109     result_type s() const {return __p_.s();}
110 
111     _LIBCPP_INLINE_VISIBILITY
112     param_type param() const {return __p_;}
113     _LIBCPP_INLINE_VISIBILITY
114     void param(const param_type& __p) {__p_ = __p;}
115 
116     _LIBCPP_INLINE_VISIBILITY
117     result_type min() const {return 0;}
118     _LIBCPP_INLINE_VISIBILITY
119     result_type max() const {return numeric_limits<result_type>::infinity();}
120 
121     friend _LIBCPP_INLINE_VISIBILITY
122         bool operator==(const lognormal_distribution& __x,
123                         const lognormal_distribution& __y)
124         {return __x.__p_ == __y.__p_;}
125     friend _LIBCPP_INLINE_VISIBILITY
126         bool operator!=(const lognormal_distribution& __x,
127                         const lognormal_distribution& __y)
128         {return !(__x == __y);}
129 
130     template <class _CharT, class _Traits, class _RT>
131     friend
132     basic_ostream<_CharT, _Traits>&
133     operator<<(basic_ostream<_CharT, _Traits>& __os,
134                const lognormal_distribution<_RT>& __x);
135 
136     template <class _CharT, class _Traits, class _RT>
137     friend
138     basic_istream<_CharT, _Traits>&
139     operator>>(basic_istream<_CharT, _Traits>& __is,
140                lognormal_distribution<_RT>& __x);
141 };
142 
143 template <class _CharT, class _Traits, class _RT>
144 inline _LIBCPP_INLINE_VISIBILITY
145 basic_ostream<_CharT, _Traits>&
146 operator<<(basic_ostream<_CharT, _Traits>& __os,
147            const lognormal_distribution<_RT>& __x)
148 {
149     return __os << __x.__p_.__nd_;
150 }
151 
152 template <class _CharT, class _Traits, class _RT>
153 inline _LIBCPP_INLINE_VISIBILITY
154 basic_istream<_CharT, _Traits>&
155 operator>>(basic_istream<_CharT, _Traits>& __is,
156            lognormal_distribution<_RT>& __x)
157 {
158     return __is >> __x.__p_.__nd_;
159 }
160 
161 #else // _LIBCPP_ABI_OLD_LOGNORMAL_DISTRIBUTION
162 
163 template<class _RealType = double>
164 class _LIBCPP_TEMPLATE_VIS lognormal_distribution
165 {
166 public:
167     // types
168     typedef _RealType result_type;
169 
170     class _LIBCPP_TEMPLATE_VIS param_type
171     {
172         result_type __m_;
173         result_type __s_;
174     public:
175         typedef lognormal_distribution distribution_type;
176 
177         _LIBCPP_INLINE_VISIBILITY
178         explicit param_type(result_type __m = 0, result_type __s = 1)
179             : __m_(__m), __s_(__s) {}
180 
181         _LIBCPP_INLINE_VISIBILITY
182         result_type m() const {return __m_;}
183         _LIBCPP_INLINE_VISIBILITY
184         result_type s() const {return __s_;}
185 
186         friend _LIBCPP_INLINE_VISIBILITY
187         bool operator==(const param_type& __x, const param_type& __y)
188             {return __x.__m_ == __y.__m_ && __x.__s_ == __y.__s_;}
189         friend _LIBCPP_INLINE_VISIBILITY
190         bool operator!=(const param_type& __x, const param_type& __y)
191             {return !(__x == __y);}
192     };
193 
194 private:
195     normal_distribution<result_type> __nd_;
196 
197 public:
198     // constructor and reset functions
199 #ifndef _LIBCPP_CXX03_LANG
200     _LIBCPP_INLINE_VISIBILITY
201     lognormal_distribution() : lognormal_distribution(0) {}
202     _LIBCPP_INLINE_VISIBILITY
203     explicit lognormal_distribution(result_type __m, result_type __s = 1)
204         : __nd_(__m, __s) {}
205 #else
206     _LIBCPP_INLINE_VISIBILITY
207     explicit lognormal_distribution(result_type __m = 0,
208                                     result_type __s = 1)
209         : __nd_(__m, __s) {}
210 #endif
211     _LIBCPP_INLINE_VISIBILITY
212     explicit lognormal_distribution(const param_type& __p)
213         : __nd_(__p.m(), __p.s()) {}
214     _LIBCPP_INLINE_VISIBILITY
215     void reset() {__nd_.reset();}
216 
217     // generating functions
218     template<class _URNG>
219     _LIBCPP_INLINE_VISIBILITY
220     result_type operator()(_URNG& __g)
221     {
222         return _VSTD::exp(__nd_(__g));
223     }
224 
225     template<class _URNG>
226     _LIBCPP_INLINE_VISIBILITY
227     result_type operator()(_URNG& __g, const param_type& __p)
228     {
229         typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s());
230         return _VSTD::exp(__nd_(__g, __pn));
231     }
232 
233     // property functions
234     _LIBCPP_INLINE_VISIBILITY
235     result_type m() const {return __nd_.mean();}
236     _LIBCPP_INLINE_VISIBILITY
237     result_type s() const {return __nd_.stddev();}
238 
239     _LIBCPP_INLINE_VISIBILITY
240     param_type param() const {return param_type(__nd_.mean(), __nd_.stddev());}
241     _LIBCPP_INLINE_VISIBILITY
242     void param(const param_type& __p)
243     {
244         typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s());
245         __nd_.param(__pn);
246     }
247 
248     _LIBCPP_INLINE_VISIBILITY
249     result_type min() const {return 0;}
250     _LIBCPP_INLINE_VISIBILITY
251     result_type max() const {return numeric_limits<result_type>::infinity();}
252 
253     friend _LIBCPP_INLINE_VISIBILITY
254         bool operator==(const lognormal_distribution& __x,
255                         const lognormal_distribution& __y)
256         {return __x.__nd_ == __y.__nd_;}
257     friend _LIBCPP_INLINE_VISIBILITY
258         bool operator!=(const lognormal_distribution& __x,
259                         const lognormal_distribution& __y)
260         {return !(__x == __y);}
261 
262     template <class _CharT, class _Traits, class _RT>
263     friend
264     basic_ostream<_CharT, _Traits>&
265     operator<<(basic_ostream<_CharT, _Traits>& __os,
266                const lognormal_distribution<_RT>& __x);
267 
268     template <class _CharT, class _Traits, class _RT>
269     friend
270     basic_istream<_CharT, _Traits>&
271     operator>>(basic_istream<_CharT, _Traits>& __is,
272                lognormal_distribution<_RT>& __x);
273 };
274 
275 template <class _CharT, class _Traits, class _RT>
276 inline _LIBCPP_INLINE_VISIBILITY
277 basic_ostream<_CharT, _Traits>&
278 operator<<(basic_ostream<_CharT, _Traits>& __os,
279            const lognormal_distribution<_RT>& __x)
280 {
281     return __os << __x.__nd_;
282 }
283 
284 template <class _CharT, class _Traits, class _RT>
285 inline _LIBCPP_INLINE_VISIBILITY
286 basic_istream<_CharT, _Traits>&
287 operator>>(basic_istream<_CharT, _Traits>& __is,
288            lognormal_distribution<_RT>& __x)
289 {
290     return __is >> __x.__nd_;
291 }
292 
293 #endif // _LIBCPP_ABI_OLD_LOGNORMAL_DISTRIBUTION
294 
295 _LIBCPP_END_NAMESPACE_STD
296 
297 _LIBCPP_POP_MACROS
298 
299 #endif // _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
300