Class: BoostDistributions::Hyperexponential

Inherits:
Object
  • Object
show all
Defined in:
ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx,
ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx

Overview

Proxy of C++ BoostDistributions::Hyperexponential class

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



16970
16971
16972
16973
16974
16975
16976
16977
16978
16979
16980
16981
16982
16983
16984
16985
16986
16987
16988
16989
16990
16991
16992
16993
16994
16995
16996
16997
16998
16999
17000
17001
17002
17003
17004
17005
17006
17007
17008
17009
17010
17011
17012
17013
17014
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16970

SWIGINTERN VALUE _wrap_new_Hyperexponential(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Hyperexponential__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Hyperexponential__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Hyperexponential__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Hyperexponential.new", 
    "    Hyperexponential.new()\n"
    "    Hyperexponential.new(std::vector< double > const &prob, std::vector< double > const &range)\n"
    "    Hyperexponential.new(std::vector< double > const &range)\n");
  
  return Qnil;
}

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

cdf(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const & x,
bool const & is_complement=False) -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type
cdf(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17167
17168
17169
17170
17171
17172
17173
17174
17175
17176
17177
17178
17179
17180
17181
17182
17183
17184
17185
17186
17187
17188
17189
17190
17191
17192
17193
17194
17195
17196
17197
17198
17199
17200
17201
17202
17203
17204
17205
17206
17207
17208
17209
17210
17211
17212
17213
17214
17215
17216
17217
17218
17219
17220
17221
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17167

SWIGINTERN VALUE _wrap_Hyperexponential_cdf(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hyperexponential_cdf__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hyperexponential_cdf__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "cdf", 
    "    boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type cdf(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const &x, bool const &is_complement)\n"
    "    boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type cdf(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const &x)\n");
  
  return Qnil;
}

#chf(*args) ⇒ Object

call-seq:

