OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [ext/] [random.tcc] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
// Random number extensions -*- C++ -*-
2
 
3
// Copyright (C) 2012 Free Software Foundation, Inc.
4
//
5
// This file is part of the GNU ISO C++ Library.  This library is free
6
// software; you can redistribute it and/or modify it under the
7
// terms of the GNU General Public License as published by the
8
// Free Software Foundation; either version 3, or (at your option)
9
// any later version.
10
 
11
// This library is distributed in the hope that it will be useful,
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
// GNU General Public License for more details.
15
 
16
// Under Section 7 of GPL version 3, you are granted additional
17
// permissions described in the GCC Runtime Library Exception, version
18
// 3.1, as published by the Free Software Foundation.
19
 
20
// You should have received a copy of the GNU General Public License and
21
// a copy of the GCC Runtime Library Exception along with this program;
22
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23
// .
24
 
25
/** @file ext/random.tcc
26
 *  This is an internal header file, included by other library headers.
27
 *  Do not attempt to use it directly. @headername{ext/random}
28
 */
29
 
30
#ifndef _EXT_RANDOM_TCC
31
#define _EXT_RANDOM_TCC 1
32
 
33
#pragma GCC system_header
34
 
35
 
36
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
37
{
38
_GLIBCXX_BEGIN_NAMESPACE_VERSION
39
 
40
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
41
 
42
  template
43
           size_t __pos1, size_t __sl1, size_t __sl2,
44
           size_t __sr1, size_t __sr2,
45
           uint32_t __msk1, uint32_t __msk2,
46
           uint32_t __msk3, uint32_t __msk4,
47
           uint32_t __parity1, uint32_t __parity2,
48
           uint32_t __parity3, uint32_t __parity4>
49
    void simd_fast_mersenne_twister_engine<_UIntType, __m,
50
                                           __pos1, __sl1, __sl2, __sr1, __sr2,
51
                                           __msk1, __msk2, __msk3, __msk4,
52
                                           __parity1, __parity2, __parity3,
53
                                           __parity4>::
54
    seed(_UIntType __seed)
55
    {
56
      _M_state32[0] = static_cast(__seed);
57
      for (size_t __i = 1; __i < _M_nstate32; ++__i)
58
        _M_state32[__i] = (1812433253UL
59
                           * (_M_state32[__i - 1] ^ (_M_state32[__i - 1] >> 30))
60
                           + __i);
61
      _M_pos = state_size;
62
      _M_period_certification();
63
    }
64
 
65
 
66
  namespace {
67
 
68
    inline uint32_t _Func1(uint32_t __x)
69
    {
70
      return (__x ^ (__x >> 27)) * UINT32_C(1664525);
71
    }
72
 
73
    inline uint32_t _Func2(uint32_t __x)
74
    {
75
      return (__x ^ (__x >> 27)) * UINT32_C(1566083941);
76
    }
77
 
78
  }
79
 
80
 
81
  template
82
           size_t __pos1, size_t __sl1, size_t __sl2,
83
           size_t __sr1, size_t __sr2,
84
           uint32_t __msk1, uint32_t __msk2,
85
           uint32_t __msk3, uint32_t __msk4,
86
           uint32_t __parity1, uint32_t __parity2,
87
           uint32_t __parity3, uint32_t __parity4>
88
    template
89
      typename std::enable_if::value>::type
90
      simd_fast_mersenne_twister_engine<_UIntType, __m,
91
                                        __pos1, __sl1, __sl2, __sr1, __sr2,
92
                                        __msk1, __msk2, __msk3, __msk4,
93
                                        __parity1, __parity2, __parity3,
94
                                        __parity4>::
95
      seed(_Sseq& __q)
96
      {
97
        size_t __lag;
98
 
99
        if (_M_nstate32 >= 623)
100
          __lag = 11;
101
        else if (_M_nstate32 >= 68)
102
          __lag = 7;
103
        else if (_M_nstate32 >= 39)
104
          __lag = 5;
105
        else
106
          __lag = 3;
107
        const size_t __mid = (_M_nstate32 - __lag) / 2;
108
 
109
        std::fill(_M_state32, _M_state32 + _M_nstate32, UINT32_C(0x8b8b8b8b));
110
        uint32_t __arr[_M_nstate32];
111
        __q.generate(__arr + 0, __arr + _M_nstate32);
112
 
113
        uint32_t __r = _Func1(_M_state32[0] ^ _M_state32[__mid]
114
                              ^ _M_state32[_M_nstate32  - 1]);
115
        _M_state32[__mid] += __r;
116
        __r += _M_nstate32;
117
        _M_state32[__mid + __lag] += __r;
118
        _M_state32[0] = __r;
119
 
120
        for (size_t __i = 1, __j = 0; __j < _M_nstate32; ++__j)
121
          {
122
            __r = _Func1(_M_state32[__i]
123
                         ^ _M_state32[(__i + __mid) % _M_nstate32]
124
                         ^ _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]);
125
            _M_state32[(__i + __mid) % _M_nstate32] += __r;
126
            __r += __arr[__j] + __i;
127
            _M_state32[(__i + __mid + __lag) % _M_nstate32] += __r;
128
            _M_state32[__i] = __r;
129
            __i = (__i + 1) % _M_nstate32;
130
          }
131
        for (size_t __j = 0; __j < _M_nstate32; ++__j)
132
          {
133
            const size_t __i = (__j + 1) % _M_nstate32;
134
            __r = _Func2(_M_state32[__i]
135
                         + _M_state32[(__i + __mid) % _M_nstate32]
136
                         + _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]);
137
            _M_state32[(__i + __mid) % _M_nstate32] ^= __r;
138
            __r -= __i;
139
            _M_state32[(__i + __mid + __lag) % _M_nstate32] ^= __r;
140
            _M_state32[__i] = __r;
141
          }
