]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // boost_math.h |
2 | ||
3 | // Copyright John Maddock 2007. | |
4 | // Copyright Paul A. Bristow 2007. | |
5 | ||
6 | // Use, modification and distribution are subject to the | |
7 | // Boost Software License, Version 1.0. | |
8 | // (See accompanying file LICENSE_1_0.txt | |
9 | // or copy at http://www.boost.org/LICENSE_1_0.txt) | |
10 | ||
11 | //#define BOOST_MATH_OVERFLOW_ERROR_POLICY errno_on_error | |
12 | //#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false | |
13 | // These are now defined in project properties | |
14 | // "BOOST_MATH_ASSERT_UNDEFINED_POLICY=0" | |
15 | // "BOOST_MATH_OVERFLOW_ERROR_POLICY=errno_on_error" | |
16 | // to avoid complications with pre-compiled headers. | |
17 | ||
18 | #ifdef _MSC_VER | |
19 | # pragma once | |
20 | # pragma warning (disable : 4127) | |
21 | #endif | |
22 | ||
23 | using namespace System; | |
24 | ||
25 | #define TRANSLATE_EXCEPTIONS_BEGIN try{ | |
26 | ||
27 | #define TRANSLATE_EXCEPTIONS_END \ | |
28 | }catch(const std::exception& e){ \ | |
29 | System::String^ s = gcnew System::String(e.what());\ | |
30 | InvalidOperationException^ se = gcnew InvalidOperationException(s);\ | |
31 | throw se; \ | |
32 | } | |
33 | ||
34 | namespace boost_math { | |
35 | ||
36 | class any_imp | |
37 | { | |
38 | public: | |
39 | // Distribution properties. | |
40 | virtual double mean()const = 0; | |
41 | virtual double mode()const = 0; | |
42 | virtual double median()const = 0; | |
43 | virtual double variance()const = 0; | |
44 | virtual double standard_deviation()const = 0; | |
45 | virtual double skewness()const = 0; | |
46 | virtual double kurtosis()const = 0; | |
47 | virtual double kurtosis_excess()const = 0; | |
48 | virtual double coefficient_of_variation()const = 0; | |
49 | // Values computed from random variate x. | |
50 | virtual double hazard(double x)const = 0; | |
51 | virtual double chf(double x)const = 0; | |
52 | virtual double cdf(double x)const = 0; | |
53 | virtual double ccdf(double x)const = 0; | |
54 | virtual double pdf(double x)const = 0; | |
55 | virtual double quantile(double x)const = 0; | |
56 | virtual double quantile_c(double x)const = 0; | |
57 | // Range & support of x | |
58 | virtual double lowest()const = 0; | |
59 | virtual double uppermost()const = 0; | |
60 | virtual double lower()const = 0; | |
61 | virtual double upper()const = 0; | |
62 | }; | |
63 | ||
64 | template <class Distribution> | |
65 | class concrete_distribution : public any_imp | |
66 | { | |
67 | public: | |
68 | concrete_distribution(const Distribution& d) : m_dist(d) {} | |
69 | // Distribution properties. | |
70 | virtual double mean()const | |
71 | { | |
72 | return boost::math::mean(m_dist); | |
73 | } | |
74 | virtual double median()const | |
75 | { | |
76 | return boost::math::median(m_dist); | |
77 | } | |
78 | virtual double mode()const | |
79 | { | |
80 | return boost::math::mode(m_dist); | |
81 | } | |
82 | virtual double variance()const | |
83 | { | |
84 | return boost::math::variance(m_dist); | |
85 | } | |
86 | virtual double skewness()const | |
87 | { | |
88 | return boost::math::skewness(m_dist); | |
89 | } | |
90 | virtual double standard_deviation()const | |
91 | { | |
92 | return boost::math::standard_deviation(m_dist); | |
93 | } | |
94 | virtual double coefficient_of_variation()const | |
95 | { | |
96 | return boost::math::coefficient_of_variation(m_dist); | |
97 | } | |
98 | virtual double kurtosis()const | |
99 | { | |
100 | return boost::math::kurtosis(m_dist); | |
101 | } | |
102 | virtual double kurtosis_excess()const | |
103 | { | |
104 | return boost::math::kurtosis_excess(m_dist); | |
105 | } | |
106 | // Range of x for the distribution. | |
107 | virtual double lowest()const | |
108 | { | |
109 | return boost::math::range(m_dist).first; | |
110 | } | |
111 | virtual double uppermost()const | |
112 | { | |
113 | return boost::math::range(m_dist).second; | |
114 | } | |
115 | // Support of x for the distribution. | |
116 | virtual double lower()const | |
117 | { | |
118 | return boost::math::support(m_dist).first; | |
119 | } | |
120 | virtual double upper()const | |
121 | { | |
122 | return boost::math::support(m_dist).second; | |
123 | } | |
124 | ||
125 | // Values computed from random variate x. | |
126 | virtual double hazard(double x)const | |
127 | { | |
128 | return boost::math::hazard(m_dist, x); | |
129 | } | |
130 | virtual double chf(double x)const | |
131 | { | |
132 | return boost::math::chf(m_dist, x); | |
133 | } | |
134 | virtual double cdf(double x)const | |
135 | { | |
136 | return boost::math::cdf(m_dist, x); | |
137 | } | |
138 | virtual double ccdf(double x)const | |
139 | { | |
140 | return boost::math::cdf(complement(m_dist, x)); | |
141 | } | |
142 | virtual double pdf(double x)const | |
143 | { | |
144 | return boost::math::pdf(m_dist, x); | |
145 | } | |
146 | virtual double quantile(double x)const | |
147 | { | |
148 | return boost::math::quantile(m_dist, x); | |
149 | } | |
150 | virtual double quantile_c(double x)const | |
151 | { | |
152 | return boost::math::quantile(complement(m_dist, x)); | |
153 | } | |
154 | private: | |
155 | Distribution m_dist; | |
156 | }; | |
157 | ||
158 | public ref class any_distribution | |
159 | { | |
160 | public: | |
161 | // Added methods for this class here. | |
162 | any_distribution(int t, double arg1, double arg2, double arg3); | |
163 | ~any_distribution() | |
164 | { | |
165 | reset(0); | |
166 | } | |
167 | // Is it OK for these to be inline? | |
f67539c2 | 168 | // Distribution properties as 'pointer-to-implementations'. |
7c673cae FG |
169 | double mean() |
170 | { | |
171 | TRANSLATE_EXCEPTIONS_BEGIN | |
172 | return pimpl->mean(); | |
173 | TRANSLATE_EXCEPTIONS_END | |
174 | } | |
175 | double median() | |
176 | { | |
177 | TRANSLATE_EXCEPTIONS_BEGIN | |
178 | return pimpl->median(); | |
179 | TRANSLATE_EXCEPTIONS_END | |
180 | } | |
181 | double mode() | |
182 | { | |
183 | TRANSLATE_EXCEPTIONS_BEGIN | |
184 | return pimpl->mode(); | |
185 | TRANSLATE_EXCEPTIONS_END | |
186 | } | |
187 | double variance() | |
188 | { | |
189 | TRANSLATE_EXCEPTIONS_BEGIN | |
190 | return pimpl->variance(); | |
191 | TRANSLATE_EXCEPTIONS_END | |
192 | } | |
193 | double standard_deviation() | |
194 | { | |
195 | TRANSLATE_EXCEPTIONS_BEGIN | |
196 | return pimpl->standard_deviation(); | |
197 | TRANSLATE_EXCEPTIONS_END | |
198 | } | |
199 | double coefficient_of_variation() | |
200 | { // aka Relative Standard deviation. | |
201 | TRANSLATE_EXCEPTIONS_BEGIN | |
202 | return pimpl->coefficient_of_variation(); | |
203 | TRANSLATE_EXCEPTIONS_END | |
204 | } | |
205 | double skewness() | |
206 | { | |
207 | TRANSLATE_EXCEPTIONS_BEGIN | |
208 | return pimpl->skewness(); | |
209 | TRANSLATE_EXCEPTIONS_END | |
210 | } | |
211 | double kurtosis() | |
212 | { | |
213 | TRANSLATE_EXCEPTIONS_BEGIN | |
214 | return pimpl->kurtosis(); | |
215 | TRANSLATE_EXCEPTIONS_END | |
216 | } | |
217 | double kurtosis_excess() | |
218 | { | |
219 | TRANSLATE_EXCEPTIONS_BEGIN | |
220 | return pimpl->kurtosis_excess(); | |
221 | TRANSLATE_EXCEPTIONS_END | |
222 | } | |
223 | // Values computed from random variate x. | |
224 | double hazard(double x) | |
225 | { | |
226 | TRANSLATE_EXCEPTIONS_BEGIN | |
227 | return pimpl->hazard(x); | |
228 | TRANSLATE_EXCEPTIONS_END | |
229 | } | |
230 | double chf(double x) | |
231 | { | |
232 | TRANSLATE_EXCEPTIONS_BEGIN | |
233 | return pimpl->chf(x); | |
234 | TRANSLATE_EXCEPTIONS_END | |
235 | } | |
236 | double cdf(double x) | |
237 | { | |
238 | TRANSLATE_EXCEPTIONS_BEGIN | |
239 | return pimpl->cdf(x); | |
240 | TRANSLATE_EXCEPTIONS_END | |
241 | } | |
242 | double ccdf(double x) | |
243 | { | |
244 | TRANSLATE_EXCEPTIONS_BEGIN | |
245 | return pimpl->ccdf(x); | |
246 | TRANSLATE_EXCEPTIONS_END | |
247 | } | |
248 | double pdf(double x) | |
249 | { | |
250 | TRANSLATE_EXCEPTIONS_BEGIN | |
251 | return pimpl->pdf(x); | |
252 | TRANSLATE_EXCEPTIONS_END | |
253 | } | |
254 | double quantile(double x) | |
255 | { | |
256 | TRANSLATE_EXCEPTIONS_BEGIN | |
257 | return pimpl->quantile(x); | |
258 | TRANSLATE_EXCEPTIONS_END | |
259 | } | |
260 | double quantile_c(double x) | |
261 | { | |
262 | TRANSLATE_EXCEPTIONS_BEGIN | |
263 | return pimpl->quantile_c(x); | |
264 | TRANSLATE_EXCEPTIONS_END | |
265 | } | |
266 | ||
267 | double lowest() | |
268 | { | |
269 | TRANSLATE_EXCEPTIONS_BEGIN | |
270 | return pimpl->lowest(); | |
271 | TRANSLATE_EXCEPTIONS_END | |
272 | } | |
273 | ||
274 | double uppermost() | |
275 | { | |
276 | TRANSLATE_EXCEPTIONS_BEGIN | |
277 | return pimpl->uppermost(); | |
278 | TRANSLATE_EXCEPTIONS_END | |
279 | } | |
280 | ||
281 | double lower() | |
282 | { | |
283 | TRANSLATE_EXCEPTIONS_BEGIN | |
284 | return pimpl->lower(); | |
285 | TRANSLATE_EXCEPTIONS_END | |
286 | } | |
287 | double upper() | |
288 | { | |
289 | TRANSLATE_EXCEPTIONS_BEGIN | |
290 | return pimpl->upper(); | |
291 | TRANSLATE_EXCEPTIONS_END | |
292 | } | |
293 | ||
294 | // How many distributions are supported: | |
295 | static int size(); | |
296 | // Display name of i'th distribution: | |
297 | static System::String^ distribution_name(int i); | |
298 | // Name of first distribution parameter, or null if not supported: | |
299 | static System::String^ first_param_name(int i); | |
300 | // Name of second distribution parameter, or null if not supported: | |
301 | static System::String^ second_param_name(int i); | |
302 | // Name of third distribution parameter, or null if not supported: | |
303 | static System::String^ third_param_name(int i); | |
304 | // Default value for first parameter: | |
305 | static double first_param_default(int i); | |
306 | // Default value for second parameter: | |
307 | static double second_param_default(int i); | |
308 | // Default value for third parameter: | |
309 | static double third_param_default(int i); | |
310 | ||
311 | private: | |
312 | any_distribution(const any_distribution^) | |
313 | { // Constructor is private. | |
314 | } | |
315 | const any_distribution^ operator=(const any_distribution^ d) | |
316 | { // Copy Constructor is private too. | |
317 | return d; | |
318 | } | |
319 | // We really should use a shared_ptr here, | |
320 | // but apparently it's not allowed in a managed class like this :-( | |
321 | void reset(any_imp* p) | |
322 | { | |
323 | if(pimpl) | |
324 | { // Exists already, so | |
325 | delete pimpl; | |
326 | } | |
327 | pimpl = p; | |
328 | } | |
329 | any_imp* pimpl; | |
330 | }; | |
331 | } |