Class: BoostDistributions::Hypergeometric

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

Hypergeometric.new(unsigned int r, unsigned int n, unsigned int N)

Class constructor.



17915
17916
17917
17918
17919
17920
17921
17922
17923
17924
17925
17926
17927
17928
17929
17930
17931
17932
17933
17934
17935
17936
17937
17938
17939
17940
17941
17942
17943
17944
17945
17946
17947
17948
17949
17950
17951
17952
17953
17954
17955
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17915

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

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

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

An instance method.



18319
18320
18321
18322
18323
18324
18325
18326
18327
18328
18329
18330
18331
18332
18333
18334
18335
18336
18337
18338
18339
18340
18341
18342
18343
18344
18345
18346
18347
18348
18349
18350
18351
18352
18353
18354
18355
18356
18357
18358
18359
18360
18361
18362
18363
18364
18365
18366
18367
18368
18369
18370
18371
18372
18373
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18319

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

#check_params(*args) ⇒ Object

call-seq:

check_params(char const * function, double * result) -> bool

An instance method.



18066
18067
18068
18069
18070
18071
18072
18073
18074
18075
18076
18077
18078
18079
18080
18081
18082
18083
18084
18085
18086
18087
18088
18089
18090
18091
18092
18093
18094
18095
18096
18097
18098
18099
18100
18101
18102
18103
18104
18105
18106
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18066