142
 
143
        _M_pos = state_size;
144
        _M_period_certification();
145
      }
146
 
147
 
148
  template
149
           size_t __pos1, size_t __sl1, size_t __sl2,
150
           size_t __sr1, size_t __sr2,
151
           uint32_t __msk1, uint32_t __msk2,
152
           uint32_t __msk3, uint32_t __msk4,
153
           uint32_t __parity1, uint32_t __parity2,
154
           uint32_t __parity3, uint32_t __parity4>
155
    void simd_fast_mersenne_twister_engine<_UIntType, __m,
156
                                           __pos1, __sl1, __sl2, __sr1, __sr2,
157
                                           __msk1, __msk2, __msk3, __msk4,
158
                                           __parity1, __parity2, __parity3,
159
                                           __parity4>::
160
    _M_period_certification(void)
161
    {
162
      static const uint32_t __parity[4] = { __parity1, __parity2,
163
                                            __parity3, __parity4 };
164
      uint32_t __inner = 0;
165
      for (size_t __i = 0; __i < 4; ++__i)
166
        if (__parity[__i] != 0)
167
          __inner ^= _M_state32[__i] & __parity[__i];
168
 
169
      if (__builtin_parity(__inner) & 1)
170
        return;
171
      for (size_t __i = 0; __i < 4; ++__i)
172
        if (__parity[__i] != 0)
173
          {
174
            _M_state32[__i] ^= 1 << (__builtin_ffs(__parity[__i]) - 1);
175
            return;
176
          }
177
      __builtin_unreachable();
178
    }
179
 
180
 
181
  template
182
           size_t __pos1, size_t __sl1, size_t __sl2,
183
           size_t __sr1, size_t __sr2,
184
           uint32_t __msk1, uint32_t __msk2,
185
           uint32_t __msk3, uint32_t __msk4,
186
           uint32_t __parity1, uint32_t __parity2,
187
           uint32_t __parity3, uint32_t __parity4>
188
    void simd_fast_mersenne_twister_engine<_UIntType, __m,
189
                                           __pos1, __sl1, __sl2, __sr1, __sr2,
190
                                           __msk1, __msk2, __msk3, __msk4,
191
                                           __parity1, __parity2, __parity3,
192
                                           __parity4>::
193
    discard(unsigned long long __z)
194
    {
195
      while (__z > state_size - _M_pos)
196
        {
197
          __z -= state_size - _M_pos;
198
 
199
          _M_gen_rand();
200
        }
201
 
202
      _M_pos += __z;
203
    }
204
 
205
 
206
#ifndef  _GLIBCXX_OPT_HAVE_RANDOM_SFMT_GEN_READ
207
 
208
  namespace {
209
 
210
    template
211
      inline void __rshift(uint32_t *__out, const uint32_t *__in)
212
      {
213
        uint64_t __th = ((static_cast(__in[3]) << 32)
214
                         | static_cast(__in[2]));
215
        uint64_t __tl = ((static_cast(__in[1]) << 32)
216
                         | static_cast(__in[0]));
217
 
218
        uint64_t __oh = __th >> (__shift * 8);
219
        uint64_t __ol = __tl >> (__shift * 8);
220
        __ol |= __th << (64 - __shift * 8);
221
        __out[1] = static_cast(__ol >> 32);
222
        __out[0] = static_cast(__ol);
223
        __out[3] = static_cast(__oh >> 32);
224
        __out[2] = static_cast(__oh);
225
      }
226
 
227
 
228
    template
229
      inline void __lshift(uint32_t *__out, const uint32_t *__in)
230
      {
231
        uint64_t __th = ((static_cast(__in[3]) << 32)
232
                         | static_cast(__in[2]));
233
        uint64_t __tl = ((static_cast(__in[1]) << 32)
234
                         | static_cast(__in[0]));
235
 
236
        uint64_t __oh = __th << (__shift * 8);
237
        uint64_t __ol = __tl << (__shift * 8);
238
        __oh |= __tl >> (64 - __shift * 8);
239
        __out[1] = static_cast(__ol >> 32);
240
        __out[0] = static_cast(__ol);
241
        __out[3] = static_cast(__oh >> 32);
242
        __out[2] = static_cast(__oh);
243
      }
244
 
245
 
246
    template
247
             uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4>
248
      inline void __recursion(uint32_t *__r,
249
                              const uint32_t *__a, const uint32_t *__b,
250
                              const uint32_t *__c, const uint32_t *__d)
251
      {
252
        uint32_t __x[4];
253
        uint32_t __y[4];
254
 
255
        __lshift<__sl2>(__x, __a);
256
        __rshift<__sr2>(__y, __c);
257
        __r[0] = (__a[0] ^ __x[0] ^ ((__b[0] >> __sr1) & __msk1)
258
                  ^ __y[0] ^ (__d[0] << __sl1));
259
        __r[1] = (__a[1] ^ __x[1] ^ ((__b[1] >> __sr1) & __msk2)
260
                  ^ __y[1] ^ (__d[1] << __sl1));
261
        __r[2] = (__a[2] ^ __x[2] ^ ((__b[2] >> __sr1) & __msk3)
262
                  ^ __y[2] ^ (__d[2] << __sl1));
263
        __r[3] = (__a[3] ^ __x[3] ^ ((__b[3] >> __sr1) & __msk4)
264
                  ^ __y[3] ^ (__d[3] << __sl1));
265
      }
266
 
267
  }
268
 
269
 
270
  template
