Class: BoostDistributions::Laplace

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

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



23426
23427
23428
23429
23430
23431
23432
23433
23434
23435
23436
23437
23438
23439
23440
23441
23442
23443
23444
23445
23446
23447
23448
23449
23450
23451
23452
23453
23454
23455
23456
23457
23458
23459
23460
23461
23462
23463
23464
23465
23466
23467
23468
23469
23470
23471
23472
23473
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 23426

SWIGINTERN VALUE _wrap_new_Laplace(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Laplace__SWIG_2(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_Laplace__SWIG_1(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_Laplace__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Laplace.new", 
    "    Laplace.new(double l_location, double l_scale)\n"
    "    Laplace.new(double l_location)\n"
    "    Laplace.new()\n");
  
  return Qnil;
}

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

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

An instance method.



23744
23745
23746
23747
23748
23749
23750
23751
23752
23753
23754
23755
23756
23757
23758
23759
23760
23761
23762
23763
23764
23765
23766
23767
23768
23769
23770
23771
23772
23773
23774
23775
23776
23777
23778
23779
23780
23781
23782
23783
23784
23785
23786
23787
23788
23789
23790
23791
23792
23793
23794
23795
23796
23797
23798
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 23744

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

#check_parameters(*args) ⇒ Object

call-seq:

check_parameters(char const * function, double * result) -> bool

An instance method.



23551
23552
23553
23554
23555
23556
23557
23558
23559
23560
23561
23562
23563
23564
23565
23566
23567
23568
23569
23570
23571
23572
23573
23574
23575
23576
23577
23578
23579
23580
23581
23582
23583
23584
23585
23586
23587
23588
23589
23590
23591
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 23551

SWIGINTERN VALUE
_wrap_Laplace_check_parameters(int argc, VALUE *argv, VALUE self) {
  boost::math::laplace_distribution< double,policies::policy< > > *arg1 = (boost::math::laplace_distribution< double,policies::policy< > > *) 0 ;
  char *arg2 = (char *) 0 ;
  double *arg3 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_boost__math__laplace_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::laplace_distribution< double,policies::policy< > > const *","check_parameters", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::laplace_distribution< double,policies::policy< > > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","check_parameters", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","check_parameters", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  result = (bool)((boost::math::laplace_distribution< double,policies::policy< > > const *)arg1)->check_parameters((char const *)arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



24017
24018
24019
24020
24021
24022
24023
24024
24025
24026
24027
24028
24029
24030
24031
24032
24033
24034
24035
24036
24037
24038
24039
24040
24041
24042
24043
24044
24045
24046
24047
24048
24049
24050
24051
24052
24053
24054
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24017

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

An instance method.



23968
23969
23970
23971
23972
23973
23974
23975
23976
23977
23978
23979
23980
23981
23982
23983
23984
23985
23986
23987
23988
23989
23990
23991
23992
23993
23994
23995
23996
23997
23998
23999
24000
24001
24002
24003
24004
24005
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 23968

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

An instance method.



24300
24301
24302
24303
24304
24305
24306
24307
24308
24309
24310
24311
24312
24313
24314
24315
24316
24317
24318
24319
24320
24321
24322
24323
24324
24325
24326
24327
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24300

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

An instance method.



24339
24340
24341
24342
24343
24344
24345
24346
24347
24348
24349
24350
24351
24352
24353
24354
24355
24356
24357
24358
24359
24360
24361
24362
24363
24364
24365
24366
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24339

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

#location(*args) ⇒ Object

call-seq:

location -> double

An instance method.



23485
23486
23487
23488
23489
23490
23491
23492
23493
23494
23495
23496
23497
23498
23499
23500
23501
23502
23503
23504
23505
23506
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 23485

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

#mean(*args) ⇒ Object

call-seq:

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

An instance method.



24066
24067
24068
24069
24070
24071
24072
24073
24074
24075
24076
24077
24078
24079
24080
24081
24082
24083
24084
24085
24086
24087
24088
24089
24090
24091
24092
24093
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24066

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

An instance method.



24105
24106
24107
24108
24109
24110
24111
24112
24113
24114
24115
24116
24117
24118
24119
24120
24121
24122
24123
24124
24125
24126
24127
24128
24129
24130
24131
24132
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24105

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

An instance method.



24144
24145
24146
24147
24148
24149
24150
24151
24152
24153
24154
24155
24156
24157
24158
24159
24160
24161
24162
24163
24164
24165
24166
24167
24168
24169
24170
24171
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24144

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

An instance method.



23603
23604
23605
23606
23607
23608
23609
23610
23611
23612
23613
23614
23615
23616
23617
23618
23619
23620
23621
23622
23623
23624
23625
23626
23627
23628
23629
23630
23631
23632
23633
23634
23635
23636
23637
23638
23639
23640
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 23603

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

An instance method.



23902
23903
23904
23905
23906
23907
23908
23909
23910
23911
23912
23913
23914
23915
23916
23917
23918
23919
23920
23921
23922
23923
23924
23925
23926
23927
23928
23929
23930
23931
23932
23933
23934
23935
23936
23937
23938
23939
23940
23941
23942
23943
23944
23945
23946
23947
23948
23949
23950
23951
23952
23953
23954
23955
23956
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 23902

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

#range(*args) ⇒ Object

call-seq:

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

An instance method.



24378
24379
24380
24381
24382
24383
24384
24385
24386
24387
24388
24389
24390
24391
24392
24393
24394
24395
24396
24397
24398
24399
24400
24401
24402
24403
24404
24405
24406
24407
24408
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24378

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

#scale(*args) ⇒ Object

call-seq:

scale -> double

An instance method.



23518
23519
23520
23521
23522
23523
23524
23525
23526
23527
23528
23529
23530
23531
23532
23533
23534
23535
23536
23537
23538
23539
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 23518

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

#skewness(*args) ⇒ Object

call-seq:

skewness -> boost::math::laplace_distribution< double,policies::policy< > >::value_type

An instance method.



24261
24262
24263
24264
24265
24266
24267
24268
24269
24270
24271
24272
24273
24274
24275
24276
24277
24278
24279
24280
24281
24282
24283
24284
24285
24286
24287
24288
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24261

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

An instance method.



24183
24184
24185
24186
24187
24188
24189
24190
24191
24192
24193
24194
24195
24196
24197
24198
24199
24200
24201
24202
24203
24204
24205
24206
24207
24208
24209
24210
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24183

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

An instance method.



24420
24421
24422
24423
24424
24425
24426
24427
24428
24429
24430
24431
24432
24433
24434
24435
24436
24437
24438
24439
24440
24441
24442
24443
24444
24445
24446
24447
24448
24449
24450
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24420

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

An instance method.



24222
24223
24224
24225
24226
24227
24228
24229
24230
24231
24232
24233
24234
24235
24236
24237
24238
24239
24240
24241
24242
24243
24244
24245
24246
24247
24248
24249
 
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 24222

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