~ubuntu-branches/ubuntu/vivid/emscripten/vivid-proposed

« back to all changes in this revision

Viewing changes to system/include/libcxx/random

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2014-01-19 14:12:40 UTC
  • mfrom: (4.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140119141240-nfiw0p8033oitpfz
Tags: 1.9.0~20140119~7dc8c2f-1
* New snapshot release (Closes: #733714)
* Provide sources for javascript and flash. Done in orig-tar.sh
  Available in third_party/websockify/include/web-socket-js/src/
  (Closes: #735903)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1813
1813
};
1814
1814
 
1815
1815
template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1816
 
class _LIBCPP_TYPE_VIS linear_congruential_engine;
 
1816
class _LIBCPP_TYPE_VIS_ONLY linear_congruential_engine;
1817
1817
 
1818
1818
template <class _CharT, class _Traits,
1819
1819
          class _Up, _Up _Ap, _Up _Cp, _Up _Np>
1829
1829
           linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
1830
1830
 
1831
1831
template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1832
 
class _LIBCPP_TYPE_VIS linear_congruential_engine
 
1832
class _LIBCPP_TYPE_VIS_ONLY linear_congruential_engine
1833
1833
{
1834
1834
public:
1835
1835
    // types
2011
2011
template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2012
2012
          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2013
2013
          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2014
 
class _LIBCPP_TYPE_VIS mersenne_twister_engine;
 
2014
class _LIBCPP_TYPE_VIS_ONLY mersenne_twister_engine;
2015
2015
 
2016
2016
template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2017
2017
          _UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
2053
2053
template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2054
2054
          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2055
2055
          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2056
 
class _LIBCPP_TYPE_VIS mersenne_twister_engine
 
2056
class _LIBCPP_TYPE_VIS_ONLY mersenne_twister_engine
2057
2057
{
2058
2058
public:
2059
2059
    // types
2499
2499
// subtract_with_carry_engine
2500
2500
 
2501
2501
template<class _UIntType, size_t __w, size_t __s, size_t __r>
2502
 
class _LIBCPP_TYPE_VIS subtract_with_carry_engine;
 
2502
class _LIBCPP_TYPE_VIS_ONLY subtract_with_carry_engine;
2503
2503
 
2504
2504
template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
2505
2505
bool
2527
2527
           subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x);
2528
2528
 
2529
2529
template<class _UIntType, size_t __w, size_t __s, size_t __r>
2530
 
class _LIBCPP_TYPE_VIS subtract_with_carry_engine
 
2530
class _LIBCPP_TYPE_VIS_ONLY subtract_with_carry_engine
2531
2531
{
2532
2532
public:
2533
2533
    // types
2810
2810
// discard_block_engine
2811
2811
 
2812
2812
template<class _Engine, size_t __p, size_t __r>
2813
 
class _LIBCPP_TYPE_VIS discard_block_engine
 
2813
class _LIBCPP_TYPE_VIS_ONLY discard_block_engine
2814
2814
{
2815
2815
    _Engine __e_;
2816
2816
    int     __n_;
2983
2983
// independent_bits_engine
2984
2984
 
2985
2985
template<class _Engine, size_t __w, class _UIntType>
2986
 
class _LIBCPP_TYPE_VIS independent_bits_engine
 
2986
class _LIBCPP_TYPE_VIS_ONLY independent_bits_engine
2987
2987
{
2988
2988
    template <class _UI, _UI _R0, size_t _Wp, size_t _Mp>
2989
2989
    class __get_n
3246
3246
};
3247
3247
 
3248
3248
template<class _Engine, size_t __k>
3249
 
class _LIBCPP_TYPE_VIS shuffle_order_engine
 
3249
class _LIBCPP_TYPE_VIS_ONLY shuffle_order_engine
3250
3250
{
3251
3251
    static_assert(0 < __k, "shuffle_order_engine invalid parameters");
3252
3252
public:
3475
3475
 
3476
3476
class _LIBCPP_TYPE_VIS random_device
3477
3477
{
 
3478
#if !defined(_WIN32)
3478
3479
    int __f_;
 
3480
#endif // defined(_WIN32)
3479
3481
public:
3480
3482
    // types
3481
3483
    typedef unsigned result_type;
3507
3509
 
3508
3510
// seed_seq
3509
3511
 
3510
 
class _LIBCPP_TYPE_VIS seed_seq
 
3512
class _LIBCPP_TYPE_VIS_ONLY seed_seq
3511
3513
{
3512
3514
public:
3513
3515
    // types
3521
3523
public:
3522
3524
    // constructors
3523
3525
    _LIBCPP_INLINE_VISIBILITY
3524
 
    seed_seq() {}
 
3526
    seed_seq() _NOEXCEPT {}
3525
3527
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
3526
3528
    template<class _Tp>
3527
3529
        _LIBCPP_INLINE_VISIBILITY
3539
3541
 
3540
3542
    // property functions
3541
3543
    _LIBCPP_INLINE_VISIBILITY
3542
 
    size_t size() const {return __v_.size();}
 
3544
    size_t size() const _NOEXCEPT {return __v_.size();}
3543
3545
    template<class _OutputIterator>
3544
3546
        _LIBCPP_INLINE_VISIBILITY
3545
3547
        void param(_OutputIterator __dest) const
3684
3686
// uniform_real_distribution
3685
3687
 
3686
3688
template<class _RealType = double>
3687
 
class _LIBCPP_TYPE_VIS uniform_real_distribution
 
3689
class _LIBCPP_TYPE_VIS_ONLY uniform_real_distribution
3688
3690
{
3689
3691
public:
3690
3692
    // types
3691
3693
    typedef _RealType result_type;
3692
3694
 
3693
 
    class _LIBCPP_TYPE_VIS param_type
 
3695
    class _LIBCPP_TYPE_VIS_ONLY param_type
3694
3696
    {
3695
3697
        result_type __a_;
3696
3698
        result_type __b_;
3805
3807
 
3806
3808
// bernoulli_distribution
3807
3809
 
3808
 
class _LIBCPP_TYPE_VIS bernoulli_distribution
 
3810
class _LIBCPP_TYPE_VIS_ONLY bernoulli_distribution
3809
3811
{
3810
3812
public:
3811
3813
    // types
3812
3814
    typedef bool result_type;
3813
3815
 
3814
 
    class _LIBCPP_TYPE_VIS param_type
 
3816
    class _LIBCPP_TYPE_VIS_ONLY param_type
3815
3817
    {
3816
3818
        double __p_;
3817
3819
    public:
3914
3916
// binomial_distribution
3915
3917
 
3916
3918
template<class _IntType = int>
3917
 
class _LIBCPP_TYPE_VIS binomial_distribution
 
3919
class _LIBCPP_TYPE_VIS_ONLY binomial_distribution
3918
3920
{
3919
3921
public:
3920
3922
    // types
3921
3923
    typedef _IntType result_type;
3922
3924
 
3923
 
    class _LIBCPP_TYPE_VIS param_type
 
3925
    class _LIBCPP_TYPE_VIS_ONLY param_type
3924
3926
    {
3925
3927
        result_type __t_;
3926
3928
        double __p_;
4079
4081
// exponential_distribution
4080
4082
 
4081
4083
template<class _RealType = double>
4082
 
class _LIBCPP_TYPE_VIS exponential_distribution
 
4084
class _LIBCPP_TYPE_VIS_ONLY exponential_distribution
4083
4085
{
4084
4086
public:
4085
4087
    // types
4086
4088
    typedef _RealType result_type;
4087
4089
 
4088
 
    class _LIBCPP_TYPE_VIS param_type
 
4090
    class _LIBCPP_TYPE_VIS_ONLY param_type
4089
4091
    {
4090
4092
        result_type __lambda_;
4091
4093
    public:
4194
4196
// normal_distribution
4195
4197
 
4196
4198
template<class _RealType = double>
4197
 
class _LIBCPP_TYPE_VIS normal_distribution
 
4199
class _LIBCPP_TYPE_VIS_ONLY normal_distribution
4198
4200
{
4199
4201
public:
4200
4202
    // types
4201
4203
    typedef _RealType result_type;
4202
4204
 
4203
 
    class _LIBCPP_TYPE_VIS param_type
 
4205
    class _LIBCPP_TYPE_VIS_ONLY param_type
4204
4206
    {
4205
4207
        result_type __mean_;
4206
4208
        result_type __stddev_;
4362
4364
// lognormal_distribution
4363
4365
 
4364
4366
template<class _RealType = double>
4365
 
class _LIBCPP_TYPE_VIS lognormal_distribution
 
4367
class _LIBCPP_TYPE_VIS_ONLY lognormal_distribution
4366
4368
{
4367
4369
public:
4368
4370
    // types
4369
4371
    typedef _RealType result_type;
4370
4372
 
4371
 
    class _LIBCPP_TYPE_VIS param_type
 
4373
    class _LIBCPP_TYPE_VIS_ONLY param_type
4372
4374
    {
4373
4375
        normal_distribution<result_type> __nd_;
4374
4376
    public:
4487
4489
// poisson_distribution
4488
4490
 
4489
4491
template<class _IntType = int>
4490
 
class _LIBCPP_TYPE_VIS poisson_distribution
 
4492
class _LIBCPP_TYPE_VIS_ONLY poisson_distribution
4491
4493
{
4492
4494
public:
4493
4495
    // types
4494
4496
    typedef _IntType result_type;
4495
4497
 
4496
 
    class _LIBCPP_TYPE_VIS param_type
 
4498
    class _LIBCPP_TYPE_VIS_ONLY param_type
4497
4499
    {
4498
4500
        double __mean_;
4499
4501
        double __s_;
4718
4720
// weibull_distribution
4719
4721
 
4720
4722
template<class _RealType = double>
4721
 
class _LIBCPP_TYPE_VIS weibull_distribution
 
4723
class _LIBCPP_TYPE_VIS_ONLY weibull_distribution
4722
4724
{
4723
4725
public:
4724
4726
    // types
4725
4727
    typedef _RealType result_type;
4726
4728
 
4727
 
    class _LIBCPP_TYPE_VIS param_type
 
4729
    class _LIBCPP_TYPE_VIS_ONLY param_type
4728
4730
    {
4729
4731
        result_type __a_;
4730
4732
        result_type __b_;
4832
4834
}
4833
4835
 
4834
4836
template<class _RealType = double>
4835
 
class _LIBCPP_TYPE_VIS extreme_value_distribution
 
4837
class _LIBCPP_TYPE_VIS_ONLY extreme_value_distribution
4836
4838
{
4837
4839
public:
4838
4840
    // types
4839
4841
    typedef _RealType result_type;
4840
4842
 
4841
 
    class _LIBCPP_TYPE_VIS param_type
 
4843
    class _LIBCPP_TYPE_VIS_ONLY param_type
4842
4844
    {
4843
4845
        result_type __a_;
4844
4846
        result_type __b_;
4953
4955
// gamma_distribution
4954
4956
 
4955
4957
template<class _RealType = double>
4956
 
class _LIBCPP_TYPE_VIS gamma_distribution
 
4958
class _LIBCPP_TYPE_VIS_ONLY gamma_distribution
4957
4959
{
4958
4960
public:
4959
4961
    // types
4960
4962
    typedef _RealType result_type;
4961
4963
 
4962
 
    class _LIBCPP_TYPE_VIS param_type
 
4964
    class _LIBCPP_TYPE_VIS_ONLY param_type
4963
4965
    {
4964
4966
        result_type __alpha_;
4965
4967
        result_type __beta_;
5125
5127
// negative_binomial_distribution
5126
5128
 
5127
5129
template<class _IntType = int>
5128
 
class _LIBCPP_TYPE_VIS negative_binomial_distribution
 
5130
class _LIBCPP_TYPE_VIS_ONLY negative_binomial_distribution
5129
5131
{
5130
5132
public:
5131
5133
    // types
5132
5134
    typedef _IntType result_type;
5133
5135
 
5134
 
    class _LIBCPP_TYPE_VIS param_type
 
5136
    class _LIBCPP_TYPE_VIS_ONLY param_type
5135
5137
    {
5136
5138
        result_type __k_;
5137
5139
        double __p_;
5260
5262
// geometric_distribution
5261
5263
 
5262
5264
template<class _IntType = int>
5263
 
class _LIBCPP_TYPE_VIS geometric_distribution
 
5265
class _LIBCPP_TYPE_VIS_ONLY geometric_distribution
5264
5266
{
5265
5267
public:
5266
5268
    // types
5267
5269
    typedef _IntType result_type;
5268
5270
 
5269
 
    class _LIBCPP_TYPE_VIS param_type
 
5271
    class _LIBCPP_TYPE_VIS_ONLY param_type
5270
5272
    {
5271
5273
        double __p_;
5272
5274
    public:
5362
5364
// chi_squared_distribution
5363
5365
 
5364
5366
template<class _RealType = double>
5365
 
class _LIBCPP_TYPE_VIS chi_squared_distribution
 
5367
class _LIBCPP_TYPE_VIS_ONLY chi_squared_distribution
5366
5368
{
5367
5369
public:
5368
5370
    // types
5369
5371
    typedef _RealType result_type;
5370
5372
 
5371
 
    class _LIBCPP_TYPE_VIS param_type
 
5373
    class _LIBCPP_TYPE_VIS_ONLY param_type
5372
5374
    {
5373
5375
        result_type __n_;
5374
5376
    public:
5468
5470
// cauchy_distribution
5469
5471
 
5470
5472
template<class _RealType = double>
5471
 
class _LIBCPP_TYPE_VIS cauchy_distribution
 
5473
class _LIBCPP_TYPE_VIS_ONLY cauchy_distribution
5472
5474
{
5473
5475
public:
5474
5476
    // types
5475
5477
    typedef _RealType result_type;
5476
5478
 
5477
 
    class _LIBCPP_TYPE_VIS param_type
 
5479
    class _LIBCPP_TYPE_VIS_ONLY param_type
5478
5480
    {
5479
5481
        result_type __a_;
5480
5482
        result_type __b_;
5591
5593
// fisher_f_distribution
5592
5594
 
5593
5595
template<class _RealType = double>
5594
 
class _LIBCPP_TYPE_VIS fisher_f_distribution
 
5596
class _LIBCPP_TYPE_VIS_ONLY fisher_f_distribution
5595
5597
{
5596
5598
public:
5597
5599
    // types
5598
5600
    typedef _RealType result_type;
5599
5601
 
5600
 
    class _LIBCPP_TYPE_VIS param_type
 
5602
    class _LIBCPP_TYPE_VIS_ONLY param_type
5601
5603
    {
5602
5604
        result_type __m_;
5603
5605
        result_type __n_;
5713
5715
// student_t_distribution
5714
5716
 
5715
5717
template<class _RealType = double>
5716
 
class _LIBCPP_TYPE_VIS student_t_distribution
 
5718
class _LIBCPP_TYPE_VIS_ONLY student_t_distribution
5717
5719
{
5718
5720
public:
5719
5721
    // types
5720
5722
    typedef _RealType result_type;
5721
5723
 
5722
 
    class _LIBCPP_TYPE_VIS param_type
 
5724
    class _LIBCPP_TYPE_VIS_ONLY param_type
5723
5725
    {
5724
5726
        result_type __n_;
5725
5727
    public:
5826
5828
// discrete_distribution
5827
5829
 
5828
5830
template<class _IntType = int>
5829
 
class _LIBCPP_TYPE_VIS discrete_distribution
 
5831
class _LIBCPP_TYPE_VIS_ONLY discrete_distribution
5830
5832
{
5831
5833
public:
5832
5834
    // types
5833
5835
    typedef _IntType result_type;
5834
5836
 
5835
 
    class _LIBCPP_TYPE_VIS param_type
 
5837
    class _LIBCPP_TYPE_VIS_ONLY param_type
5836
5838
    {
5837
5839
        vector<double> __p_;
5838
5840
    public:
5901
5903
        discrete_distribution(size_t __nw, double __xmin, double __xmax,
5902
5904
                              _UnaryOperation __fw)
5903
5905
        : __p_(__nw, __xmin, __xmax, __fw) {}
 
5906
    _LIBCPP_INLINE_VISIBILITY
5904
5907
    explicit discrete_distribution(const param_type& __p)
5905
 
    _LIBCPP_INLINE_VISIBILITY
5906
5908
        : __p_(__p) {}
5907
5909
    _LIBCPP_INLINE_VISIBILITY
5908
5910
    void reset() {}
6057
6059
// piecewise_constant_distribution
6058
6060
 
6059
6061
template<class _RealType = double>
6060
 
class _LIBCPP_TYPE_VIS piecewise_constant_distribution
 
6062
class _LIBCPP_TYPE_VIS_ONLY piecewise_constant_distribution
6061
6063
{
6062
6064
public:
6063
6065
    // types
6064
6066
    typedef _RealType result_type;
6065
6067
 
6066
 
    class _LIBCPP_TYPE_VIS param_type
 
6068
    class _LIBCPP_TYPE_VIS_ONLY param_type
6067
6069
    {
6068
6070
        vector<result_type> __b_;
6069
6071
        vector<result_type> __densities_;
6381
6383
// piecewise_linear_distribution
6382
6384
 
6383
6385
template<class _RealType = double>
6384
 
class _LIBCPP_TYPE_VIS piecewise_linear_distribution
 
6386
class _LIBCPP_TYPE_VIS_ONLY piecewise_linear_distribution
6385
6387
{
6386
6388
public:
6387
6389
    // types
6388
6390
    typedef _RealType result_type;
6389
6391
 
6390
 
    class _LIBCPP_TYPE_VIS param_type
 
6392
    class _LIBCPP_TYPE_VIS_ONLY param_type
6391
6393
    {
6392
6394
        vector<result_type> __b_;
6393
6395
        vector<result_type> __densities_;