Class: BoostDistributions::NonCentralChiSquared

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

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

NonCentralChiSquared.new(double df_, double lambda)

Class constructor.



28820
28821
28822
28823
28824
28825
28826
28827
28828
28829
28830
28831
28832
28833
28834
28835
28836
28837
28838
28839
28840
28841
28842
28843
28844
28845
28846
28847
28848
28849
28850
28851
28852
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 28820

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

Class Method Details

.find_degrees_of_freedom(*args) ⇒ Object

call-seq:

find_degrees_of_freedom(double lam, double x, double p) -> double

A class method.



28930
28931
28932
28933
28934
28935
28936
28937
28938
28939
28940
28941
28942
28943
28944
28945
28946
28947
28948
28949
28950
28951
28952
28953
28954
28955
28956
28957
28958
28959
28960
28961
28962
28963
28964
28965
28966
28967
28968
28969
28970
28971
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 28930

SWIGINTERN VALUE
_wrap_NonCentralChiSquared_find_degrees_of_freedom(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::non_central_chi_squared_distribution<(double,policies::policy<()>)>::find_degrees_of_freedom", 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::non_central_chi_squared_distribution<(double,policies::policy<()>)>::find_degrees_of_freedom", 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::non_central_chi_squared_distribution<(double,policies::policy<()>)>::find_degrees_of_freedom", 3, argv[2] ));
  } 
  arg3 = static_cast< double >(val3);
  try {
    result = (double)boost::math::non_central_chi_squared_distribution< double,policies::policy< > >::SWIGTEMPLATEDISAMBIGUATOR find_degrees_of_freedom(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_non_centrality(*args) ⇒ Object

call-seq:

find_non_centrality(double v, double x, double p) -> double

A class method.



28983
28984
28985
28986
28987
28988
28989
28990
28991
28992
28993
28994
28995
28996
28997
28998
28999
29000
29001
29002
29003
29004
29005
29006
29007
29008
29009
29010
29011
29012
29013
29014
29015
29016
29017
29018
29019
29020
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 28983

SWIGINTERN VALUE
_wrap_NonCentralChiSquared_find_non_centrality(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::non_central_chi_squared_distribution<(double,policies::policy<()>)>::find_non_centrality", 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::non_central_chi_squared_distribution<(double,policies::policy<()>)>::find_non_centrality", 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::non_central_chi_squared_distribution<(double,policies::policy<()>)>::find_non_centrality", 3, argv[2] ));
  } 
  arg3 = static_cast< double >(val3);
  result = (double)boost::math::non_central_chi_squared_distribution< double,policies::policy< > >::SWIGTEMPLATEDISAMBIGUATOR find_non_centrality(arg1,arg2,arg3);
  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::non_central_chi_squared_distribution< double,policies::policy< > >::value_type const & x,
bool const & is_complement=False) -> boost::math::non_central_chi_squared_distribution< double,policies::policy< > >::value_type
cdf(boost::math::non_central_chi_squared_distribution< double,policies::policy< > >::value_type const & x) -> boost::math::non_central_chi_squared_distribution< double,policies::policy< > >::value_type

An instance method.



29173
29174
29175
29176
29177
29178
29179
29180
29181
29182
29183
29184
29185
29186
29187
29188
29189
29190
29191
29192
29193
29194
29195
29196
29197
29198
29199
29200
29201
29202
29203
29204
29205
29206
29207
29208
29209
29210
29211
29212
29213
29214
29215
29216
29217
29218
29219
29220
29221
29222
29223
29224
29225
29226
29227
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29173

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

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



29446
29447
29448
29449
29450
29451
29452
29453
29454
29455
29456
29457
29458
29459
29460
29461
29462
29463
29464
29465
29466
29467
29468
29469
29470
29471
29472
29473
29474
29475
29476
29477
29478
29479
29480
29481
29482
29483
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29446

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

#degrees_of_freedom(*args) ⇒ Object

call-seq:

degrees_of_freedom -> double

An instance method.



28864
28865
28866
28867
28868
28869
28870
28871
28872
28873
28874
28875
28876
28877
28878
28879
28880
28881
28882
28883
28884
28885
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 28864

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

#hazard(*args) ⇒ Object

call-seq:

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

An instance method.



29397
29398
29399
29400
29401
29402
29403
29404
29405
29406
29407
29408
29409
29410
29411
29412
29413
29414
29415
29416
29417
29418
29419
29420
29421
29422
29423
29424
29425
29426
29427
29428
29429
29430
29431
29432
29433
29434
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29397

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

An instance method.



29729
29730
29731
29732
29733
29734
29735
29736
29737
29738
29739
29740
29741
29742
29743
29744
29745
29746
29747
29748
29749
29750
29751
29752
29753
29754
29755
29756
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29729

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

An instance method.



29768
29769
29770
29771
29772
29773
29774
29775
29776
29777
29778
29779
29780
29781
29782
29783
29784
29785
29786
29787
29788
29789
29790
29791
29792
29793
29794
29795
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29768

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

An instance method.



29495
29496
29497
29498
29499
29500
29501
29502
29503
29504
29505
29506
29507
29508
29509
29510
29511
29512
29513
29514
29515
29516
29517
29518
29519
29520
29521
29522
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29495

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

An instance method.



29534
29535
29536
29537
29538
29539
29540
29541
29542
29543
29544
29545
29546
29547
29548
29549
29550
29551
29552
29553
29554
29555
29556
29557
29558
29559
29560
29561
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29534

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

An instance method.



29573
29574
29575
29576
29577
29578
29579
29580
29581
29582
29583
29584
29585
29586
29587
29588
29589
29590
29591
29592
29593
29594
29595
29596
29597
29598
29599
29600
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29573

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

#non_centrality(*args) ⇒ Object

call-seq:

non_centrality -> double

An instance method.



28897
28898
28899
28900
28901
28902
28903
28904
28905
28906
28907
28908
28909
28910
28911
28912
28913
28914
28915
28916
28917
28918
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 28897

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

#pdf(*args) ⇒ Object

call-seq:

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

An instance method.



29032
29033
29034
29035
29036
29037
29038
29039
29040
29041
29042
29043
29044
29045
29046
29047
29048
29049
29050
29051
29052
29053
29054
29055
29056
29057
29058
29059
29060
29061
29062
29063
29064
29065
29066
29067
29068
29069
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29032

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

An instance method.



29331
29332
29333
29334
29335
29336
29337
29338
29339
29340
29341
29342
29343
29344
29345
29346
29347
29348
29349
29350
29351
29352
29353
29354
29355
29356
29357
29358
29359
29360
29361
29362
29363
29364
29365
29366
29367
29368
29369
29370
29371
29372
29373
29374
29375
29376
29377
29378
29379
29380
29381
29382
29383
29384
29385
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29331

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

#range(*args) ⇒ Object

call-seq:

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

An instance method.



29807
29808
29809
29810
29811
29812
29813
29814
29815
29816
29817
29818
29819
29820
29821
29822
29823
29824
29825
29826
29827
29828
29829
29830
29831
29832
29833
29834
29835
29836
29837
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29807

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

An instance method.



29690
29691
29692
29693
29694
29695
29696
29697
29698
29699
29700
29701
29702
29703
29704
29705
29706
29707
29708
29709
29710
29711
29712
29713
29714
29715
29716
29717
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29690

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

An instance method.



29612
29613
29614
29615
29616
29617
29618
29619
29620
29621
29622
29623
29624
29625
29626
29627
29628
29629
29630
29631
29632
29633
29634
29635
29636
29637
29638
29639
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29612

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

An instance method.



29849
29850
29851
29852
29853
29854
29855
29856
29857
29858
29859
29860
29861
29862
29863
29864
29865
29866
29867
29868
29869
29870
29871
29872
29873
29874
29875
29876
29877
29878
29879
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29849

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

An instance method.



29651
29652
29653
29654
29655
29656
29657
29658
29659
29660
29661
29662
29663
29664
29665
29666
29667
29668
29669
29670
29671
29672
29673
29674
29675
29676
29677
29678
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 29651

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