SWIGINTERN VALUE
_wrap_Hypergeometric_check_params(int argc, VALUE *argv, VALUE self) {
  boost::math::hypergeometric_distribution< double,policies::policy< > > *arg1 = (boost::math::hypergeometric_distribution< double,policies::policy< > > *) 0 ;
  char *arg2 = (char *) 0 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hypergeometric_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hypergeometric_distribution< double,policies::policy< > > const *","check_params", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hypergeometric_distribution< double,policies::policy< > > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","check_params", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","check_params", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  result = (bool)((boost::math::hypergeometric_distribution< double,policies::policy< > > const *)arg1)->check_params((char const *)arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

#check_x(*args) ⇒ Object

call-seq:

check_x(unsigned int x, char const * function, double * result) -> bool

An instance method.



18118
18119
18120
18121
18122
18123
18124
18125
18126
18127
18128
18129
18130
18131
18132
18133
18134
18135
18136
18137
18138
18139
18140
18141
18142
18143
18144
18145
18146
18147
18148
18149
18150
18151
18152
18153
18154
18155
18156
18157
18158
18159
18160
18161
18162
18163
18164
18165
18166
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18118

SWIGINTERN VALUE
_wrap_Hypergeometric_check_x(int argc, VALUE *argv, VALUE self) {
  boost::math::hypergeometric_distribution< double,policies::policy< > > *arg1 = (boost::math::hypergeometric_distribution< double,policies::policy< > > *) 0 ;
  unsigned int arg2 ;
  char *arg3 = (char *) 0 ;
  double *arg4 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__hypergeometric_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hypergeometric_distribution< double,policies::policy< > > const *","check_x", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hypergeometric_distribution< double,policies::policy< > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","check_x", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","check_x", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","check_x", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)((boost::math::hypergeometric_distribution< double,policies::policy< > > const *)arg1)->check_x(arg2,(char const *)arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



18592
18593
18594
18595
18596
18597
18598
18599
18600
18601
18602
18603
18604
18605
18606
18607
18608
18609
18610
18611
18612
18613
18614
18615
18616
18617
18618
18619
18620
18621
18622
18623
18624
18625
18626
18627
18628
18629
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18592

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

#defective(*args) ⇒ Object

call-seq:

defective -> unsigned int

An instance method.



18000
18001
18002
18003
18004
18005
18006
18007
18008
18009
18010
18011
18012
18013
18014
18015
18016
18017
18018
18019
18020
18021
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18000

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

#hazard(*args) ⇒ Object

call-seq:

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

An instance method.



18543
18544
18545
18546
18547
18548
18549
18550
18551
18552
18553
18554
18555
18556
18557
18558
18559
18560
18561
18562
18563
18564
18565
18566
18567
18568
18569
18570
18571
18572
18573
18574
18575
18576
18577
18578
18579
18580
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18543

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

An instance method.



18875
18876
18877
18878
18879
18880
18881
18882
18883
18884
18885
18886
18887
18888
18889
18890
18891
18892
18893
18894
18895
18896
18897
18898
18899
18900
18901
18902
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18875

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

An instance method.



18914
18915
18916
18917
18918
18919
18920
18921
18922
18923
18924
18925
18926
18927
18928
18929
18930
18931
18932
18933
18934
18935
18936
18937
18938
18939
18940
18941
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18914

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

An instance method.



18641
18642
18643
18644
18645
18646
18647
18648
18649
18650
18651
18652
18653
18654
18655
18656
18657
18658
18659
18660
18661
18662
18663
18664
18665
18666
18667
18668
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18641

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

An instance method.



18680
18681
18682
18683
18684
18685
18686
18687
18688
18689
18690
18691
18692
18693
18694
18695
18696
18697
18698
18699
18700
18701
18702
18703
18704
18705
18706
18707
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18680

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

An instance method.



18719
18720
18721
18722
18723
18724
18725
18726
18727
18728
18729
18730
18731
18732
18733
18734
18735
18736
18737
18738
18739
18740
18741
18742
18743
18744
18745
18746
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18719

SWIGINTERN VALUE
_wrap_Hypergeometric_mode(int argc, VALUE *argv, VALUE self) {
  boost::math::hypergeometric_distribution< double,policies::policy< > > *arg1 = (boost::math::hypergeometric_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hypergeometric_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__hypergeometric_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hypergeometric_distribution< double,policies::policy< > > const *","mode", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hypergeometric_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = (boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type)boost_math_hypergeometric_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__mode((boost::math::hypergeometric_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::hypergeometric_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type

An instance method.



18178
18179
18180
18181
18182
18183
18184
18185
18186
18187
18188
18189
18190
18191
18192
18193
18194
18195
18196
18197
18198
18199
18200
18201
18202
18203
18204
18205
18206
18207
18208
18209
18210
18211
18212
18213
18214
18215
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18178

SWIGINTERN VALUE
_wrap_Hypergeometric_pdf(int argc, VALUE *argv, VALUE self) {
  boost::math::hypergeometric_distribution< double,policies::policy< > > *arg1 = (boost::math::hypergeometric_distribution< double,policies::policy< > > *) 0 ;
  boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::hypergeometric_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__hypergeometric_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::hypergeometric_distribution< double,policies::policy< > > const *","pdf", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::hypergeometric_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::hypergeometric_distribution< double,policies::policy< > >::value_type","pdf", 2, argv[0] ));
  } 
  temp2 = static_cast< boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type >(val2);
  arg2 = &temp2;
  try {
    result = (boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type)boost_math_hypergeometric_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__pdf((boost::math::hypergeometric_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::hypergeometric_distribution< double,policies::policy< > >::value_type const & p,
bool const & is_complement=False) -> boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type
quantile(boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type const & p) -> boost::math::hypergeometric_distribution< double,policies::policy< > >::value_type

An instance method.



18477
18478
18479
18480
18481
18482
18483
18484
18485
18486
18487
18488
18489
18490
18491
18492
18493
18494
18495
18496
18497
18498
18499
18500
18501
18502
18503
18504
18505
18506
18507
18508
18509
18510
18511
18512
18513
18514
18515
18516
18517
18518
18519
18520
18521
18522
18523
18524
18525
18526
18527
18528
18529
18530
18531
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18477

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

#range(*args) ⇒ Object

call-seq:

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

An instance method.



18953
18954
18955
18956
18957
18958
18959
18960
18961
18962
18963
18964
18965
18966
18967
18968
18969
18970
18971
18972
18973
18974
18975
18976
18977
18978
18979
18980
18981
18982
18983
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18953

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

#sample_count(*args) ⇒ Object

call-seq:

sample_count -> unsigned int

An instance method.



18033
18034
18035
18036
18037
18038
18039
18040
18041
18042
18043
18044
18045
18046
18047
18048
18049
18050
18051
18052
18053
18054
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18033

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

#skewness(*args) ⇒ Object

call-seq:

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

An instance method.



18836
18837
18838
18839
18840
18841
18842
18843
18844
18845
18846
18847
18848
18849
18850
18851
18852
18853
18854
18855
18856
18857
18858
18859
18860
18861
18862
18863
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18836

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

An instance method.



18758
18759
18760
18761
18762
18763
18764
18765
18766
18767
18768
18769
18770
18771
18772
18773
18774
18775
18776
18777
18778
18779
18780
18781
18782
18783
18784
18785
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18758

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

An instance method.



18995
18996
18997
18998
18999
19000
19001
19002
19003
19004
19005
19006
19007
19008
19009
19010
19011
19012
19013
19014
19015
19016
19017
19018
19019
19020
19021
19022
19023
19024
19025
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18995

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

#total(*args) ⇒ Object

call-seq:

total -> unsigned int

An instance method.



17967
17968
17969
17970
17971
17972
17973
17974
17975
17976
17977
17978
17979
17980
17981
17982
17983
17984
17985
17986
17987
17988
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 17967

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

#variance(*args) ⇒ Object

call-seq:

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

An instance method.



18797
18798
18799
18800
18801
18802
18803
18804
18805
18806
18807
18808
18809
18810
18811
18812
18813
18814
18815
18816
18817
18818
18819
18820
18821
18822
18823
18824
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 18797

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