Class: BoostDistributions::Binomial
- Inherits:
-
Object
- Object
- BoostDistributions::Binomial
- Defined in:
- ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx,
ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx
Overview
Proxy of C++ BoostDistributions::Binomial class
Class Method Summary collapse
-
.find_lower_bound_on_p(*args, self) ⇒ Object
call-seq: find_lower_bound_on_p(double trials, double successes, double probability, boost::math::binomial_distribution< double,policies::policy< > >::interval_type t=boost::math::binomial_distribution< double,policies::policy< > >::clopper_pearson_exact_interval) -> double find_lower_bound_on_p(double trials, double successes, double probability) -> double.
-
.find_maximum_number_of_trials(*args) ⇒ Object
call-seq: find_maximum_number_of_trials(double k, double p, double alpha) -> double.
-
.find_minimum_number_of_trials(*args) ⇒ Object
call-seq: find_minimum_number_of_trials(double k, double p, double alpha) -> double.
-
.find_upper_bound_on_p(*args, self) ⇒ Object
call-seq: find_upper_bound_on_p(double trials, double successes, double probability, boost::math::binomial_distribution< double,policies::policy< > >::interval_type t=boost::math::binomial_distribution< double,policies::policy< > >::clopper_pearson_exact_interval) -> double find_upper_bound_on_p(double trials, double successes, double probability) -> double.
Instance Method Summary collapse
-
#cdf(*args, self) ⇒ Object
call-seq: cdf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & x, bool const & is_complement=False) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type cdf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#chf(*args) ⇒ Object
call-seq: chf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#hazard(*args) ⇒ Object
call-seq: hazard(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
- #initialize(*args, self) ⇒ Object constructor
-
#kurtosis(*args) ⇒ Object
call-seq: kurtosis -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#kurtosis_excess(*args) ⇒ Object
call-seq: kurtosis_excess -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#mean(*args) ⇒ Object
call-seq: mean -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#median(*args) ⇒ Object
call-seq: median -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#mode(*args) ⇒ Object
call-seq: mode -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#pdf(*args) ⇒ Object
call-seq: pdf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#quantile(*args, self) ⇒ Object
call-seq: quantile(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & p, bool const & is_complement=False) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type quantile(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & p) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#range(*args) ⇒ Object
call-seq: range -> std::pair< boost::math::binomial_distribution< double,policies::policy< > >::value_type,boost::math::binomial_distribution< double,policies::policy< > >::value_type >.
-
#skewness(*args) ⇒ Object
call-seq: skewness -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#standard_deviation(*args) ⇒ Object
call-seq: standard_deviation -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
-
#success_fraction(*args) ⇒ Object
call-seq: success_fraction -> double.
-
#support(*args) ⇒ Object
call-seq: support -> std::pair< boost::math::binomial_distribution< double,policies::policy< > >::value_type,boost::math::binomial_distribution< double,policies::policy< > >::value_type >.
-
#trials(*args) ⇒ Object
call-seq: trials -> double.
-
#variance(*args) ⇒ Object
call-seq: variance -> boost::math::binomial_distribution< double,policies::policy< > >::value_type.
Constructor Details
#initialize(*args, self) ⇒ Object
7857 7858 7859 7860 7861 7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 7857
SWIGINTERN VALUE _wrap_new_Binomial(int nargs, VALUE *args, VALUE self) {
int argc;
VALUE argv[2];
int ii;
argc = nargs;
if (argc > 2) SWIG_fail;
for (ii = 0; (ii < argc); ++ii) {
argv[ii] = args[ii];
}
if (argc == 0) {
return _wrap_new_Binomial__SWIG_2(nargs, args, self);
}
if (argc == 1) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_Binomial__SWIG_1(nargs, args, self);
}
}
if (argc == 2) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_Binomial__SWIG_0(nargs, args, self);
}
}
}
fail:
Ruby_Format_OverloadedError( argc, 2, "Binomial.new",
" Binomial.new(double n, double p)\n"
" Binomial.new(double n)\n"
" Binomial.new()\n");
return Qnil;
}
|
Class Method Details
.find_lower_bound_on_p(*args, self) ⇒ Object
call-seq:
find_lower_bound_on_p(double trials, double successes, double probability, boost::math::binomial_distribution< double,policies::policy< > >::interval_type t=boost::math::binomial_distribution< double,policies::policy< > >::clopper_pearson_exact_interval) -> double
find_lower_bound_on_p(double trials, double successes, double probability) -> double
A class method.
8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8097
SWIGINTERN VALUE _wrap_Binomial_find_lower_bound_on_p(int nargs, VALUE *args, VALUE self) {
int argc;
VALUE argv[4];
int ii;
argc = nargs;
if (argc > 4) SWIG_fail;
for (ii = 0; (ii < argc); ++ii) {
argv[ii] = args[ii];
}
if (argc == 3) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Binomial_find_lower_bound_on_p__SWIG_1(nargs, args, self);
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Binomial_find_lower_bound_on_p__SWIG_0(nargs, args, self);
}
}
}
}
}
fail:
Ruby_Format_OverloadedError( argc, 4, "Binomial.find_lower_bound_on_p",
" double Binomial.find_lower_bound_on_p(double trials, double successes, double probability, boost::math::binomial_distribution< double,policies::policy< > >::interval_type t)\n"
" double Binomial.find_lower_bound_on_p(double trials, double successes, double probability)\n");
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.
8405 8406 8407 8408 8409 8410 8411 8412 8413 8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8405
SWIGINTERN VALUE
_wrap_Binomial_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::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::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::binomial_distribution<(double,policies::policy<()>)>::find_maximum_number_of_trials", 3, argv[2] ));
}
arg3 = static_cast< double >(val3);
try {
result = (double)boost::math::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.
8352 8353 8354 8355 8356 8357 8358 8359 8360 8361 8362 8363 8364 8365 8366 8367 8368 8369 8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391 8392 8393 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8352
SWIGINTERN VALUE
_wrap_Binomial_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::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::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::binomial_distribution<(double,policies::policy<()>)>::find_minimum_number_of_trials", 3, argv[2] ));
}
arg3 = static_cast< double >(val3);
try {
result = (double)boost::math::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, self) ⇒ Object
call-seq:
find_upper_bound_on_p(double trials, double successes, double probability, boost::math::binomial_distribution< double,policies::policy< > >::interval_type t=boost::math::binomial_distribution< double,policies::policy< > >::clopper_pearson_exact_interval) -> double
find_upper_bound_on_p(double trials, double successes, double probability) -> double
A class method.
8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329 8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8273
SWIGINTERN VALUE _wrap_Binomial_find_upper_bound_on_p(int nargs, VALUE *args, VALUE self) {
int argc;
VALUE argv[4];
int ii;
argc = nargs;
if (argc > 4) SWIG_fail;
for (ii = 0; (ii < argc); ++ii) {
argv[ii] = args[ii];
}
if (argc == 3) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Binomial_find_upper_bound_on_p__SWIG_1(nargs, args, self);
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Binomial_find_upper_bound_on_p__SWIG_0(nargs, args, self);
}
}
}
}
}
fail:
Ruby_Format_OverloadedError( argc, 4, "Binomial.find_upper_bound_on_p",
" double Binomial.find_upper_bound_on_p(double trials, double successes, double probability, boost::math::binomial_distribution< double,policies::policy< > >::interval_type t)\n"
" double Binomial.find_upper_bound_on_p(double trials, double successes, double probability)\n");
return Qnil;
}
|
Instance Method Details
#cdf(*args, self) ⇒ Object
call-seq:
cdf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & x,
bool const & is_complement=False) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type
cdf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
8599 8600 8601 8602 8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646 8647 8648 8649 8650 8651 8652 8653 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8599
SWIGINTERN VALUE _wrap_Binomial_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__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_Binomial_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__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_Binomial_cdf__SWIG_0(nargs, args, self);
}
}
}
}
fail:
Ruby_Format_OverloadedError( argc, 4, "cdf",
" boost::math::binomial_distribution< double,policies::policy< > >::value_type cdf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const &x, bool const &is_complement)\n"
" boost::math::binomial_distribution< double,policies::policy< > >::value_type cdf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const &x)\n");
return Qnil;
}
|
#chf(*args) ⇒ Object
call-seq:
chf(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
8872 8873 8874 8875 8876 8877 8878 8879 8880 8881 8882 8883 8884 8885 8886 8887 8888 8889 8890 8891 8892 8893 8894 8895 8896 8897 8898 8899 8900 8901 8902 8903 8904 8905 8906 8907 8908 8909 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8872
SWIGINTERN VALUE
_wrap_Binomial_chf(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
boost::math::binomial_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::binomial_distribution< double,policies::policy< > >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","chf", 1, self ));
}
arg1 = reinterpret_cast< boost::math::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::binomial_distribution< double,policies::policy< > >::value_type","chf", 2, argv[0] ));
}
temp2 = static_cast< boost::math::binomial_distribution< double,policies::policy< > >::value_type >(val2);
arg2 = &temp2;
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__chf((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
8823 8824 8825 8826 8827 8828 8829 8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8823
SWIGINTERN VALUE
_wrap_Binomial_hazard(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
boost::math::binomial_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::binomial_distribution< double,policies::policy< > >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","hazard", 1, self ));
}
arg1 = reinterpret_cast< boost::math::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::binomial_distribution< double,policies::policy< > >::value_type","hazard", 2, argv[0] ));
}
temp2 = static_cast< boost::math::binomial_distribution< double,policies::policy< > >::value_type >(val2);
arg2 = &temp2;
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__hazard((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
9155 9156 9157 9158 9159 9160 9161 9162 9163 9164 9165 9166 9167 9168 9169 9170 9171 9172 9173 9174 9175 9176 9177 9178 9179 9180 9181 9182 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 9155
SWIGINTERN VALUE
_wrap_Binomial_kurtosis(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","kurtosis", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__kurtosis((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
9194 9195 9196 9197 9198 9199 9200 9201 9202 9203 9204 9205 9206 9207 9208 9209 9210 9211 9212 9213 9214 9215 9216 9217 9218 9219 9220 9221 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 9194
SWIGINTERN VALUE
_wrap_Binomial_kurtosis_excess(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","kurtosis_excess", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__kurtosis_excess((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
8921 8922 8923 8924 8925 8926 8927 8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947 8948 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8921
SWIGINTERN VALUE
_wrap_Binomial_mean(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","mean", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__mean((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
8960 8961 8962 8963 8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981 8982 8983 8984 8985 8986 8987 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8960
SWIGINTERN VALUE
_wrap_Binomial_median(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","median", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__median((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
8999 9000 9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021 9022 9023 9024 9025 9026 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8999
SWIGINTERN VALUE
_wrap_Binomial_mode(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","mode", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__mode((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8458
SWIGINTERN VALUE
_wrap_Binomial_pdf(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
boost::math::binomial_distribution< double,policies::policy< > >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::binomial_distribution< double,policies::policy< > >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","pdf", 1, self ));
}
arg1 = reinterpret_cast< boost::math::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::binomial_distribution< double,policies::policy< > >::value_type","pdf", 2, argv[0] ));
}
temp2 = static_cast< boost::math::binomial_distribution< double,policies::policy< > >::value_type >(val2);
arg2 = &temp2;
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__pdf((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type const & p,
bool const & is_complement=False) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type
quantile(boost::math::binomial_distribution< double,policies::policy< > >::value_type const & p) -> boost::math::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
8757 8758 8759 8760 8761 8762 8763 8764 8765 8766 8767 8768 8769 8770 8771 8772 8773 8774 8775 8776 8777 8778 8779 8780 8781 8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 8757
SWIGINTERN VALUE _wrap_Binomial_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__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_Binomial_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__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_Binomial_quantile__SWIG_0(nargs, args, self);
}
}
}
}
fail:
Ruby_Format_OverloadedError( argc, 4, "quantile",
" boost::math::binomial_distribution< double,policies::policy< > >::value_type quantile(boost::math::binomial_distribution< double,policies::policy< > >::value_type const &p, bool const &is_complement)\n"
" boost::math::binomial_distribution< double,policies::policy< > >::value_type quantile(boost::math::binomial_distribution< double,policies::policy< > >::value_type const &p)\n");
return Qnil;
}
|
#range(*args) ⇒ Object
call-seq:
range -> std::pair< boost::math::binomial_distribution< double,policies::policy< > >::value_type,boost::math::binomial_distribution< double,policies::policy< > >::value_type >
An instance method.
9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244 9245 9246 9247 9248 9249 9250 9251 9252 9253 9254 9255 9256 9257 9258 9259 9260 9261 9262 9263 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 9233
SWIGINTERN VALUE
_wrap_Binomial_range(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::pair< boost::math::binomial_distribution< double,policies::policy< > >::value_type,boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","range", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__range((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
9116 9117 9118 9119 9120 9121 9122 9123 9124 9125 9126 9127 9128 9129 9130 9131 9132 9133 9134 9135 9136 9137 9138 9139 9140 9141 9142 9143 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 9116
SWIGINTERN VALUE
_wrap_Binomial_skewness(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","skewness", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__skewness((boost::math::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::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
9038 9039 9040 9041 9042 9043 9044 9045 9046 9047 9048 9049 9050 9051 9052 9053 9054 9055 9056 9057 9058 9059 9060 9061 9062 9063 9064 9065 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 9038
SWIGINTERN VALUE
_wrap_Binomial_standard_deviation(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","standard_deviation", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__standard_deviation((boost::math::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.
7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 7916
SWIGINTERN VALUE
_wrap_Binomial_success_fraction(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","success_fraction", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
result = (double)((boost::math::binomial_distribution< double,policies::policy< > > const *)arg1)->success_fraction();
vresult = SWIG_From_double(static_cast< double >(result));
return vresult;
fail:
return Qnil;
}
|
#support(*args) ⇒ Object
call-seq:
support -> std::pair< boost::math::binomial_distribution< double,policies::policy< > >::value_type,boost::math::binomial_distribution< double,policies::policy< > >::value_type >
An instance method.
9275 9276 9277 9278 9279 9280 9281 9282 9283 9284 9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 9275
SWIGINTERN VALUE
_wrap_Binomial_support(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::pair< boost::math::binomial_distribution< double,policies::policy< > >::value_type,boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","support", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__support((boost::math::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;
}
|
#trials(*args) ⇒ Object
call-seq:
trials -> double
An instance method.
7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 7949
SWIGINTERN VALUE
_wrap_Binomial_trials(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","trials", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
result = (double)((boost::math::binomial_distribution< double,policies::policy< > > const *)arg1)->trials();
vresult = SWIG_From_double(static_cast< double >(result));
return vresult;
fail:
return Qnil;
}
|
#variance(*args) ⇒ Object
call-seq:
variance -> boost::math::binomial_distribution< double,policies::policy< > >::value_type
An instance method.
9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087 9088 9089 9090 9091 9092 9093 9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104 |
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 9077
SWIGINTERN VALUE
_wrap_Binomial_variance(int argc, VALUE *argv, VALUE self) {
boost::math::binomial_distribution< double,policies::policy< > > *arg1 = (boost::math::binomial_distribution< double,policies::policy< > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
boost::math::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__binomial_distributionT_double_policies__policyT_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::binomial_distribution< double,policies::policy< > > const *","variance", 1, self ));
}
arg1 = reinterpret_cast< boost::math::binomial_distribution< double,policies::policy< > > * >(argp1);
try {
result = (boost::math::binomial_distribution< double,policies::policy< > >::value_type)boost_math_binomial_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__variance((boost::math::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;
}
|