271
           size_t __pos1, size_t __sl1, size_t __sl2,
272
           size_t __sr1, size_t __sr2,
273
           uint32_t __msk1, uint32_t __msk2,
274
           uint32_t __msk3, uint32_t __msk4,
275
           uint32_t __parity1, uint32_t __parity2,
276
           uint32_t __parity3, uint32_t __parity4>
277
    void simd_fast_mersenne_twister_engine<_UIntType, __m,
278
                                           __pos1, __sl1, __sl2, __sr1, __sr2,
279
                                           __msk1, __msk2, __msk3, __msk4,
280
                                           __parity1, __parity2, __parity3,
281
                                           __parity4>::
282
    _M_gen_rand(void)
283
    {
284
      const uint32_t *__r1 = &_M_state32[_M_nstate32 - 8];
285
      const uint32_t *__r2 = &_M_state32[_M_nstate32 - 4];
286
      static constexpr size_t __pos1_32 = __pos1 * 4;
287
 
288
      size_t __i;
289
      for (__i = 0; __i < _M_nstate32 - __pos1_32; __i += 4)
290
        {
291
          __recursion<__sl1, __sl2, __sr1, __sr2,
292
                      __msk1, __msk2, __msk3, __msk4>
293
            (&_M_state32[__i], &_M_state32[__i],
294
             &_M_state32[__i + __pos1_32], __r1, __r2);
295
          __r1 = __r2;
296
          __r2 = &_M_state32[__i];
297
        }
298
 
299
      for (; __i < _M_nstate32; __i += 4)
300
        {
301
          __recursion<__sl1, __sl2, __sr1, __sr2,
302
                      __msk1, __msk2, __msk3, __msk4>
303
            (&_M_state32[__i], &_M_state32[__i],
304
             &_M_state32[__i + __pos1_32 - _M_nstate32], __r1, __r2);
305
          __r1 = __r2;
306
          __r2 = &_M_state32[__i];
307
        }
308
 
309
      _M_pos = 0;
310
    }
311
 
312
#endif
313
 
314
#ifndef _GLIBCXX_OPT_HAVE_RANDOM_SFMT_OPERATOREQUAL
315
  template
316
           size_t __pos1, size_t __sl1, size_t __sl2,
317
           size_t __sr1, size_t __sr2,
318
           uint32_t __msk1, uint32_t __msk2,
319
           uint32_t __msk3, uint32_t __msk4,
320
           uint32_t __parity1, uint32_t __parity2,
321
           uint32_t __parity3, uint32_t __parity4>
322
    bool
323
    operator==(const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
324
               __m, __pos1, __sl1, __sl2, __sr1, __sr2,
325
               __msk1, __msk2, __msk3, __msk4,
326
               __parity1, __parity2, __parity3, __parity4>& __lhs,
327
               const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
328
               __m, __pos1, __sl1, __sl2, __sr1, __sr2,
329
               __msk1, __msk2, __msk3, __msk4,
330
               __parity1, __parity2, __parity3, __parity4>& __rhs)
331
    {
332
      typedef __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
333
               __m, __pos1, __sl1, __sl2, __sr1, __sr2,
334
               __msk1, __msk2, __msk3, __msk4,
335
               __parity1, __parity2, __parity3, __parity4> __engine;
336
      return (std::equal(__lhs._M_stateT,
337
                         __lhs._M_stateT + __engine::state_size,
338
                         __rhs._M_stateT)
339
              && __lhs._M_pos == __rhs._M_pos);
340
    }
341
#endif
342
 
343
  template
344
           size_t __pos1, size_t __sl1, size_t __sl2,
345
           size_t __sr1, size_t __sr2,
346
           uint32_t __msk1, uint32_t __msk2,
347
           uint32_t __msk3, uint32_t __msk4,
348
           uint32_t __parity1, uint32_t __parity2,
349
           uint32_t __parity3, uint32_t __parity4,
350
           typename _CharT, typename _Traits>
351
    std::basic_ostream<_CharT, _Traits>&
352
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
353
               const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
354
               __m, __pos1, __sl1, __sl2, __sr1, __sr2,
355
               __msk1, __msk2, __msk3, __msk4,
356
               __parity1, __parity2, __parity3, __parity4>& __x)
357
    {
358
      typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
359
      typedef typename __ostream_type::ios_base __ios_base;
360
 
361
      const typename __ios_base::fmtflags __flags = __os.flags();
362
      const _CharT __fill = __os.fill();
363
      const _CharT __space = __os.widen(' ');
364
      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
365
      __os.fill(__space);
366
 
367
      for (size_t __i = 0; __i < __x._M_nstate32; ++__i)
368
        __os << __x._M_state32[__i] << __space;
369
      __os << __x._M_pos;
370
 
371
      __os.flags(__flags);
372
      __os.fill(__fill);
373
      return __os;
374
    }
375
 
376
 
377
  template
378
           size_t __pos1, size_t __sl1, size_t __sl2,
379
           size_t __sr1, size_t __sr2,
380
           uint32_t __msk1, uint32_t __msk2,
381
           uint32_t __msk3, uint32_t __msk4,
382
           uint32_t __parity1, uint32_t __parity2,
383
           uint32_t __parity3, uint32_t __parity4,
384
           typename _CharT, typename _Traits>
385
    std::basic_istream<_CharT, _Traits>&
386
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
387
               __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
388
               __m, __pos1, __sl1, __sl2, __sr1, __sr2,
389
               __msk1, __msk2, __msk3, __msk4,
390
               __parity1, __parity2, __parity3, __parity4>& __x)
