Class: BoostDistributions::Geometric

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

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

Geometric.new(double p)

Class constructor.



15556
15557
15558
15559
15560
15561
15562
15563
15564
15565
15566
15567
15568
15569
15570
15571
15572
15573
15574
15575
15576
15577
15578
15579
15580
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15556

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

Class Method Details

.find_lower_bound_on_p(*args) ⇒ Object

call-seq:

find_lower_bound_on_p(double trials, double alpha) -> double

A class method.



15658
15659
15660
15661
15662
15663
15664
15665
15666
15667
15668
15669
15670
15671
15672
15673
15674
15675
15676
15677
15678
15679
15680
15681
15682
15683
15684
15685
15686
15687
15688
15689
15690
15691
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15658

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

.find_maximum_number_of_trials(*args) ⇒ Object

call-seq:

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

A class method.



15801
15802
15803
15804
15805
15806
15807
15808
15809
15810
15811
15812
15813
15814
15815
15816
15817
15818
15819
15820
15821
15822
15823
15824
15825
15826
15827
15828
15829
15830
15831
15832
15833
15834
15835
15836
15837
15838
15839
15840
15841
15842
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15801

SWIGINTERN VALUE
_wrap_Geometric_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::geometric_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::geometric_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::geometric_distribution<(double,policies::policy<()>)>::find_maximum_number_of_trials", 3, argv[2] ));
  } 
  arg3 = static_cast< double >(val3);
  try {
    result = (double)boost::math::geometric_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.



15748
15749
15750
15751
15752
15753
15754
15755
15756
15757
15758
15759
15760
15761
15762
15763
15764
15765
15766
15767
15768
15769
15770
15771
15772
15773
15774
15775
15776
15777
15778
15779
15780
15781
15782
15783
15784
15785
15786
15787
15788
15789
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15748

SWIGINTERN VALUE
_wrap_Geometric_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::geometric_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::geometric_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::geometric_distribution<(double,policies::policy<()>)>::find_minimum_number_of_trials", 3, argv[2] ));
  } 
  arg3 = static_cast< double >(val3);
  try {
    result = (double)boost::math::geometric_distribution< double,policies::policy< > >::SWIGTEMPLATEDISAMBIGUATOR find_minimum_number_of_trials(arg1,arg2,arg3);
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

.find_upper_bound_on_p(*args) ⇒ Object

call-seq:

find_upper_bound_on_p(double trials, double alpha) -> double

A class method.



15703
15704
15705
15706
15707
15708
15709
15710
15711
15712
15713
15714
15715
15716
15717
15718
15719
15720
15721
15722
15723
15724
15725
15726
15727
15728
15729
15730
15731
15732
15733
15734
15735
15736
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15703

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

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

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

An instance method.



15995
15996
15997
15998
15999
16000
16001
16002
16003
16004
16005
16006
16007
16008
16009
16010
16011
16012
16013
16014
16015
16016
16017
16018
16019
16020
16021
16022
16023
16024
16025
16026
16027
16028
16029
16030
16031
16032
16033
16034
16035
16036
16037
16038
16039
16040
16041
16042
16043
16044
16045
16046
16047
16048
16049
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15995

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

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



16268
16269
16270
16271
16272
16273
16274
16275
16276
16277
16278
16279
16280
16281
16282
16283
16284
16285
16286
16287
16288
16289
16290
16291
16292
16293
16294
16295
16296
16297
16298
16299
16300
16301
16302
16303
16304
16305
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16268

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

An instance method.



16219
16220
16221
16222
16223
16224
16225
16226
16227
16228
16229
16230
16231
16232
16233
16234
16235
16236
16237
16238
16239
16240
16241
16242
16243
16244
16245
16246
16247
16248
16249
16250
16251
16252
16253
16254
16255
16256
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16219

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

An instance method.



16551
16552
16553
16554
16555
16556
16557
16558
16559
16560
16561
16562
16563
16564
16565
16566
16567
16568
16569
16570
16571
16572
16573
16574
16575
16576
16577
16578
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16551

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

An instance method.



16590
16591
16592
16593
16594
16595
16596
16597
16598
16599
16600
16601
16602
16603
16604
16605
16606
16607
16608
16609
16610
16611
16612
16613
16614
16615
16616
16617
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16590

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

An instance method.



16317
16318
16319
16320
16321
16322
16323
16324
16325
16326
16327
16328
16329
16330
16331
16332
16333
16334
16335
16336
16337
16338
16339
16340
16341
16342
16343
16344
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16317

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

An instance method.



16356
16357
16358
16359
16360
16361
16362
16363
16364
16365
16366
16367
16368
16369
16370
16371
16372
16373
16374
16375
16376
16377
16378
16379
16380
16381
16382
16383
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16356

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

An instance method.



16395
16396
16397
16398
16399
16400
16401
16402
16403
16404
16405
16406
16407
16408
16409
16410
16411
16412
16413
16414
16415
16416
16417
16418
16419
16420
16421
16422
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16395

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

An instance method.



15854
15855
15856
15857
15858
15859
15860
15861
15862
15863
15864
15865
15866
15867
15868
15869
15870
15871
15872
15873
15874
15875
15876
15877
15878
15879
15880
15881
15882
15883
15884
15885
15886
15887
15888
15889
15890
15891
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15854

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

An instance method.



16153
16154
16155
16156
16157
16158
16159
16160
16161
16162
16163
16164
16165
16166
16167
16168
16169
16170
16171
16172
16173
16174
16175
16176
16177
16178
16179
16180
16181
16182
16183
16184
16185
16186
16187
16188
16189
16190
16191
16192
16193
16194
16195
16196
16197
16198
16199
16200
16201
16202
16203
16204
16205
16206
16207
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16153

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

#range(*args) ⇒ Object

call-seq:

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

An instance method.



16629
16630
16631
16632
16633
16634
16635
16636
16637
16638
16639
16640
16641
16642
16643
16644
16645
16646
16647
16648
16649
16650
16651
16652
16653
16654
16655
16656
16657
16658
16659
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16629

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

An instance method.



16512
16513
16514
16515
16516
16517
16518
16519
16520
16521
16522
16523
16524
16525
16526
16527
16528
16529
16530
16531
16532
16533
16534
16535
16536
16537
16538
16539
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16512

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

An instance method.



16434
16435
16436
16437
16438
16439
16440
16441
16442
16443
16444
16445
16446
16447
16448
16449
16450
16451
16452
16453
16454
16455
16456
16457
16458
16459
16460
16461
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16434

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



15592
15593
15594
15595
15596
15597
15598
15599
15600
15601
15602
15603
15604
15605
15606
15607
15608
15609
15610
15611
15612
15613
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15592

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

#successes(*args) ⇒ Object

call-seq:

successes -> double

An instance method.



15625
15626
15627
15628
15629
15630
15631
15632
15633
15634
15635
15636
15637
15638
15639
15640
15641
15642
15643
15644
15645
15646
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 15625

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

#support(*args) ⇒ Object

call-seq:

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

An instance method.



16671
16672
16673
16674
16675
16676
16677
16678
16679
16680
16681
16682
16683
16684
16685
16686
16687
16688
16689
16690
16691
16692
16693
16694
16695
16696
16697
16698
16699
16700
16701
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16671

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

An instance method.



16473
16474
16475
16476
16477
16478
16479
16480
16481
16482
16483
16484
16485
16486
16487
16488
16489
16490
16491
16492
16493
16494
16495
16496
16497
16498
16499
16500
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 16473

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