Class: BoostDistributions::NegativeBinomial

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::NegativeBinomial class

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

NegativeBinomial.new(double r, double p)

Class constructor.



26686
26687
26688
26689
26690
26691
26692
26693
26694
26695
26696
26697
26698
26699
26700
26701
26702
26703
26704
26705
26706
26707
26708
26709
26710
26711
26712
26713
26714
26715
26716
26717
26718
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 26686

SWIGINTERN VALUE
_wrap_new_NegativeBinomial(int argc, VALUE *argv, VALUE self) {
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::negative_binomial_distribution< double,policies::policy< > > *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","negative_binomial_distribution<(double,policies::policy<()>)>", 1, argv[0] ));
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","negative_binomial_distribution<(double,policies::policy<()>)>", 2, argv[1] ));
  } 
  arg2 = static_cast< double >(val2);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > > *)new boost::math::negative_binomial_distribution< double,policies::policy< > >(arg1,arg2);
    DATA_PTR(self) = result;
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  return self;
fail:
  return Qnil;
}

Class Method Details

.find_lower_bound_on_p(*args) ⇒ Object

call-seq:

find_lower_bound_on_p(double trials, double successes, double alpha) -> double

A class method.



26796
26797
26798
26799
26800
26801
26802
26803
26804
26805
26806
26807
26808
26809
26810
26811
26812
26813
26814
26815
26816
26817
26818
26819
26820
26821
26822
26823
26824
26825
26826
26827
26828
26829
26830
26831
26832
26833
26834
26835
26836
26837
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 26796

SWIGINTERN VALUE
_wrap_NegativeBinomial_find_lower_bound_on_p(int argc, VALUE *argv, VALUE self) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_lower_bound_on_p", 1, argv[0] ));
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_lower_bound_on_p", 2, argv[1] ));
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_lower_bound_on_p", 3, argv[2] ));
  } 
  arg3 = static_cast< double >(val3);
  try {
    result = (double)boost::math::negative_binomial_distribution< double,policies::policy< > >::SWIGTEMPLATEDISAMBIGUATOR find_lower_bound_on_p(arg1,arg2,arg3);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

.find_maximum_number_of_trials(*args) ⇒ Object

call-seq:

find_maximum_number_of_trials(double k, double p, double alpha) -> double

A class method.



26955
26956
26957
26958
26959
26960
26961
26962
26963
26964
26965
26966
26967
26968
26969
26970
26971
26972
26973
26974
26975
26976
26977
26978
26979
26980
26981
26982
26983
26984
26985
26986
26987
26988
26989
26990
26991
26992
26993
26994
26995
26996
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 26955

SWIGINTERN VALUE
_wrap_NegativeBinomial_find_maximum_number_of_trials(int argc, VALUE *argv, VALUE self) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_maximum_number_of_trials", 1, argv[0] ));
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_maximum_number_of_trials", 2, argv[1] ));
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_maximum_number_of_trials", 3, argv[2] ));
  } 
  arg3 = static_cast< double >(val3);
  try {
    result = (double)boost::math::negative_binomial_distribution< double,policies::policy< > >::SWIGTEMPLATEDISAMBIGUATOR find_maximum_number_of_trials(arg1,arg2,arg3);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

.find_minimum_number_of_trials(*args) ⇒ Object

call-seq:

find_minimum_number_of_trials(double k, double p, double alpha) -> double

A class method.



26902
26903
26904
26905
26906
26907
26908
26909
26910
26911
26912
26913
26914
26915
26916
26917
26918
26919
26920
26921
26922
26923
26924
26925
26926
26927
26928
26929
26930
26931
26932
26933
26934
26935
26936
26937
26938
26939
26940
26941
26942
26943
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 26902

SWIGINTERN VALUE
_wrap_NegativeBinomial_find_minimum_number_of_trials(int argc, VALUE *argv, VALUE self) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_minimum_number_of_trials", 1, argv[0] ));
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_minimum_number_of_trials", 2, argv[1] ));
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_minimum_number_of_trials", 3, argv[2] ));
  } 
  arg3 = static_cast< double >(val3);
  try {
    result = (double)boost::math::negative_binomial_distribution< double,policies::policy< > >::SWIGTEMPLATEDISAMBIGUATOR find_minimum_number_of_trials(arg1,arg2,arg3);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

.find_upper_bound_on_p(*args) ⇒ Object

call-seq:

find_upper_bound_on_p(double trials, double successes, double alpha) -> double

A class method.



26849
26850
26851
26852
26853
26854
26855
26856
26857
26858
26859
26860
26861
26862
26863
26864
26865
26866
26867
26868
26869
26870
26871
26872
26873
26874
26875
26876
26877
26878
26879
26880
26881
26882
26883
26884
26885
26886
26887
26888
26889
26890
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 26849

SWIGINTERN VALUE
_wrap_NegativeBinomial_find_upper_bound_on_p(int argc, VALUE *argv, VALUE self) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_upper_bound_on_p", 1, argv[0] ));
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_upper_bound_on_p", 2, argv[1] ));
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","boost::math::negative_binomial_distribution<(double,policies::policy<()>)>::find_upper_bound_on_p", 3, argv[2] ));
  } 
  arg3 = static_cast< double >(val3);
  try {
    result = (double)boost::math::negative_binomial_distribution< double,policies::policy< > >::SWIGTEMPLATEDISAMBIGUATOR find_upper_bound_on_p(arg1,arg2,arg3);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

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

An instance method.



27149
27150
27151
27152
27153
27154
27155
27156
27157
27158
27159
27160
27161
27162
27163
27164
27165
27166
27167
27168
27169
27170
27171
27172
27173
27174
27175
27176
27177
27178
27179
27180
27181
27182
27183
27184
27185
27186
27187
27188
27189
27190
27191
27192
27193
27194
27195
27196
27197
27198
27199
27200
27201
27202
27203
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27149

SWIGINTERN VALUE _wrap_NegativeBinomial_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__negative_binomial_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_NegativeBinomial_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__negative_binomial_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_NegativeBinomial_cdf__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "cdf", 
    "    boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type cdf(boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type const &x, bool const &is_complement)\n"
    "    boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type cdf(boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type const &x)\n");
  
  return Qnil;
}

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