391
    {
392
      typedef std::basic_istream<_CharT, _Traits> __istream_type;
393
      typedef typename __istream_type::ios_base __ios_base;
394
 
395
      const typename __ios_base::fmtflags __flags = __is.flags();
396
      __is.flags(__ios_base::dec | __ios_base::skipws);
397
 
398
      for (size_t __i = 0; __i < __x._M_nstate32; ++__i)
399
        __is >> __x._M_state32[__i];
400
      __is >> __x._M_pos;
401
 
402
      __is.flags(__flags);
403
      return __is;
404
    }
405
 
406
#endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
407
 
408
  /**
409
   * Iteration method due to M.D. Jhnk.
410
   *
411
   * M.D. Jhnk, Erzeugung von betaverteilten und gammaverteilten
412
   * Zufallszahlen, Metrika, Volume 8, 1964
413
   */
414
  template
415
    template
416
      typename beta_distribution<_RealType>::result_type
417
      beta_distribution<_RealType>::
418
      operator()(_UniformRandomNumberGenerator& __urng,
419
                 const param_type& __param)
420
      {
421
        std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
422
          __aurng(__urng);
423
 
424
        result_type __x, __y;
425
        do
426
          {
427
            __x = std::exp(std::log(__aurng()) / __param.alpha());
428
            __y = std::exp(std::log(__aurng()) / __param.beta());
429
          }
430
        while (__x + __y > result_type(1));
431
 
432
        return __x / (__x + __y);
433
      }
434
 
435
  template
436
    template
437
             typename _UniformRandomNumberGenerator>
438
      void
439
      beta_distribution<_RealType>::
440
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
441
                      _UniformRandomNumberGenerator& __urng,
442
                      const param_type& __param)
443
      {
444
        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
445
 
446
        std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
447
          __aurng(__urng);
448
 
449
        while (__f != __t)
450
          {
451
            result_type __x, __y;
452
            do
453
              {
454
                __x = std::exp(std::log(__aurng()) / __param.alpha());
455
                __y = std::exp(std::log(__aurng()) / __param.beta());
456
              }
457
            while (__x + __y > result_type(1));
458
 
459
            *__f++ = __x / (__x + __y);
460
          }
461
      }
462
 
463
  template
464
    std::basic_ostream<_CharT, _Traits>&
465
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
466
               const __gnu_cxx::beta_distribution<_RealType>& __x)
467
    {
468
      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
469
      typedef typename __ostream_type::ios_base    __ios_base;
470
 
471
      const typename __ios_base::fmtflags __flags = __os.flags();
472
      const _CharT __fill = __os.fill();
473
      const std::streamsize __precision = __os.precision();
474
      const _CharT __space = __os.widen(' ');
475
      __os.flags(__ios_base::scientific | __ios_base::left);
476
      __os.fill(__space);
477
      __os.precision(std::numeric_limits<_RealType>::max_digits10);
478
 
479
      __os << __x.alpha() << __space << __x.beta();
480
 
481
      __os.flags(__flags);
482
      __os.fill(__fill);
483
      __os.precision(__precision);
484
      return __os;
485
    }
486
 
487
  template
488
    std::basic_istream<_CharT, _Traits>&
489
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
490
               __gnu_cxx::beta_distribution<_RealType>& __x)
491
    {
492
      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
493
      typedef typename __istream_type::ios_base    __ios_base;
494
 
495
      const typename __ios_base::fmtflags __flags = __is.flags();
496
      __is.flags(__ios_base::dec | __ios_base::skipws);
497
 
498
      _RealType __alpha_val, __beta_val;
499
      __is >> __alpha_val >> __beta_val;
500
      __x.param(typename __gnu_cxx::beta_distribution<_RealType>::
501
                param_type(__alpha_val, __beta_val));
502
 
503
      __is.flags(__flags);
504
      return __is;
505
    }
506
 
507
 
508
  template
509
    template
510
      void
511
      normal_mv_distribution<_Dimen, _RealType>::param_type::
512
      _M_init_full(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
513
                   _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)
514
      {
515
        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
516
        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
517
        std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
518
                  _M_mean.end(), _RealType(0));
519
 
520
        // Perform the Cholesky decomposition
521
        auto __w = _M_t.begin();
522
        for (size_t __j = 0; __j < _Dimen; ++__j)
523
          {
524
            _RealType __sum = _RealType(0);
525
 
526
            auto __slitbegin = __w;
527
            auto __cit = _M_t.begin();
528
            for (size_t __i = 0; __i < __j; ++__i)
529
              {
530
                auto __slit = __slitbegin;
531
                _RealType __s = *__varcovbegin++;
532
                for (size_t __k = 0; __k < __i; ++__k)
533
                  __s -= *__slit++ * *__cit++;
534
 
535
                *__w++ = __s /= *__cit++;
536
                __sum += __s * __s;
537
              }
538
 
539
            __sum = *__varcovbegin - __sum;
540
            if (__builtin_expect(__sum <= _RealType(0), 0))
541
              std::__throw_runtime_error(__N("normal_mv_distribution::"
542
                                             "param_type::_M_init_full"));
543
            *__w++ = std::sqrt(__sum);
544
 
545
            std::advance(__varcovbegin, _Dimen - __j);
546
          }
547
      }
548
 
549
  template
550
    template
551
      void
552
      normal_mv_distribution<_Dimen, _RealType>::param_type::
553
      _M_init_lower(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
554
                    _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)
555
      {
556
        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
557
        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
558
        std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
559
                  _M_mean.end(), _RealType(0));
560
 
561
        // Perform the Cholesky decomposition
562
        auto __w = _M_t.begin();
563
        for (size_t __j = 0; __j < _Dimen; ++__j)
