Class: BoostDistributions::Normal

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

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object



32043
32044
32045
32046
32047
32048
32049
32050
32051
32052
32053
32054
32055
32056
32057
32058
32059
32060
32061
32062
32063
32064
32065
32066
32067
32068
32069
32070
32071
32072
32073
32074
32075
32076
32077
32078
32079
32080
32081
32082
32083
32084
32085
32086
32087
32088
32089
32090
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32043

SWIGINTERN VALUE _wrap_new_Normal(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_Normal__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_Normal__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_Normal__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Normal.new", 
    "    Normal.new(double l_mean, double sd)\n"
    "    Normal.new(double l_mean)\n"
    "    Normal.new()\n");
  
  return Qnil;
}

Instance Method Details

#cdf(*args, self) ⇒ Object

call-seq:

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

An instance method.



32375
32376
32377
32378
32379
32380
32381
32382
32383
32384
32385
32386
32387
32388
32389
32390
32391
32392
32393
32394
32395
32396
32397
32398
32399
32400
32401
32402
32403
32404
32405
32406
32407
32408
32409
32410
32411
32412
32413
32414
32415
32416
32417
32418
32419
32420
32421
32422
32423
32424
32425
32426
32427
32428
32429
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32375

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

#chf(*args) ⇒ Object

call-seq:

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

An instance method.



32648
32649
32650
32651
32652
32653
32654
32655
32656
32657
32658
32659
32660
32661
32662
32663
32664
32665
32666
32667
32668
32669
32670
32671
32672
32673
32674
32675
32676
32677
32678
32679
32680
32681
32682
32683
32684
32685
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32648

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

An instance method.



32599
32600
32601
32602
32603
32604
32605
32606
32607
32608
32609
32610
32611
32612
32613
32614
32615
32616
32617
32618
32619
32620
32621
32622
32623
32624
32625
32626
32627
32628
32629
32630
32631
32632
32633
32634
32635
32636
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32599

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

An instance method.



32853
32854
32855
32856
32857
32858
32859
32860
32861
32862
32863
32864
32865
32866
32867
32868
32869
32870
32871
32872
32873
32874
32875
32876
32877
32878
32879
32880
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32853

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

An instance method.



32892
32893
32894
32895
32896
32897
32898
32899
32900
32901
32902
32903
32904
32905
32906
32907
32908
32909
32910
32911
32912
32913
32914
32915
32916
32917
32918
32919
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32892

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



32168
32169
32170
32171
32172
32173
32174
32175
32176
32177
32178
32179
32180
32181
32182
32183
32184
32185
32186
32187
32188
32189
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32168

SWIGINTERN VALUE
_wrap_Normal_location(int argc, VALUE *argv, VALUE self) {
  boost::math::normal_distribution< double,policies::policy< > > *arg1 = (boost::math::normal_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__normal_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::normal_distribution< double,policies::policy< > > const *","location", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::normal_distribution< double,policies::policy< > > * >(argp1);
  result = (double)((boost::math::normal_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 -> double

An instance method.



32102
32103
32104
32105
32106
32107
32108
32109
32110
32111
32112
32113
32114
32115
32116
32117
32118
32119
32120
32121
32122
32123
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32102

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

#median(*args) ⇒ Object

call-seq:

median -> boost::math::normal_distribution< double,policies::policy< > >::value_type

An instance method.



32697
32698
32699
32700
32701
32702
32703
32704
32705
32706
32707
32708
32709
32710
32711
32712
32713
32714
32715
32716
32717
32718
32719
32720
32721
32722
32723
32724
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32697

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

An instance method.



32736
32737
32738
32739
32740
32741
32742
32743
32744
32745
32746
32747
32748
32749
32750
32751
32752
32753
32754
32755
32756
32757
32758
32759
32760
32761
32762
32763
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32736

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

An instance method.



32234
32235
32236
32237
32238
32239
32240
32241
32242
32243
32244
32245
32246
32247
32248
32249
32250
32251
32252
32253
32254
32255
32256
32257
32258
32259
32260
32261
32262
32263
32264
32265
32266
32267
32268
32269
32270
32271
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32234

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

An instance method.



32533
32534
32535
32536
32537
32538
32539
32540
32541
32542
32543
32544
32545
32546
32547
32548
32549
32550
32551
32552
32553
32554
32555
32556
32557
32558
32559
32560
32561
32562
32563
32564
32565
32566
32567
32568
32569
32570
32571
32572
32573
32574
32575
32576
32577
32578
32579
32580
32581
32582
32583
32584
32585
32586
32587
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32533

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

#range(*args) ⇒ Object

call-seq:

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

An instance method.



32931
32932
32933
32934
32935
32936
32937
32938
32939
32940
32941
32942
32943
32944
32945
32946
32947
32948
32949
32950
32951
32952
32953
32954
32955
32956
32957
32958
32959
32960
32961
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32931

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



32201
32202
32203
32204
32205
32206
32207
32208
32209
32210
32211
32212
32213
32214
32215
32216
32217
32218
32219
32220
32221
32222
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32201

SWIGINTERN VALUE
_wrap_Normal_scale(int argc, VALUE *argv, VALUE self) {
  boost::math::normal_distribution< double,policies::policy< > > *arg1 = (boost::math::normal_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__normal_distributionT_double_policies__policyT_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "boost::math::normal_distribution< double,policies::policy< > > const *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< boost::math::normal_distribution< double,policies::policy< > > * >(argp1);
  result = (double)((boost::math::normal_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::normal_distribution< double,policies::policy< > >::value_type

An instance method.



32814
32815
32816
32817
32818
32819
32820
32821
32822
32823
32824
32825
32826
32827
32828
32829
32830
32831
32832
32833
32834
32835
32836
32837
32838
32839
32840
32841
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32814

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

An instance method.



32135
32136
32137
32138
32139
32140
32141
32142
32143
32144
32145
32146
32147
32148
32149
32150
32151
32152
32153
32154
32155
32156
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32135

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

#support(*args) ⇒ Object

call-seq:

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

An instance method.



32973
32974
32975
32976
32977
32978
32979
32980
32981
32982
32983
32984
32985
32986
32987
32988
32989
32990
32991
32992
32993
32994
32995
32996
32997
32998
32999
33000
33001
33002
33003
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32973

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

An instance method.



32775
32776
32777
32778
32779
32780
32781
32782
32783
32784
32785
32786
32787
32788
32789
32790
32791
32792
32793
32794
32795
32796
32797
32798
32799
32800
32801
32802
# File 'ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx', line 32775

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