chf(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17440
17441
17442
17443
17444
17445
17446
17447
17448
17449
17450
17451
17452
17453
17454
17455
17456
17457
17458
17459
17460
17461
17462
17463
17464
17465
17466
17467
17468
17469
17470
17471
17472
17473
17474
17475
17476
17477
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17440

SWIGINTERN VALUE
_wrap_Hyperexponential_chf(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","chf", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type","chf", 2, argv[0] ));
  } 
  temp2 = static_cast< boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type >(val2);
  arg2 = &temp2;
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__chf((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1,(double const &)*arg2);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#hazard(*args) ⇒ Object

call-seq:

hazard(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17391
17392
17393
17394
17395
17396
17397
17398
17399
17400
17401
17402
17403
17404
17405
17406
17407
17408
17409
17410
17411
17412
17413
17414
17415
17416
17417
17418
17419
17420
17421
17422
17423
17424
17425
17426
17427
17428
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17391

SWIGINTERN VALUE
_wrap_Hyperexponential_hazard(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","hazard", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type","hazard", 2, argv[0] ));
  } 
  temp2 = static_cast< boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type >(val2);
  arg2 = &temp2;
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__hazard((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1,(double const &)*arg2);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#kurtosis(*args) ⇒ Object

call-seq:

kurtosis -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17723
17724
17725
17726
17727
17728
17729
17730
17731
17732
17733
17734
17735
17736
17737
17738
17739
17740
17741
17742
17743
17744
17745
17746
17747
17748
17749
17750
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17723

SWIGINTERN VALUE
_wrap_Hyperexponential_kurtosis(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","kurtosis", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__kurtosis((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#kurtosis_excess(*args) ⇒ Object

call-seq:

kurtosis_excess -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17762
17763
17764
17765
17766
17767
17768
17769
17770
17771
17772
17773
17774
17775
17776
17777
17778
17779
17780
17781
17782
17783
17784
17785
17786
17787
17788
17789
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17762

SWIGINTERN VALUE
_wrap_Hyperexponential_kurtosis_excess(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","kurtosis_excess", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__kurtosis_excess((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#mean(*args) ⇒ Object

call-seq:

mean -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17489
17490
17491
17492
17493
17494
17495
17496
17497
17498
17499
17500
17501
17502
17503
17504
17505
17506
17507
17508
17509
17510
17511
17512
17513
17514
17515
17516
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17489

SWIGINTERN VALUE
_wrap_Hyperexponential_mean(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","mean", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__mean((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#median(*args) ⇒ Object

call-seq:

median -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17528
17529
17530
17531
17532
17533
17534
17535
17536
17537
17538
17539
17540
17541
17542
17543
17544
17545
17546
17547
17548
17549
17550
17551
17552
17553
17554
17555
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17528

SWIGINTERN VALUE
_wrap_Hyperexponential_median(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","median", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__median((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#mode(*args) ⇒ Object

call-seq:

mode -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17567
17568
17569
17570
17571
17572
17573
17574
17575
17576
17577
17578
17579
17580
17581
17582
17583
17584
17585
17586
17587
17588
17589
17590
17591
17592
17593
17594
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17567

SWIGINTERN VALUE
_wrap_Hyperexponential_mode(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","mode", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__mode((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#num_phases(*args) ⇒ Object

call-seq:

num_phases -> std::size_t

An instance method.



16834
16835
16836
16837
16838
16839
16840
16841
16842
16843
16844
16845
16846
16847
16848
16849
16850
16851
16852
16853
16854
16855
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16834

SWIGINTERN VALUE
_wrap_Hyperexponential_num_phases(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","num_phases", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  result = ((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1)->num_phases();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#pdf(*args) ⇒ Object

call-seq:

pdf(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17026
17027
17028
17029
17030
17031
17032
17033
17034
17035
17036
17037
17038
17039
17040
17041
17042
17043
17044
17045
17046
17047
17048
17049
17050
17051
17052
17053
17054
17055
17056
17057
17058
17059
17060
17061
17062
17063
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17026

SWIGINTERN VALUE
_wrap_Hyperexponential_pdf(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","pdf", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type","pdf", 2, argv[0] ));
  } 
  temp2 = static_cast< boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type >(val2);
  arg2 = &temp2;
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__pdf((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1,(double const &)*arg2);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#probabilities(*args) ⇒ Object

call-seq:

probabilities -> std::vector< double >

An instance method.



16758
16759
16760
16761
16762
16763
16764
16765
16766
16767
16768
16769
16770
16771
16772
16773
16774
16775
16776
16777
16778
16779
16780
16781
16782
16783
16784
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16758

SWIGINTERN VALUE
_wrap_Hyperexponential_probabilities(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","probabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  result = ((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1)->probabilities();
  {
    for(typename std::vector< double >::const_iterator it((&result)->begin()), it_end((&result)->end());
      it != it_end; ++it){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(*it));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#quantile(*args, self) ⇒ Object

call-seq:

quantile(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const & p,
bool const & is_complement=False) -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type
quantile(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const & p) -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17325
17326
17327
17328
17329
17330
17331
17332
17333
17334
17335
17336
17337
17338
17339
17340
17341
17342
17343
17344
17345
17346
17347
17348
17349
17350
17351
17352
17353
17354
17355
17356
17357
17358
17359
17360
17361
17362
17363
17364
17365
17366
17367
17368
17369
17370
17371
17372
17373
17374
17375
17376
17377
17378
17379
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17325

SWIGINTERN VALUE _wrap_Hyperexponential_quantile(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hyperexponential_quantile__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hyperexponential_quantile__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "quantile", 
    "    boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type quantile(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const &p, bool const &is_complement)\n"
    "    boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type quantile(boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type const &p)\n");
  
  return Qnil;
}

#range(*args) ⇒ Object

call-seq:

range -> std::pair< boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type,boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type >

An instance method.



17801
17802
17803
17804
17805
17806
17807
17808
17809
17810
17811
17812
17813
17814
17815
17816
17817
17818
17819
17820
17821
17822
17823
17824
17825
17826
17827
17828
17829
17830
17831
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17801

SWIGINTERN VALUE
_wrap_Hyperexponential_range(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type,boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","range", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__range((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->first));
    vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->second));
  }
  return vresult;
fail:
  return Qnil;
}

#rates(*args) ⇒ Object

call-seq:

rates -> std::vector< double >

An instance method.



16796
16797
16798
16799
16800
16801
16802
16803
16804
16805
16806
16807
16808
16809
16810
16811
16812
16813
16814
16815
16816
16817
16818
16819
16820
16821
16822
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16796

SWIGINTERN VALUE
_wrap_Hyperexponential_rates(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","rates", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  result = ((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1)->rates();
  {
    for(typename std::vector< double >::const_iterator it((&result)->begin()), it_end((&result)->end());
      it != it_end; ++it){
      vresult = SWIG_Ruby_AppendOutput(vresult, swig::from(*it));
    }
  }
  return vresult;
fail:
  return Qnil;
}

#skewness(*args) ⇒ Object

call-seq:

skewness -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17684
17685
17686
17687
17688
17689
17690
17691
17692
17693
17694
17695
17696
17697
17698
17699
17700
17701
17702
17703
17704
17705
17706
17707
17708
17709
17710
17711
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17684

SWIGINTERN VALUE
_wrap_Hyperexponential_skewness(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","skewness", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__skewness((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#standard_deviation(*args) ⇒ Object

call-seq:

standard_deviation -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17606
17607
17608
17609
17610
17611
17612
17613
17614
17615
17616
17617
17618
17619
17620
17621
17622
17623
17624
17625
17626
17627
17628
17629
17630
17631
17632
17633
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17606

SWIGINTERN VALUE
_wrap_Hyperexponential_standard_deviation(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","standard_deviation", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__standard_deviation((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#support(*args) ⇒ Object

call-seq:

support -> std::pair< boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type,boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type >

An instance method.



17843
17844
17845
17846
17847
17848
17849
17850
17851
17852
17853
17854
17855
17856
17857
17858
17859
17860
17861
17862
17863
17864
17865
17866
17867
17868
17869
17870
17871
17872
17873
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17843

SWIGINTERN VALUE
_wrap_Hyperexponential_support(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type,boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","support", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__support((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->first));
    vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->second));
  }
  return vresult;
fail:
  return Qnil;
}

#variance(*args) ⇒ Object

call-seq:

variance -> boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type

An instance method.



17645
17646
17647
17648
17649
17650
17651
17652
17653
17654
17655
17656
17657
17658
17659
17660
17661
17662
17663
17664
17665
17666
17667
17668
17669
17670
17671
17672
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17645

SWIGINTERN VALUE
_wrap_Hyperexponential_variance(int argc, VALUE *argv, VALUE self) {
  boost::math::hyperexponential_distribution< double,policies::policy< > > *arg1 = (boost::math::hyperexponential_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hyperexponential_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hyperexponential_distribution< double,policies::policy< > > const *","variance", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hyperexponential_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hyperexponential_distribution< double,policies::policy< > >::value_type)boost_math_hyperexponential_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__variance((boost::math::hyperexponential_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}