564
          {
565
            _RealType __sum = _RealType(0);
566
 
567
            auto __slitbegin = __w;
568
            auto __cit = _M_t.begin();
569
            for (size_t __i = 0; __i < __j; ++__i)
570
              {
571
                auto __slit = __slitbegin;
572
                _RealType __s = *__varcovbegin++;
573
                for (size_t __k = 0; __k < __i; ++__k)
574
                  __s -= *__slit++ * *__cit++;
575
 
576
                *__w++ = __s /= *__cit++;
577
                __sum += __s * __s;
578
              }
579
 
580
            __sum = *__varcovbegin++ - __sum;
581
            if (__builtin_expect(__sum <= _RealType(0), 0))
582
              std::__throw_runtime_error(__N("normal_mv_distribution::"
583
                                             "param_type::_M_init_full"));
584
            *__w++ = std::sqrt(__sum);
585
          }
586
      }
587
 
588
  template
589
    template
590
      void
591
      normal_mv_distribution<_Dimen, _RealType>::param_type::
592
      _M_init_diagonal(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
593
                       _InputIterator2 __varbegin, _InputIterator2 __varend)
594
      {
595
        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
596
        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
597
        std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
598
                  _M_mean.end(), _RealType(0));
599
 
600
        auto __w = _M_t.begin();
601
        size_t __step = 0;
602
        while (__varbegin != __varend)
603
          {
604
            std::fill_n(__w, __step, _RealType(0));
605
            __w += __step++;
606
            if (__builtin_expect(*__varbegin < _RealType(0), 0))
607
              std::__throw_runtime_error(__N("normal_mv_distribution::"
608
                                             "param_type::_M_init_diagonal"));
609
            *__w++ = std::sqrt(*__varbegin++);
610
          }
611
      }
612
 
613
  template
614
    template
615
      typename normal_mv_distribution<_Dimen, _RealType>::result_type
616
      normal_mv_distribution<_Dimen, _RealType>::
617
      operator()(_UniformRandomNumberGenerator& __urng,
618
                 const param_type& __param)
619
      {
620
        result_type __ret;
621
 
622
        _M_nd.__generate(__ret.begin(), __ret.end(), __urng);
623
 
624
        auto __t_it = __param._M_t.crbegin();
625
        for (size_t __i = _Dimen; __i > 0; --__i)
626
          {
627
            _RealType __sum = _RealType(0);
628
            for (size_t __j = __i; __j > 0; --__j)
629
              __sum += __ret[__j - 1] * *__t_it++;
630
            __ret[__i - 1] = __sum;
631
          }
632
 
633
        return __ret;
634
      }
635
 
636
  template
637
    template
638
      void
639
      normal_mv_distribution<_Dimen, _RealType>::
640
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
641
                      _UniformRandomNumberGenerator& __urng,
642
                      const param_type& __param)
643
      {
644
        __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
645
                                    _ForwardIterator>)
646
        while (__f != __t)
647
          *__f++ = this->operator()(__urng, __param);
648
      }
649
 
650
  template
651
    bool
652
    operator==(const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&
653
               __d1,
654
               const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&
655
               __d2)
656
    {
657
      return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd;
658
    }
659
 
660
  template
661
    std::basic_ostream<_CharT, _Traits>&
662
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
663
               const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>& __x)
664
    {
665
      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
666
      typedef typename __ostream_type::ios_base    __ios_base;
667
 
668
      const typename __ios_base::fmtflags __flags = __os.flags();
669
      const _CharT __fill = __os.fill();
670
      const std::streamsize __precision = __os.precision();
671
      const _CharT __space = __os.widen(' ');
672
      __os.flags(__ios_base::scientific | __ios_base::left);
673
      __os.fill(__space);
674
      __os.precision(std::numeric_limits<_RealType>::max_digits10);
675
 
676
      auto __mean = __x._M_param.mean();
677
      for (auto __it : __mean)
678
        __os << __it << __space;
679
      auto __t = __x._M_param.varcov();
680
      for (auto __it : __t)
681
        __os << __it << __space;
682
 
683
      __os << __x._M_nd;
684
 
685
      __os.flags(__flags);
686
      __os.fill(__fill);
687
      __os.precision(__precision);
688
      return __os;
689
    }
690
 
691
  template
692
    std::basic_istream<_CharT, _Traits>&
693
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
694
               __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>& __x)
695
    {
696
      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
697
      typedef typename __istream_type::ios_base    __ios_base;
698
 
699
      const typename __ios_base::fmtflags __flags = __is.flags();
700
      __is.flags(__ios_base::dec | __ios_base::skipws);
701
 
702
      std::array<_RealType, _Dimen> __mean;
703
      for (auto& __it : __mean)
704
        __is >> __it;
705
      std::array<_RealType, _Dimen * (_Dimen + 1) / 2> __varcov;
706
      for (auto& __it : __varcov)
707
        __is >> __it;
708
 
709
      __is >> __x._M_nd;
710
 
711
      __x.param(typename normal_mv_distribution<_Dimen, _RealType>::
712
                param_type(__mean.begin(), __mean.end(),
713
                           __varcov.begin(), __varcov.end()));
714
 
715
      __is.flags(__flags);
716
      return __is;
717
    }
718
 
719
 
720
  template
721
    template
722
             typename _UniformRandomNumberGenerator>
723
      void
724
      rice_distribution<_RealType>::
725
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
726
                      _UniformRandomNumberGenerator& __urng,
727
                      const param_type& __p)