27422
27423
27424
27425
27426
27427
27428
27429
27430
27431
27432
27433
27434
27435
27436
27437
27438
27439
27440
27441
27442
27443
27444
27445
27446
27447
27448
27449
27450
27451
27452
27453
27454
27455
27456
27457
27458
27459
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27422

SWIGINTERN VALUE
_wrap_NegativeBinomial_chf(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","chf", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type","chf", 2, argv[0] ));
  } 
  temp2 = static_cast< boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type >(val2);
  arg2 = &temp2;
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__chf((boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type

An instance method.



27373
27374
27375
27376
27377
27378
27379
27380
27381
27382
27383
27384
27385
27386
27387
27388
27389
27390
27391
27392
27393
27394
27395
27396
27397
27398
27399
27400
27401
27402
27403
27404
27405
27406
27407
27408
27409
27410
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27373

SWIGINTERN VALUE
_wrap_NegativeBinomial_hazard(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","hazard", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type","hazard", 2, argv[0] ));
  } 
  temp2 = static_cast< boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type >(val2);
  arg2 = &temp2;
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__hazard((boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type

An instance method.



27705
27706
27707
27708
27709
27710
27711
27712
27713
27714
27715
27716
27717
27718
27719
27720
27721
27722
27723
27724
27725
27726
27727
27728
27729
27730
27731
27732
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27705

SWIGINTERN VALUE
_wrap_NegativeBinomial_kurtosis(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","kurtosis", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__kurtosis((boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type

An instance method.



27744
27745
27746
27747
27748
27749
27750
27751
27752
27753
27754
27755
27756
27757
27758
27759
27760
27761
27762
27763
27764
27765
27766
27767
27768
27769
27770
27771
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27744

SWIGINTERN VALUE
_wrap_NegativeBinomial_kurtosis_excess(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","kurtosis_excess", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__kurtosis_excess((boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type

An instance method.



27471
27472
27473
27474
27475
27476
27477
27478
27479
27480
27481
27482
27483
27484
27485
27486
27487
27488
27489
27490
27491
27492
27493
27494
27495
27496
27497
27498
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27471

SWIGINTERN VALUE
_wrap_NegativeBinomial_mean(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","mean", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__mean((boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type

An instance method.



27510
27511
27512
27513
27514
27515
27516
27517
27518
27519
27520
27521
27522
27523
27524
27525
27526
27527
27528
27529
27530
27531
27532
27533
27534
27535
27536
27537
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27510

SWIGINTERN VALUE
_wrap_NegativeBinomial_median(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","median", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__median((boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type

An instance method.



27549
27550
27551
27552
27553
27554
27555
27556
27557
27558
27559
27560
27561
27562
27563
27564
27565
27566
27567
27568
27569
27570
27571
27572
27573
27574
27575
27576
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27549

SWIGINTERN VALUE
_wrap_NegativeBinomial_mode(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","mode", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__mode((boost::math::negative_binomial_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;
}

#pdf(*args) ⇒ Object

call-seq:

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

An instance method.



27008
27009
27010
27011
27012
27013
27014
27015
27016
27017
27018
27019
27020
27021
27022
27023
27024
27025
27026
27027
27028
27029
27030
27031
27032
27033
27034
27035
27036
27037
27038
27039
27040
27041
27042
27043
27044
27045
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27008

SWIGINTERN VALUE
_wrap_NegativeBinomial_pdf(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","pdf", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type","pdf", 2, argv[0] ));
  } 
  temp2 = static_cast< boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type >(val2);
  arg2 = &temp2;
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__pdf((boost::math::negative_binomial_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;
}

#quantile(*args, self) ⇒ Object

call-seq:

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

An instance method.



27307
27308
27309
27310
27311
27312
27313
27314
27315
27316
27317
27318
27319
27320
27321
27322
27323
27324
27325
27326
27327
27328
27329
27330
27331
27332
27333
27334
27335
27336
27337
27338
27339
27340
27341
27342
27343
27344
27345
27346
27347
27348
27349
27350
27351
27352
27353
27354
27355
27356
27357
27358
27359
27360
27361
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27307

SWIGINTERN VALUE _wrap_NegativeBinomial_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__negative_binomial_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_NegativeBinomial_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__negative_binomial_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_NegativeBinomial_quantile__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "quantile", 
    "    boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type quantile(boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type const &p, bool const &is_complement)\n"
    "    boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type quantile(boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type const &p)\n");
  
  return Qnil;
}

#range(*args) ⇒ Object

call-seq:

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

An instance method.



27783
27784
27785
27786
27787
27788
27789
27790
27791
27792
27793
27794
27795
27796
27797
27798
27799
27800
27801
27802
27803
27804
27805
27806
27807
27808
27809
27810
27811
27812
27813
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27783

SWIGINTERN VALUE
_wrap_NegativeBinomial_range(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type,boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","range", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__range((boost::math::negative_binomial_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;
}

#skewness(*args) ⇒ Object

call-seq:

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

An instance method.



27666
27667
27668
27669
27670
27671
27672
27673
27674
27675
27676
27677
27678
27679
27680
27681
27682
27683
27684
27685
27686
27687
27688
27689
27690
27691
27692
27693
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27666

SWIGINTERN VALUE
_wrap_NegativeBinomial_skewness(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","skewness", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__skewness((boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type

An instance method.



27588
27589
27590
27591
27592
27593
27594
27595
27596
27597
27598
27599
27600
27601
27602
27603
27604
27605
27606
27607
27608
27609
27610
27611
27612
27613
27614
27615
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27588

SWIGINTERN VALUE
_wrap_NegativeBinomial_standard_deviation(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","standard_deviation", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__standard_deviation((boost::math::negative_binomial_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;
}

#success_fraction(*args) ⇒ Object

call-seq:

success_fraction -> double

An instance method.



26730
26731
26732
26733
26734
26735
26736
26737
26738
26739
26740
26741
26742
26743
26744
26745
26746
26747
26748
26749
26750
26751
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 26730

SWIGINTERN VALUE
_wrap_NegativeBinomial_success_fraction(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","success_fraction", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  result = (double)((boost::math::negative_binomial_distribution< double,policies::policy< > > const *)arg1)->success_fraction();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#successes(*args) ⇒ Object

call-seq:

successes -> double

An instance method.



26763
26764
26765
26766
26767
26768
26769
26770
26771
26772
26773
26774
26775
26776
26777
26778
26779
26780
26781
26782
26783
26784
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 26763

SWIGINTERN VALUE
_wrap_NegativeBinomial_successes(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","successes", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  result = (double)((boost::math::negative_binomial_distribution< double,policies::policy< > > const *)arg1)->successes();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#support(*args) ⇒ Object

call-seq:

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

An instance method.



27825
27826
27827
27828
27829
27830
27831
27832
27833
27834
27835
27836
27837
27838
27839
27840
27841
27842
27843
27844
27845
27846
27847
27848
27849
27850
27851
27852
27853
27854
27855
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27825

SWIGINTERN VALUE
_wrap_NegativeBinomial_support(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type,boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","support", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__support((boost::math::negative_binomial_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::negative_binomial_distribution< double,policies::policy< > >::value_type

An instance method.



27627
27628
27629
27630
27631
27632
27633
27634
27635
27636
27637
27638
27639
27640
27641
27642
27643
27644
27645
27646
27647
27648
27649
27650
27651
27652
27653
27654
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 27627

SWIGINTERN VALUE
_wrap_NegativeBinomial_variance(int argc, VALUE *argv, VALUE self) {
  boost::math::negative_binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::negative_binomial_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::negative_binomial_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__negative_binomial_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::negative_binomial_distribution< double,policies::policy< > > const *","variance", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::negative_binomial_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::negative_binomial_distribution< double,policies::policy< > >::value_type)boost_math_negative_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__variance((boost::math::negative_binomial_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;
}