Class: BoostDistributions::Poisson

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

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



34189
34190
34191
34192
34193
34194
34195
34196
34197
34198
34199
34200
34201
34202
34203
34204
34205
34206
34207
34208
34209
34210
34211
34212
34213
34214
34215
34216
34217
34218
34219
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34189

SWIGINTERN VALUE _wrap_new_Poisson(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Poisson__SWIG_1(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_Poisson__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Poisson.new", 
    "    Poisson.new(double l_mean)\n"
    "    Poisson.new()\n");
  
  return Qnil;
}

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

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

An instance method.



34405
34406
34407
34408
34409
34410
34411
34412
34413
34414
34415
34416
34417
34418
34419
34420
34421
34422
34423
34424
34425
34426
34427
34428
34429
34430
34431
34432
34433
34434
34435
34436
34437
34438
34439
34440
34441
34442
34443
34444
34445
34446
34447
34448
34449
34450
34451
34452
34453
34454
34455
34456
34457
34458
34459
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34405

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

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



34678
34679
34680
34681
34682
34683
34684
34685
34686
34687
34688
34689
34690
34691
34692
34693
34694
34695
34696
34697
34698
34699
34700
34701
34702
34703
34704
34705
34706
34707
34708
34709
34710
34711
34712
34713
34714
34715
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34678

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

An instance method.



34629
34630
34631
34632
34633
34634
34635
34636
34637
34638
34639
34640
34641
34642
34643
34644
34645
34646
34647
34648
34649
34650
34651
34652
34653
34654
34655
34656
34657
34658
34659
34660
34661
34662
34663
34664
34665
34666
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34629

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

An instance method.



34922
34923
34924
34925
34926
34927
34928
34929
34930
34931
34932
34933
34934
34935
34936
34937
34938
34939
34940
34941
34942
34943
34944
34945
34946
34947
34948
34949
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34922

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

An instance method.



34961
34962
34963
34964
34965
34966
34967
34968
34969
34970
34971
34972
34973
34974
34975
34976
34977
34978
34979
34980
34981
34982
34983
34984
34985
34986
34987
34988
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34961

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

An instance method.



34231
34232
34233
34234
34235
34236
34237
34238
34239
34240
34241
34242
34243
34244
34245
34246
34247
34248
34249
34250
34251
34252
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34231

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

#median(*args) ⇒ Object

call-seq:

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

An instance method.



34727
34728
34729
34730
34731
34732
34733
34734
34735
34736
34737
34738
34739
34740
34741
34742
34743
34744
34745
34746
34747
34748
34749
34750
34751
34752
34753
34754
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34727

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

An instance method.



34766
34767
34768
34769
34770
34771
34772
34773
34774
34775
34776
34777
34778
34779
34780
34781
34782
34783
34784
34785
34786
34787
34788
34789
34790
34791
34792
34793
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34766

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

An instance method.



34264
34265
34266
34267
34268
34269
34270
34271
34272
34273
34274
34275
34276
34277
34278
34279
34280
34281
34282
34283
34284
34285
34286
34287
34288
34289
34290
34291
34292
34293
34294
34295
34296
34297
34298
34299
34300
34301
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34264

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

An instance method.



34563
34564
34565
34566
34567
34568
34569
34570
34571
34572
34573
34574
34575
34576
34577
34578
34579
34580
34581
34582
34583
34584
34585
34586
34587
34588
34589
34590
34591
34592
34593
34594
34595
34596
34597
34598
34599
34600
34601
34602
34603
34604
34605
34606
34607
34608
34609
34610
34611
34612
34613
34614
34615
34616
34617
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34563

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

#range(*args) ⇒ Object

call-seq:

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

An instance method.



35000
35001
35002
35003
35004
35005
35006
35007
35008
35009
35010
35011
35012
35013
35014
35015
35016
35017
35018
35019
35020
35021
35022
35023
35024
35025
35026
35027
35028
35029
35030
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 35000

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

An instance method.



34883
34884
34885
34886
34887
34888
34889
34890
34891
34892
34893
34894
34895
34896
34897
34898
34899
34900
34901
34902
34903
34904
34905
34906
34907
34908
34909
34910
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34883

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

An instance method.



34805
34806
34807
34808
34809
34810
34811
34812
34813
34814
34815
34816
34817
34818
34819
34820
34821
34822
34823
34824
34825
34826
34827
34828
34829
34830
34831
34832
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34805

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

An instance method.



35042
35043
35044
35045
35046
35047
35048
35049
35050
35051
35052
35053
35054
35055
35056
35057
35058
35059
35060
35061
35062
35063
35064
35065
35066
35067
35068
35069
35070
35071
35072
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 35042

SWIGINTERN VALUE
_wrap_Poisson_support(int argc, VALUE *argv, VALUE self) {
  boost::math::poisson_distribution< double,policies::policy< > > *arg1 = (boost::math::poisson_distribution< double,policies::policy< > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< boost::math::poisson_distribution< double,policies::policy< > >::value_type,boost::math::poisson_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__poisson_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::poisson_distribution< double,policies::policy< > > const *","support", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::poisson_distribution< double,policies::policy< > > * >(argp1);
  try {
    result = boost_math_poisson_distribution_Sl_double_Sc_policies_policy_Sl__Sg__Sg__support((boost::math::poisson_distribution< double,policies::policy< > > const *)arg1);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  } catch(std::runtime_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  {
    vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->first));
    vresult = SWIG_Ruby_AppendOutput(vresult, swig::from((&result)->second));
  }
  return vresult;
fail:
  return Qnil;
}

#variance(*args) ⇒ Object

call-seq:

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

An instance method.



34844
34845
34846
34847
34848
34849
34850
34851
34852
34853
34854
34855
34856
34857
34858
34859
34860
34861
34862
34863
34864
34865
34866
34867
34868
34869
34870
34871
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 34844

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