728
      {
729
        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
730
 
731
        while (__f != __t)
732
          {
733
            typename std::normal_distribution::param_type
734
              __px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma());
735
            result_type __x = this->_M_ndx(__px, __urng);
736
            result_type __y = this->_M_ndy(__py, __urng);
737
#if _GLIBCXX_USE_C99_MATH_TR1
738
            *__f++ = std::hypot(__x, __y);
739
#else
740
            *__f++ = std::sqrt(__x * __x + __y * __y);
741
#endif
742
          }
743
      }
744
 
745
  template
746
    std::basic_ostream<_CharT, _Traits>&
747
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
748
               const rice_distribution<_RealType>& __x)
749
    {
750
      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
751
      typedef typename __ostream_type::ios_base    __ios_base;
752
 
753
      const typename __ios_base::fmtflags __flags = __os.flags();
754
      const _CharT __fill = __os.fill();
755
      const std::streamsize __precision = __os.precision();
756
      const _CharT __space = __os.widen(' ');
757
      __os.flags(__ios_base::scientific | __ios_base::left);
758
      __os.fill(__space);
759
      __os.precision(std::numeric_limits<_RealType>::max_digits10);
760
 
761
      __os << __x.nu() << __space << __x.sigma();
762
      __os << __space << __x._M_ndx;
763
      __os << __space << __x._M_ndy;
764
 
765
      __os.flags(__flags);
766
      __os.fill(__fill);
767
      __os.precision(__precision);
768
      return __os;
769
    }
770
 
771
  template
772
    std::basic_istream<_CharT, _Traits>&
773
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
774
               rice_distribution<_RealType>& __x)
775
    {
776
      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
777
      typedef typename __istream_type::ios_base    __ios_base;
778
 
779
      const typename __ios_base::fmtflags __flags = __is.flags();
780
      __is.flags(__ios_base::dec | __ios_base::skipws);
781
 
782
      _RealType __nu_val, __sigma_val;
783
      __is >> __nu_val >> __sigma_val;
784
      __is >> __x._M_ndx;
785
      __is >> __x._M_ndy;
786
      __x.param(typename rice_distribution<_RealType>::
787
                param_type(__nu_val, __sigma_val));
788
 
789
      __is.flags(__flags);
790
      return __is;
791
    }
792
 
793
 
794
  template
795
    template
796
             typename _UniformRandomNumberGenerator>
797
      void
798
      nakagami_distribution<_RealType>::
799
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
800
                      _UniformRandomNumberGenerator& __urng,
801
                      const param_type& __p)
802
      {
803
        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
804
 
805
        typename std::gamma_distribution::param_type
806
          __pg(__p.mu(), __p.omega() / __p.mu());
807
        while (__f != __t)
808
          *__f++ = std::sqrt(this->_M_gd(__pg, __urng));
809
      }
810
 
811
  template
812
    std::basic_ostream<_CharT, _Traits>&
813
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
814
               const nakagami_distribution<_RealType>& __x)
815
    {
816
      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
817
      typedef typename __ostream_type::ios_base    __ios_base;
818
 
819
      const typename __ios_base::fmtflags __flags = __os.flags();
820
      const _CharT __fill = __os.fill();
821
      const std::streamsize __precision = __os.precision();
822
      const _CharT __space = __os.widen(' ');
823
      __os.flags(__ios_base::scientific | __ios_base::left);
824
      __os.fill(__space);
825
      __os.precision(std::numeric_limits<_RealType>::max_digits10);
826
 
827
      __os << __x.mu() << __space << __x.omega();
828
      __os << __space << __x._M_gd;
829
 
830
      __os.flags(__flags);
831
      __os.fill(__fill);
832
      __os.precision(__precision);
833
      return __os;
834
    }
835
 
836
  template
837
    std::basic_istream<_CharT, _Traits>&
838
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
839
               nakagami_distribution<_RealType>& __x)
840
    {
841
      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
842
      typedef typename __istream_type::ios_base    __ios_base;
843
 
844
      const typename __ios_base::fmtflags __flags = __is.flags();
845
      __is.flags(__ios_base::dec | __ios_base::skipws);
846
 
847
      _RealType __mu_val, __omega_val;
848
      __is >> __mu_val >> __omega_val;
849
      __is >> __x._M_gd;
850
      __x.param(typename nakagami_distribution<_RealType>::
851
                param_type(__mu_val, __omega_val));
852
 
853
      __is.flags(__flags);
854
      return __is;
855
    }
856
 
857
 
858
  template
859
    template
860
             typename _UniformRandomNumberGenerator>
861
      void
862
      pareto_distribution<_RealType>::
863
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
864
                      _UniformRandomNumberGenerator& __urng,
865
                      const param_type& __p)
866
      {
867
        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
868
 
869
        result_type __mu_val = __p.mu();
870
        result_type __malphinv = -result_type(1) / __p.alpha();
871
        while (__f != __t)
872
          *__f++ = __mu_val * std::pow(this->_M_ud(__urng), __malphinv);
873
      }
874
 
875
  template
876
    std::basic_ostream<_CharT, _Traits>&
877
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
878
               const pareto_distribution<_RealType>& __x)
879
    {
880
      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
881
      typedef typename __ostream_type::ios_base    __ios_base;
882
 
883
      const typename __ios_base::fmtflags __flags = __os.flags();
884
      const _CharT __fill = __os.fill();
885
      const std::streamsize __precision = __os.precision();
886
      const _CharT __space = __os.widen(' ');
887
      __os.flags(__ios_base::scientific | __ios_base::left);
888
      __os.fill(__space);
889
      __os.precision(std::numeric_limits<_RealType>::max_digits10);
890
 
891
      __os << __x.alpha() << __space << __x.mu();
892
      __os << __space << __x._M_ud;
893
 
894
      __os.flags(__flags);
895
      __os.fill(__fill);
896
      __os.precision(__precision);
897
      return __os;
898
    }
