Class: BoostDistributions::FisherF

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

FisherF.new(double const & i, double const & j)

Class constructor.



13480
13481
13482
13483
13484
13485
13486
13487
13488
13489
13490
13491
13492
13493
13494
13495
13496
13497
13498
13499
13500
13501
13502
13503
13504
13505
13506
13507
13508
13509
13510
13511
13512
13513
13514
13515
13516
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 13480

SWIGINTERN VALUE
_wrap_new_FisherF(int argc, VALUE *argv, VALUE self) {
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double temp1 ;
  double val1 ;
  int ecode1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  boost::math::fisher_f_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","fisher_f_distribution<(double,policies::policy<()>)>", 1, argv[0] ));
  } 
  temp1 = static_cast< double >(val1);
  arg1 = &temp1;
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fisher_f_distribution<(double,policies::policy<()>)>", 2, argv[1] ));
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  try {
    result = (boost::math::fisher_f_distribution< double,policies::policy< > > *)new boost::math::fisher_f_distribution< double,policies::policy< > >((double const &)*arg1,(double const &)*arg2);
    DATA_PTR(self) = result;
  } catch(std::logic_error &_e) {
    SWIG_exception_fail(SWIG_RuntimeError, (&_e)->what());
  }
  return self;
fail:
  return Qnil;
}

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

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

An instance method.



13735
13736
13737
13738
13739
13740
13741
13742
13743
13744
13745
13746
13747
13748
13749
13750
13751
13752
13753
13754
13755
13756
13757
13758
13759
13760
13761
13762
13763
13764
13765
13766
13767
13768
13769
13770
13771
13772
13773
13774
13775
13776
13777
13778
13779
13780
13781
13782
13783
13784
13785
13786
13787
13788
13789
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 13735

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

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



14008
14009
14010
14011
14012
14013
14014
14015
14016
14017
14018
14019
14020
14021
14022
14023
14024
14025
14026
14027
14028
14029
14030
14031
14032
14033
14034
14035
14036
14037
14038
14039
14040
14041
14042
14043
14044
14045
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14008

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

call-seq:

degrees_of_freedom1 -> double

An instance method.



13528
13529
13530
13531
13532
13533
13534
13535
13536
13537
13538
13539
13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 13528

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

#degrees_of_freedom2(*args) ⇒ Object

call-seq:

degrees_of_freedom2 -> double

An instance method.



13561
13562
13563
13564
13565
13566
13567
13568
13569
13570
13571
13572
13573
13574
13575
13576
13577
13578
13579
13580
13581
13582
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 13561

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

#hazard(*args) ⇒ Object

call-seq:

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

An instance method.



13959
13960
13961
13962
13963
13964
13965
13966
13967
13968
13969
13970
13971
13972
13973
13974
13975
13976
13977
13978
13979
13980
13981
13982
13983
13984
13985
13986
13987
13988
13989
13990
13991
13992
13993
13994
13995
13996
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 13959

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

An instance method.



14291
14292
14293
14294
14295
14296
14297
14298
14299
14300
14301
14302
14303
14304
14305
14306
14307
14308
14309
14310
14311
14312
14313
14314
14315
14316
14317
14318
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14291

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

An instance method.



14330
14331
14332
14333
14334
14335
14336
14337
14338
14339
14340
14341
14342
14343
14344
14345
14346
14347
14348
14349
14350
14351
14352
14353
14354
14355
14356
14357
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14330

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

An instance method.



14057
14058
14059
14060
14061
14062
14063
14064
14065
14066
14067
14068
14069
14070
14071
14072
14073
14074
14075
14076
14077
14078
14079
14080
14081
14082
14083
14084
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14057

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

An instance method.



14096
14097
14098
14099
14100
14101
14102
14103
14104
14105
14106
14107
14108
14109
14110
14111
14112
14113
14114
14115
14116
14117
14118
14119
14120
14121
14122
14123
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14096

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

An instance method.



14135
14136
14137
14138
14139
14140
14141
14142
14143
14144
14145
14146
14147
14148
14149
14150
14151
14152
14153
14154
14155
14156
14157
14158
14159
14160
14161
14162
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14135

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

An instance method.



13594
13595
13596
13597
13598
13599
13600
13601
13602
13603
13604
13605
13606
13607
13608
13609
13610
13611
13612
13613
13614
13615
13616
13617
13618
13619
13620
13621
13622
13623
13624
13625
13626
13627
13628
13629
13630
13631
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 13594

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

An instance method.



13893
13894
13895
13896
13897
13898
13899
13900
13901
13902
13903
13904
13905
13906
13907
13908
13909
13910
13911
13912
13913
13914
13915
13916
13917
13918
13919
13920
13921
13922
13923
13924
13925
13926
13927
13928
13929
13930
13931
13932
13933
13934
13935
13936
13937
13938
13939
13940
13941
13942
13943
13944
13945
13946
13947
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 13893

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

#range(*args) ⇒ Object

call-seq:

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

An instance method.



14369
14370
14371
14372
14373
14374
14375
14376
14377
14378
14379
14380
14381
14382
14383
14384
14385
14386
14387
14388
14389
14390
14391
14392
14393
14394
14395
14396
14397
14398
14399
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14369

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

An instance method.



14252
14253
14254
14255
14256
14257
14258
14259
14260
14261
14262
14263
14264
14265
14266
14267
14268
14269
14270
14271
14272
14273
14274
14275
14276
14277
14278
14279
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14252

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

An instance method.



14174
14175
14176
14177
14178
14179
14180
14181
14182
14183
14184
14185
14186
14187
14188
14189
14190
14191
14192
14193
14194
14195
14196
14197
14198
14199
14200
14201
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14174

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

An instance method.



14411
14412
14413
14414
14415
14416
14417
14418
14419
14420
14421
14422
14423
14424
14425
14426
14427
14428
14429
14430
14431
14432
14433
14434
14435
14436
14437
14438
14439
14440
14441
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14411

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

An instance method.



14213
14214
14215
14216
14217
14218
14219
14220
14221
14222
14223
14224
14225
14226
14227
14228
14229
14230
14231
14232
14233
14234
14235
14236
14237
14238
14239
14240
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 14213

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