Class: BoostDistributions::Triangular

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

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



38611
38612
38613
38614
38615
38616
38617
38618
38619
38620
38621
38622
38623
38624
38625
38626
38627
38628
38629
38630
38631
38632
38633
38634
38635
38636
38637
38638
38639
38640
38641
38642
38643
38644
38645
38646
38647
38648
38649
38650
38651
38652
38653
38654
38655
38656
38657
38658
38659
38660
38661
38662
38663
38664
38665
38666
38667
38668
38669
38670
38671
38672
38673
38674
38675
38676
38677
38678
38679
38680
38681
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 38611

SWIGINTERN VALUE _wrap_new_Triangular(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Triangular__SWIG_3(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Triangular__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Triangular__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Triangular__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Triangular.new", 
    "    Triangular.new(double l_lower, double l_mode, double l_upper)\n"
    "    Triangular.new(double l_lower, double l_mode)\n"
    "    Triangular.new(double l_lower)\n"
    "    Triangular.new()\n");
  
  return Qnil;
}

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

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

An instance method.



38933
38934
38935
38936
38937
38938
38939
38940
38941
38942
38943
38944
38945
38946
38947
38948
38949
38950
38951
38952
38953
38954
38955
38956
38957
38958
38959
38960
38961
38962
38963
38964
38965
38966
38967
38968
38969
38970
38971
38972
38973
38974
38975
38976
38977
38978
38979
38980
38981
38982
38983
38984
38985
38986
38987
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 38933

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

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



39206
39207
39208
39209
39210
39211
39212
39213
39214
39215
39216
39217
39218
39219
39220
39221
39222
39223
39224
39225
39226
39227
39228
39229
39230
39231
39232
39233
39234
39235
39236
39237
39238
39239
39240
39241
39242
39243
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39206

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

An instance method.



39157
39158
39159
39160
39161
39162
39163
39164
39165
39166
39167
39168
39169
39170
39171
39172
39173
39174
39175
39176
39177
39178
39179
39180
39181
39182
39183
39184
39185
39186
39187
39188
39189
39190
39191
39192
39193
39194
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39157

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

An instance method.



39450
39451
39452
39453
39454
39455
39456
39457
39458
39459
39460
39461
39462
39463
39464
39465
39466
39467
39468
39469
39470
39471
39472
39473
39474
39475
39476
39477
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39450

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

An instance method.



39489
39490
39491
39492
39493
39494
39495
39496
39497
39498
39499
39500
39501
39502
39503
39504
39505
39506
39507
39508
39509
39510
39511
39512
39513
39514
39515
39516
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39489

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

#lower(*args) ⇒ Object

call-seq:

lower -> double

An instance method.



38693
38694
38695
38696
38697
38698
38699
38700
38701
38702
38703
38704
38705
38706
38707
38708
38709
38710
38711
38712
38713
38714
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 38693

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

#mean(*args) ⇒ Object

call-seq:

mean -> boost::math::triangular_distribution< double,policies::policy< > >::value_type

An instance method.



39255
39256
39257
39258
39259
39260
39261
39262
39263
39264
39265
39266
39267
39268
39269
39270
39271
39272
39273
39274
39275
39276
39277
39278
39279
39280
39281
39282
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39255

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

An instance method.



39294
39295
39296
39297
39298
39299
39300
39301
39302
39303
39304
39305
39306
39307
39308
39309
39310
39311
39312
39313
39314
39315
39316
39317
39318
39319
39320
39321
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39294

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

An instance method.



38726
38727
38728
38729
38730
38731
38732
38733
38734
38735
38736
38737
38738
38739
38740
38741
38742
38743
38744
38745
38746
38747
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 38726

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

#pdf(*args) ⇒ Object

call-seq:

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

An instance method.



38792
38793
38794
38795
38796
38797
38798
38799
38800
38801
38802
38803
38804
38805
38806
38807
38808
38809
38810
38811
38812
38813
38814
38815
38816
38817
38818
38819
38820
38821
38822
38823
38824
38825
38826
38827
38828
38829
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 38792

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

An instance method.



39091
39092
39093
39094
39095
39096
39097
39098
39099
39100
39101
39102
39103
39104
39105
39106
39107
39108
39109
39110
39111
39112
39113
39114
39115
39116
39117
39118
39119
39120
39121
39122
39123
39124
39125
39126
39127
39128
39129
39130
39131
39132
39133
39134
39135
39136
39137
39138
39139
39140
39141
39142
39143
39144
39145
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39091

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

#range(*args) ⇒ Object

call-seq:

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

An instance method.



39528
39529
39530
39531
39532
39533
39534
39535
39536
39537
39538
39539
39540
39541
39542
39543
39544
39545
39546
39547
39548
39549
39550
39551
39552
39553
39554
39555
39556
39557
39558
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39528

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

An instance method.



39411
39412
39413
39414
39415
39416
39417
39418
39419
39420
39421
39422
39423
39424
39425
39426
39427
39428
39429
39430
39431
39432
39433
39434
39435
39436
39437
39438
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39411

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

An instance method.



39333
39334
39335
39336
39337
39338
39339
39340
39341
39342
39343
39344
39345
39346
39347
39348
39349
39350
39351
39352
39353
39354
39355
39356
39357
39358
39359
39360
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39333

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

An instance method.



39570
39571
39572
39573
39574
39575
39576
39577
39578
39579
39580
39581
39582
39583
39584
39585
39586
39587
39588
39589
39590
39591
39592
39593
39594
39595
39596
39597
39598
39599
39600
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39570

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

#upper(*args) ⇒ Object

call-seq:

upper -> double

An instance method.



38759
38760
38761
38762
38763
38764
38765
38766
38767
38768
38769
38770
38771
38772
38773
38774
38775
38776
38777
38778
38779
38780
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 38759

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

#variance(*args) ⇒ Object

call-seq:

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

An instance method.



39372
39373
39374
39375
39376
39377
39378
39379
39380
39381
39382
39383
39384
39385
39386
39387
39388
39389
39390
39391
39392
39393
39394
39395
39396
39397
39398
39399
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 39372

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