899
 
900
  template
901
    std::basic_istream<_CharT, _Traits>&
902
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
903
               pareto_distribution<_RealType>& __x)
904
    {
905
      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
906
      typedef typename __istream_type::ios_base    __ios_base;
907
 
908
      const typename __ios_base::fmtflags __flags = __is.flags();
909
      __is.flags(__ios_base::dec | __ios_base::skipws);
910
 
911
      _RealType __alpha_val, __mu_val;
912
      __is >> __alpha_val >> __mu_val;
913
      __is >> __x._M_ud;
914
      __x.param(typename pareto_distribution<_RealType>::
915
                param_type(__alpha_val, __mu_val));
916
 
917
      __is.flags(__flags);
918
      return __is;
919
    }
920
 
921
 
922
  template
923
    template
924
      typename k_distribution<_RealType>::result_type
925
      k_distribution<_RealType>::
926
      operator()(_UniformRandomNumberGenerator& __urng)
927
      {
928
        result_type __x = this->_M_gd1(__urng);
929
        result_type __y = this->_M_gd2(__urng);
930
        return std::sqrt(__x * __y);
931
      }
932
 
933
  template
934
    template
935
      typename k_distribution<_RealType>::result_type
936
      k_distribution<_RealType>::
937
      operator()(_UniformRandomNumberGenerator& __urng,
938
                 const param_type& __p)
939
      {
940
        typename std::gamma_distribution::param_type
941
          __p1(__p.lambda(), result_type(1) / __p.lambda()),
942
          __p2(__p.nu(), __p.mu() / __p.nu());
943
        result_type __x = this->_M_gd1(__p1, __urng);
944
        result_type __y = this->_M_gd2(__p2, __urng);
945
        return std::sqrt(__x * __y);
946
      }
947
 
948
  template
949
    template
950
             typename _UniformRandomNumberGenerator>
951
      void
952
      k_distribution<_RealType>::
953
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
954
                      _UniformRandomNumberGenerator& __urng,
955
                      const param_type& __p)
956
      {
957
        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
958
 
959
        typename std::gamma_distribution::param_type
960
          __p1(__p.lambda(), result_type(1) / __p.lambda()),
961
          __p2(__p.nu(), __p.mu() / __p.nu());
962
        while (__f != __t)
963
          {
964
            result_type __x = this->_M_gd1(__p1, __urng);
965
            result_type __y = this->_M_gd2(__p2, __urng);
966
            *__f++ = std::sqrt(__x * __y);
967
          }
968
      }
969
 
970
  template
971
    std::basic_ostream<_CharT, _Traits>&
972
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
973
               const k_distribution<_RealType>& __x)
974
    {
975
      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
976
      typedef typename __ostream_type::ios_base    __ios_base;
977
 
978
      const typename __ios_base::fmtflags __flags = __os.flags();
979
      const _CharT __fill = __os.fill();
980
      const std::streamsize __precision = __os.precision();
981
      const _CharT __space = __os.widen(' ');
982
      __os.flags(__ios_base::scientific | __ios_base::left);
983
      __os.fill(__space);
984
      __os.precision(std::numeric_limits<_RealType>::max_digits10);
985
 
986
      __os << __x.lambda() << __space << __x.mu() << __space << __x.nu();
987
      __os << __space << __x._M_gd1;
988
      __os << __space << __x._M_gd2;
989
 
990
      __os.flags(__flags);
991
      __os.fill(__fill);
992
      __os.precision(__precision);
993
      return __os;
994
    }
995
 
996
  template
997
    std::basic_istream<_CharT, _Traits>&
998
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
999
               k_distribution<_RealType>& __x)
1000
    {
1001
      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
1002
      typedef typename __istream_type::ios_base    __ios_base;
1003
 
1004
      const typename __ios_base::fmtflags __flags = __is.flags();
1005
      __is.flags(__ios_base::dec | __ios_base::skipws);
1006
 
1007
      _RealType __lambda_val, __mu_val, __nu_val;
1008
      __is >> __lambda_val >> __mu_val >> __nu_val;
1009
      __is >> __x._M_gd1;
1010
      __is >> __x._M_gd2;
1011
      __x.param(typename k_distribution<_RealType>::
1012
                param_type(__lambda_val, __mu_val, __nu_val));
1013
 
1014
      __is.flags(__flags);
1015
      return __is;
1016
    }
1017
 
1018
 
1019
  template
1020
    template
1021
             typename _UniformRandomNumberGenerator>
1022
      void
1023
      arcsine_distribution<_RealType>::
1024
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
1025
                      _UniformRandomNumberGenerator& __urng,
1026
                      const param_type& __p)
1027
      {
1028
        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
1029
 
1030
        result_type __dif = __p.b() - __p.a();
1031
        result_type __sum = __p.a() + __p.b();
1032
        while (__f != __t)
1033
          {
1034
            result_type __x = std::sin(this->_M_ud(__urng));
1035
            *__f++ = (__x * __dif + __sum) / result_type(2);
1036
          }
1037
      }
1038
 
1039
  template
1040
    std::basic_ostream<_CharT, _Traits>&
1041
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1042
               const arcsine_distribution<_RealType>& __x)
1043
    {
1044
      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
1045
      typedef typename __ostream_type::ios_base    __ios_base;
1046
 
1047
      const typename __ios_base::fmtflags __flags = __os.flags();
1048
      const _CharT __fill = __os.fill();
1049
      const std::streamsize __precision = __os.precision();
1050
      const _CharT __space = __os.widen(' ');
1051
      __os.flags(__ios_base::scientific | __ios_base::left);
1052
      __os.fill(__space);
1053
      __os.precision(std::numeric_limits<_RealType>::max_digits10);
1054
 
1055
      __os << __x.a() << __space << __x.b();
1056
      __os << __space << __x._M_ud;
1057
 
1058
      __os.flags(__flags);
1059
      __os.fill(__fill);
1060
      __os.precision(__precision);
1061
      return __os;
1062
    }
1063
 
1064
  template
1065
    std::basic_istream<_CharT, _Traits>&
1066
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
1067
               arcsine_distribution<_RealType>& __x)
1068
    {
1069
      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
1070
      typedef typename __istream_type::ios_base    __ios_base;
1071
 
1072
      const typename __ios_base::fmtflags __flags = __is.flags();
1073
      __is.flags(__ios_base::dec | __ios_base::skipws);
1074
 
1075
      _RealType __a, __b;
1076
      __is >> __a >> __b;
1077
      __is >> __x._M_ud;
1078
      __x.param(typename arcsine_distribution<_RealType>::
1079
                param_type(__a, __b));
1080
 
1081
      __is.flags(__flags);
1082
      return __is;
1083
    }
1084
 
1085
 
1086
  template
1087
    template
1088
      typename hoyt_distribution<_RealType>::result_type
1089
      hoyt_distribution<_RealType>::
1090
      operator()(_UniformRandomNumberGenerator& __urng)
1091
      {
1092
        result_type __x = this->_M_ad(__urng);
1093
        result_type __y = this->_M_ed(__urng);
1094
        return (result_type(2) * this->q()
1095
                  / (result_type(1) + this->q() * this->q()))
1096
               * std::sqrt(this->omega() * __x * __y);
1097
      }
1098
 
1099
  template
1100
    template
1101
      typename hoyt_distribution<_RealType>::result_type
1102
      hoyt_distribution<_RealType>::
1103
      operator()(_UniformRandomNumberGenerator& __urng,
1104
                 const param_type& __p)
1105
      {
1106
        result_type __q2 = __p.q() * __p.q();
1107
        result_type __num = result_type(0.5L) * (result_type(1) + __q2);
1108
        typename __gnu_cxx::arcsine_distribution::param_type
1109
          __pa(__num, __num / __q2);
1110
        result_type __x = this->_M_ad(__pa, __urng);
1111
        result_type __y = this->_M_ed(__urng);
1112
        return (result_type(2) * __p.q() / (result_type(1) + __q2))
1113
               * std::sqrt(__p.omega() * __x * __y);
1114
      }
1115
 
1116
  template
1117
    template
1118
             typename _UniformRandomNumberGenerator>
1119
      void
1120
      hoyt_distribution<_RealType>::
1121
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
1122
                      _UniformRandomNumberGenerator& __urng,
1123
                      const param_type& __p)
1124
      {
1125
        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)
1126
 
1127
        result_type __2q = result_type(2) * __p.q();
1128
        result_type __q2 = __p.q() * __p.q();
1129
        result_type __q2p1 = result_type(1) + __q2;
1130
        result_type __num = result_type(0.5L) * __q2p1;
1131
        result_type __omega = __p.omega();
1132
        typename __gnu_cxx::arcsine_distribution::param_type
1133
          __pa(__num, __num / __q2);
1134
        while (__f != __t)
1135
          {
1136
            result_type __x = this->_M_ad(__pa, __urng);
1137
            result_type __y = this->_M_ed(__urng);
1138
            *__f++ = (__2q / __q2p1) * std::sqrt(__omega * __x * __y);
1139
          }
1140
      }
1141
 
1142
  template
1143
    std::basic_ostream<_CharT, _Traits>&
1144
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1145
               const hoyt_distribution<_RealType>& __x)
1146
    {
1147
      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;
1148
      typedef typename __ostream_type::ios_base    __ios_base;
1149
 
1150
      const typename __ios_base::fmtflags __flags = __os.flags();
1151
      const _CharT __fill = __os.fill();
1152
      const std::streamsize __precision = __os.precision();
1153
      const _CharT __space = __os.widen(' ');
1154
      __os.flags(__ios_base::scientific | __ios_base::left);
1155
      __os.fill(__space);
1156
      __os.precision(std::numeric_limits<_RealType>::max_digits10);
1157
 
1158
      __os << __x.q() << __space << __x.omega();
1159
      __os << __space << __x._M_ad;
1160
      __os << __space << __x._M_ed;
1161
 
1162
      __os.flags(__flags);
1163
      __os.fill(__fill);
1164
      __os.precision(__precision);
1165
      return __os;
1166
    }
1167
 
1168
  template
1169
    std::basic_istream<_CharT, _Traits>&
1170
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
1171
               hoyt_distribution<_RealType>& __x)
1172
    {
1173
      typedef std::basic_istream<_CharT, _Traits>  __istream_type;
1174
      typedef typename __istream_type::ios_base    __ios_base;
1175
 
1176
      const typename __ios_base::fmtflags __flags = __is.flags();
1177
      __is.flags(__ios_base::dec | __ios_base::skipws);
1178
 
1179
      _RealType __q, __omega;
1180
      __is >> __q >> __omega;
1181
      __is >> __x._M_ad;
1182
      __is >> __x._M_ed;
1183
      __x.param(typename hoyt_distribution<_RealType>::
1184
                param_type(__q, __omega));
1185
 
1186
      __is.flags(__flags);
1187
      return __is;
1188
    }
1189
 
1190
_GLIBCXX_END_NAMESPACE_VERSION
1191
} // namespace
1192
 
1193
 
1194
#endif // _EXT_RANDOM_TCC

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.