|
|
Boost-Commit : |
From: johnmaddock_at_[hidden]
Date: 2007-05-24 13:36:51
Author: johnmaddock
Date: 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
New Revision: 4227
URL: http://svn.boost.org/trac/boost/changeset/4227
Log:
Added "inline" specifier to lots of functions that really should always have had it....
Text files modified:
sandbox/math_toolkit/boost/math/distributions/bernoulli.hpp | 14 ++++++------
sandbox/math_toolkit/boost/math/distributions/beta.hpp | 14 ++++++------
sandbox/math_toolkit/boost/math/distributions/binomial.hpp | 6 ++--
sandbox/math_toolkit/boost/math/distributions/cauchy.hpp | 8 +++---
sandbox/math_toolkit/boost/math/distributions/chi_squared.hpp | 12 +++++-----
sandbox/math_toolkit/boost/math/distributions/complement.hpp | 12 +++++-----
sandbox/math_toolkit/boost/math/distributions/detail/common_error_handling.hpp | 2
sandbox/math_toolkit/boost/math/distributions/detail/derived_accessors.hpp | 6 ++--
sandbox/math_toolkit/boost/math/distributions/exponential.hpp | 14 ++++++------
sandbox/math_toolkit/boost/math/distributions/extreme_value.hpp | 10 ++++----
sandbox/math_toolkit/boost/math/distributions/fisher_f.hpp | 12 +++++-----
sandbox/math_toolkit/boost/math/distributions/gamma.hpp | 18 ++++++++--------
sandbox/math_toolkit/boost/math/distributions/lognormal.hpp | 12 +++++-----
sandbox/math_toolkit/boost/math/distributions/negative_binomial.hpp | 16 +++++++-------
sandbox/math_toolkit/boost/math/distributions/normal.hpp | 14 ++++++------
sandbox/math_toolkit/boost/math/distributions/pareto.hpp | 20 +++++++++---------
sandbox/math_toolkit/boost/math/distributions/poisson.hpp | 12 +++++-----
sandbox/math_toolkit/boost/math/distributions/rayleigh.hpp | 14 ++++++------
sandbox/math_toolkit/boost/math/distributions/students_t.hpp | 14 ++++++------
sandbox/math_toolkit/boost/math/distributions/triangular.hpp | 14 ++++++------
sandbox/math_toolkit/boost/math/distributions/uniform.hpp | 20 +++++++++---------
sandbox/math_toolkit/boost/math/distributions/weibull.hpp | 18 ++++++++--------
sandbox/math_toolkit/boost/math/special_functions/bessel.hpp | 6 ++--
sandbox/math_toolkit/boost/math/special_functions/beta.hpp | 18 ++++++++--------
sandbox/math_toolkit/boost/math/special_functions/detail/bessel_jv.hpp | 23 ---------------------
sandbox/math_toolkit/boost/math/special_functions/detail/bessel_jy_asym.hpp | 14 ++++++------
sandbox/math_toolkit/boost/math/special_functions/detail/bessel_kv.hpp | 23 ---------------------
sandbox/math_toolkit/boost/math/special_functions/detail/bessel_yv.hpp | 23 ---------------------
sandbox/math_toolkit/boost/math/special_functions/detail/ibeta_inverse.hpp | 4 +-
sandbox/math_toolkit/boost/math/special_functions/detail/igamma_inverse.hpp | 2
sandbox/math_toolkit/boost/math/special_functions/digamma.hpp | 12 +++++-----
sandbox/math_toolkit/boost/math/special_functions/erf.hpp | 4 +-
sandbox/math_toolkit/boost/math/special_functions/expm1.hpp | 2
sandbox/math_toolkit/boost/math/special_functions/factorials.hpp | 2
sandbox/math_toolkit/boost/math/special_functions/fpclassify.hpp | 6 ++--
sandbox/math_toolkit/boost/math/special_functions/gamma.hpp | 12 +++++-----
sandbox/math_toolkit/boost/math/special_functions/spherical_harmonic.hpp | 2
sandbox/math_toolkit/boost/math/tools/minima.hpp | 2
sandbox/math_toolkit/boost/math/tools/polynomial.hpp | 20 +++++++++---------
sandbox/math_toolkit/boost/math/tools/rational.hpp | 2
sandbox/math_toolkit/boost/math/tools/roots.hpp | 8 +++---
sandbox/math_toolkit/boost/math/tools/series.hpp | 42 ----------------------------------------
sandbox/math_toolkit/boost/math/tools/test_data.hpp | 10 ++++----
sandbox/math_toolkit/boost/math/tools/toms748_solve.hpp | 4 +-
44 files changed, 206 insertions(+), 317 deletions(-)
Modified: sandbox/math_toolkit/boost/math/distributions/bernoulli.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/bernoulli.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/bernoulli.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -67,7 +67,7 @@
}
template <class RealType>
- bool check_dist_and_k(const char* function, const RealType& p, RealType k, RealType* result)
+ inline bool check_dist_and_k(const char* function, const RealType& p, RealType k, RealType* result)
{
if(check_dist(function, p, result) == false)
{
@@ -122,14 +122,14 @@
typedef bernoulli_distribution<double> bernoulli;
template <class RealType>
- const std::pair<RealType, RealType> range(const bernoulli_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> range(const bernoulli_distribution<RealType>& /* dist */)
{ // Range of permissible values for random variable k = {0, 1}.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, 1);
}
template <class RealType>
- const std::pair<RealType, RealType> support(const bernoulli_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> support(const bernoulli_distribution<RealType>& /* dist */)
{ // Range of supported values for random variable k = {0, 1}.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
return std::pair<RealType, RealType>(0, 1);
@@ -180,7 +180,7 @@
} // pdf
template <class RealType>
- RealType cdf(const bernoulli_distribution<RealType>& dist, const RealType k)
+ inline RealType cdf(const bernoulli_distribution<RealType>& dist, const RealType k)
{ // Cumulative Distribution Function Bernoulli.
RealType p = dist.success_fraction();
// Error check:
@@ -204,7 +204,7 @@
} // bernoulli cdf
template <class RealType>
- RealType cdf(const complemented2_type<bernoulli_distribution<RealType>, RealType>& c)
+ inline RealType cdf(const complemented2_type<bernoulli_distribution<RealType>, RealType>& c)
{ // Complemented Cumulative Distribution Function bernoulli.
RealType const& k = c.param;
bernoulli_distribution<RealType> const& dist = c.dist;
@@ -230,7 +230,7 @@
} // bernoulli cdf complement
template <class RealType>
- RealType quantile(const bernoulli_distribution<RealType>& dist, const RealType& p)
+ inline RealType quantile(const bernoulli_distribution<RealType>& dist, const RealType& p)
{ // Quantile or Percent Point Bernoulli function.
// Return the number of expected successes k either 0 or 1.
// for a given probability p.
@@ -255,7 +255,7 @@
} // quantile
template <class RealType>
- RealType quantile(const complemented2_type<bernoulli_distribution<RealType>, RealType>& c)
+ inline RealType quantile(const complemented2_type<bernoulli_distribution<RealType>, RealType>& c)
{ // Quantile or Percent Point bernoulli function.
// Return the number of expected successes k for a given
// complement of the probability q.
Modified: sandbox/math_toolkit/boost/math/distributions/beta.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/beta.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/beta.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -270,14 +270,14 @@
}; // template <class RealType> class beta_distribution
template <class RealType>
- const std::pair<RealType, RealType> range(const beta_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> range(const beta_distribution<RealType>& /* dist */)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, 1);
}
template <class RealType>
- const std::pair<RealType, RealType> support(const beta_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> support(const beta_distribution<RealType>& /* dist */)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
return std::pair<RealType, RealType>(0, 1);
@@ -356,7 +356,7 @@
} // kurtosis
template <class RealType>
- RealType pdf(const beta_distribution<RealType>& dist, const RealType x)
+ inline RealType pdf(const beta_distribution<RealType>& dist, const RealType x)
{ // Probability Density/Mass Function.
BOOST_FPU_EXCEPTION_GUARD
@@ -380,7 +380,7 @@
} // pdf
template <class RealType>
- RealType cdf(const beta_distribution<RealType>& dist, const RealType x)
+ inline RealType cdf(const beta_distribution<RealType>& dist, const RealType x)
{ // Cumulative Distribution Function beta.
using boost::math::tools::domain_error;
using namespace std; // for ADL of std functions
@@ -410,7 +410,7 @@
} // beta cdf
template <class RealType>
- RealType cdf(const complemented2_type<beta_distribution<RealType>, RealType>& c)
+ inline RealType cdf(const complemented2_type<beta_distribution<RealType>, RealType>& c)
{ // Complemented Cumulative Distribution Function beta.
using boost::math::tools::domain_error;
@@ -445,7 +445,7 @@
} // beta cdf
template <class RealType>
- RealType quantile(const beta_distribution<RealType>& dist, const RealType& p)
+ inline RealType quantile(const beta_distribution<RealType>& dist, const RealType& p)
{ // Quantile or Percent Point beta function or
// Inverse Cumulative probability distribution function CDF.
// Return x (0 <= x <= 1),
@@ -478,7 +478,7 @@
} // quantile
template <class RealType>
- RealType quantile(const complemented2_type<beta_distribution<RealType>, RealType>& c)
+ inline RealType quantile(const complemented2_type<beta_distribution<RealType>, RealType>& c)
{ // Complement Quantile or Percent Point beta function .
// Return the number of expected x for a given
// complement of the probability q.
Modified: sandbox/math_toolkit/boost/math/distributions/binomial.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/binomial.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/binomial.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -133,7 +133,7 @@
function, N, result);
}
template <class RealType>
- bool check_dist_and_k(const char* function, const RealType& N, const RealType& p, RealType k, RealType* result)
+ inline bool check_dist_and_k(const char* function, const RealType& N, const RealType& p, RealType k, RealType* result)
{
if(check_dist(function, N, p, result) == false)
return false;
@@ -384,7 +384,7 @@
} // pdf
template <class RealType>
- RealType cdf(const binomial_distribution<RealType>& dist, const RealType k)
+ inline RealType cdf(const binomial_distribution<RealType>& dist, const RealType k)
{ // Cumulative Distribution Function Binomial.
// The random variate k is the number of successes in n trials.
// k argument may be integral, signed, or unsigned, or floating point.
@@ -457,7 +457,7 @@
} // binomial cdf
template <class RealType>
- RealType cdf(const complemented2_type<binomial_distribution<RealType>, RealType>& c)
+ inline RealType cdf(const complemented2_type<binomial_distribution<RealType>, RealType>& c)
{ // Complemented Cumulative Distribution Function Binomial.
// The random variate k is the number of successes in n trials.
// k argument may be integral, signed, or unsigned, or floating point.
Modified: sandbox/math_toolkit/boost/math/distributions/cauchy.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/cauchy.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/cauchy.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -28,7 +28,7 @@
{
template <class RealType>
-bool check_cauchy_scale(const char* func, RealType scale, RealType* result)
+inline bool check_cauchy_scale(const char* func, RealType scale, RealType* result)
{
if(scale <= 0)
{
@@ -156,21 +156,21 @@
typedef cauchy_distribution<double> cauchy;
template <class RealType>
-const std::pair<RealType, RealType> range(const cauchy_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const cauchy_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(-max_value<RealType>(), max_value<RealType>()); // - to + infinity.
}
template <class RealType>
-const std::pair<RealType, RealType> support(const cauchy_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const cauchy_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
return std::pair<RealType, RealType>(-tools::max_value<RealType>(), tools::max_value<RealType>()); // - to + infinity.
}
template <class RealType>
-RealType pdf(const cauchy_distribution<RealType>& dist, const RealType& x)
+inline RealType pdf(const cauchy_distribution<RealType>& dist, const RealType& x)
{
RealType result;
RealType loc = dist.location();
Modified: sandbox/math_toolkit/boost/math/distributions/chi_squared.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/chi_squared.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/chi_squared.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -53,14 +53,14 @@
typedef chi_squared_distribution<double> chi_squared;
template <class RealType>
-const std::pair<RealType, RealType> range(const chi_squared_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const chi_squared_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, max_value<RealType>()); // 0 to + infinity.
}
template <class RealType>
-const std::pair<RealType, RealType> support(const chi_squared_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const chi_squared_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
return std::pair<RealType, RealType>(0, tools::max_value<RealType>()); // 0 to + infinity.
@@ -105,7 +105,7 @@
} // pdf
template <class RealType>
-RealType cdf(const chi_squared_distribution<RealType>& dist, const RealType& chi_square)
+inline RealType cdf(const chi_squared_distribution<RealType>& dist, const RealType& chi_square)
{
RealType degrees_of_freedom = dist.degrees_of_freedom();
// Error check:
@@ -124,7 +124,7 @@
} // cdf
template <class RealType>
-RealType quantile(const chi_squared_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const chi_squared_distribution<RealType>& dist, const RealType& p)
{
RealType degrees_of_freedom = dist.degrees_of_freedom();
// Error check:
@@ -139,7 +139,7 @@
} // quantile
template <class RealType>
-RealType cdf(const complemented2_type<chi_squared_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<chi_squared_distribution<RealType>, RealType>& c)
{
RealType const& degrees_of_freedom = c.dist.degrees_of_freedom();
RealType const& chi_square = c.param;
@@ -159,7 +159,7 @@
}
template <class RealType>
-RealType quantile(const complemented2_type<chi_squared_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<chi_squared_distribution<RealType>, RealType>& c)
{
RealType const& degrees_of_freedom = c.dist.degrees_of_freedom();
RealType const& q = c.param;
Modified: sandbox/math_toolkit/boost/math/distributions/complement.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/complement.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/complement.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -153,37 +153,37 @@
};
template <class Dist, class RealType>
-complemented2_type<Dist, RealType> complement(const Dist& d, const RealType& r)
+inline complemented2_type<Dist, RealType> complement(const Dist& d, const RealType& r)
{
return complemented2_type<Dist, RealType>(d, r);
}
template <class Dist, class RealType1, class RealType2>
-complemented3_type<Dist, RealType1, RealType2> complement(const Dist& d, const RealType1& r1, const RealType2& r2)
+inline complemented3_type<Dist, RealType1, RealType2> complement(const Dist& d, const RealType1& r1, const RealType2& r2)
{
return complemented3_type<Dist, RealType1, RealType2>(d, r1, r2);
}
template <class Dist, class RealType1, class RealType2, class RealType3>
-complemented4_type<Dist, RealType1, RealType2, RealType3> complement(const Dist& d, const RealType1& r1, const RealType2& r2, const RealType3& r3)
+inline complemented4_type<Dist, RealType1, RealType2, RealType3> complement(const Dist& d, const RealType1& r1, const RealType2& r2, const RealType3& r3)
{
return complemented4_type<Dist, RealType1, RealType2, RealType3>(d, r1, r2, r3);
}
template <class Dist, class RealType1, class RealType2, class RealType3, class RealType4>
-complemented5_type<Dist, RealType1, RealType2, RealType3, RealType4> complement(const Dist& d, const RealType1& r1, const RealType2& r2, const RealType3& r3, const RealType4& r4)
+inline complemented5_type<Dist, RealType1, RealType2, RealType3, RealType4> complement(const Dist& d, const RealType1& r1, const RealType2& r2, const RealType3& r3, const RealType4& r4)
{
return complemented5_type<Dist, RealType1, RealType2, RealType3, RealType4>(d, r1, r2, r3, r4);
}
template <class Dist, class RealType1, class RealType2, class RealType3, class RealType4, class RealType5>
-complemented6_type<Dist, RealType1, RealType2, RealType3, RealType4, RealType5> complement(const Dist& d, const RealType1& r1, const RealType2& r2, const RealType3& r3, const RealType4& r4, const RealType5& r5)
+inline complemented6_type<Dist, RealType1, RealType2, RealType3, RealType4, RealType5> complement(const Dist& d, const RealType1& r1, const RealType2& r2, const RealType3& r3, const RealType4& r4, const RealType5& r5)
{
return complemented6_type<Dist, RealType1, RealType2, RealType3, RealType4, RealType5>(d, r1, r2, r3, r4, r5);
}
template <class Dist, class RealType1, class RealType2, class RealType3, class RealType4, class RealType5, class RealType6>
-complemented7_type<Dist, RealType1, RealType2, RealType3, RealType4, RealType5, RealType6> complement(const Dist& d, const RealType1& r1, const RealType2& r2, const RealType3& r3, const RealType4& r4, const RealType5& r5, const RealType6& r6)
+inline complemented7_type<Dist, RealType1, RealType2, RealType3, RealType4, RealType5, RealType6> complement(const Dist& d, const RealType1& r1, const RealType2& r2, const RealType3& r3, const RealType4& r4, const RealType5& r5, const RealType6& r6)
{
return complemented7_type<Dist, RealType1, RealType2, RealType3, RealType4, RealType5, RealType6>(d, r1, r2, r3, r4, r5, r6);
}
Modified: sandbox/math_toolkit/boost/math/distributions/detail/common_error_handling.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/detail/common_error_handling.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/detail/common_error_handling.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -45,7 +45,7 @@
}
template <class RealType>
-bool check_scale(
+inline bool check_scale(
const char* function,
RealType scale,
RealType* result)
Modified: sandbox/math_toolkit/boost/math/distributions/detail/derived_accessors.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/detail/derived_accessors.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/detail/derived_accessors.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -56,7 +56,7 @@
}
template <class Distribution, class RealType>
-typename Distribution::value_type hazard(const Distribution& dist, const RealType& x)
+inline typename Distribution::value_type hazard(const Distribution& dist, const RealType& x)
{ // hazard function
// http://www.itl.nist.gov/div898/handbook/eda/section3/eda362.htm#HAZ
typedef typename Distribution::value_type value_type;
@@ -82,7 +82,7 @@
}
template <class Distribution>
-typename Distribution::value_type coefficient_of_variation(const Distribution& dist)
+inline typename Distribution::value_type coefficient_of_variation(const Distribution& dist)
{
typedef typename Distribution::value_type value_type;
@@ -148,7 +148,7 @@
}
template <class Dist>
-typename Dist::value_type median(const Dist& d)
+inline typename Dist::value_type median(const Dist& d)
{ // median - default definition for those distributions for which a
// simple closed form is not known,
// and for which a domain_error and/or NaN generating function is NOT defined.
Modified: sandbox/math_toolkit/boost/math/distributions/exponential.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/exponential.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/exponential.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -76,14 +76,14 @@
typedef exponential_distribution<double> exponential;
template <class RealType>
-const std::pair<RealType, RealType> range(const exponential_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const exponential_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(static_cast<RealType>(0), max_value<RealType>());
}
template <class RealType>
-const std::pair<RealType, RealType> support(const exponential_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const exponential_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -91,7 +91,7 @@
}
template <class RealType>
-RealType pdf(const exponential_distribution<RealType>& dist, const RealType& x)
+inline RealType pdf(const exponential_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -106,7 +106,7 @@
} // pdf
template <class RealType>
-RealType cdf(const exponential_distribution<RealType>& dist, const RealType& x)
+inline RealType cdf(const exponential_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -122,7 +122,7 @@
} // cdf
template <class RealType>
-RealType quantile(const exponential_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const exponential_distribution<RealType>& dist, const RealType& p)
{
using namespace std; // for ADL of std functions
@@ -143,7 +143,7 @@
} // quantile
template <class RealType>
-RealType cdf(const complemented2_type<exponential_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<exponential_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
@@ -159,7 +159,7 @@
}
template <class RealType>
-RealType quantile(const complemented2_type<exponential_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<exponential_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
Modified: sandbox/math_toolkit/boost/math/distributions/extreme_value.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/extreme_value.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/extreme_value.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -71,14 +71,14 @@
typedef extreme_value_distribution<double> extreme_value;
template <class RealType>
-const std::pair<RealType, RealType> range(const extreme_value_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const extreme_value_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(-max_value<RealType>(), max_value<RealType>());
}
template <class RealType>
-const std::pair<RealType, RealType> support(const extreme_value_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const extreme_value_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -86,7 +86,7 @@
}
template <class RealType>
-RealType pdf(const extreme_value_distribution<RealType>& dist, const RealType& x)
+inline RealType pdf(const extreme_value_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -100,7 +100,7 @@
} // pdf
template <class RealType>
-RealType cdf(const extreme_value_distribution<RealType>& dist, const RealType& x)
+inline RealType cdf(const extreme_value_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -139,7 +139,7 @@
} // quantile
template <class RealType>
-RealType cdf(const complemented2_type<extreme_value_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<extreme_value_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
Modified: sandbox/math_toolkit/boost/math/distributions/fisher_f.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/fisher_f.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/fisher_f.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -52,14 +52,14 @@
typedef fisher_f_distribution<double> fisher_f;
template <class RealType>
-const std::pair<RealType, RealType> range(const fisher_f_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const fisher_f_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, max_value<RealType>());
}
template <class RealType>
-const std::pair<RealType, RealType> support(const fisher_f_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const fisher_f_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -123,7 +123,7 @@
} // pdf
template <class RealType>
-RealType cdf(const fisher_f_distribution<RealType>& dist, const RealType& x)
+inline RealType cdf(const fisher_f_distribution<RealType>& dist, const RealType& x)
{
RealType df1 = dist.degrees_of_freedom1();
RealType df2 = dist.degrees_of_freedom2();
@@ -157,7 +157,7 @@
} // cdf
template <class RealType>
-RealType quantile(const fisher_f_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const fisher_f_distribution<RealType>& dist, const RealType& p)
{
RealType df1 = dist.degrees_of_freedom1();
RealType df2 = dist.degrees_of_freedom2();
@@ -179,7 +179,7 @@
} // quantile
template <class RealType>
-RealType cdf(const complemented2_type<fisher_f_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<fisher_f_distribution<RealType>, RealType>& c)
{
RealType df1 = c.dist.degrees_of_freedom1();
RealType df2 = c.dist.degrees_of_freedom2();
@@ -214,7 +214,7 @@
}
template <class RealType>
-RealType quantile(const complemented2_type<fisher_f_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<fisher_f_distribution<RealType>, RealType>& c)
{
RealType df1 = c.dist.degrees_of_freedom1();
RealType df2 = c.dist.degrees_of_freedom2();
Modified: sandbox/math_toolkit/boost/math/distributions/gamma.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/gamma.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/gamma.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -22,7 +22,7 @@
{
template <class RealType>
-bool check_gamma_shape(
+inline bool check_gamma_shape(
const char* function,
RealType shape,
RealType* result)
@@ -38,7 +38,7 @@
}
template <class RealType>
-bool check_gamma_x(
+inline bool check_gamma_x(
const char* function,
RealType const& x,
RealType* result)
@@ -98,14 +98,14 @@
// NO typedef because of clash with name of gamma function.
template <class RealType>
-const std::pair<RealType, RealType> range(const gamma_distribution<RealType>& /* dist */)
+inline const std::pair<RealType, RealType> range(const gamma_distribution<RealType>& /* dist */)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, max_value<RealType>());
}
template <class RealType>
-const std::pair<RealType, RealType> support(const gamma_distribution<RealType>& /* dist */)
+inline const std::pair<RealType, RealType> support(const gamma_distribution<RealType>& /* dist */)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -113,7 +113,7 @@
}
template <class RealType>
-RealType pdf(const gamma_distribution<RealType>& dist, const RealType& x)
+inline RealType pdf(const gamma_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -153,7 +153,7 @@
} // cdf
template <class RealType>
-RealType quantile(const gamma_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const gamma_distribution<RealType>& dist, const RealType& p)
{
using namespace std; // for ADL of std functions
@@ -175,7 +175,7 @@
}
template <class RealType>
-RealType cdf(const complemented2_type<gamma_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<gamma_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
@@ -194,7 +194,7 @@
}
template <class RealType>
-RealType quantile(const complemented2_type<gamma_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<gamma_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
@@ -233,7 +233,7 @@
}
template <class RealType>
-RealType variance(const gamma_distribution<RealType>& dist)
+inline RealType variance(const gamma_distribution<RealType>& dist)
{
using namespace std; // for ADL of std functions
Modified: sandbox/math_toolkit/boost/math/distributions/lognormal.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/lognormal.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/lognormal.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -22,7 +22,7 @@
{
template <class RealType>
- bool check_lognormal_x(
+ inline bool check_lognormal_x(
const char* function,
RealType const& x,
RealType* result)
@@ -73,14 +73,14 @@
typedef lognormal_distribution<double> lognormal;
template <class RealType>
-const std::pair<RealType, RealType> range(const lognormal_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const lognormal_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x is >0 to +infinity.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, max_value<RealType>());
}
template <class RealType>
-const std::pair<RealType, RealType> support(const lognormal_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const lognormal_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -131,7 +131,7 @@
}
template <class RealType>
-RealType quantile(const lognormal_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const lognormal_distribution<RealType>& dist, const RealType& p)
{
using namespace std; // for ADL of std functions
@@ -149,7 +149,7 @@
}
template <class RealType>
-RealType cdf(const complemented2_type<lognormal_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<lognormal_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
@@ -165,7 +165,7 @@
}
template <class RealType>
-RealType quantile(const complemented2_type<lognormal_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<lognormal_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
Modified: sandbox/math_toolkit/boost/math/distributions/negative_binomial.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/negative_binomial.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/negative_binomial.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -97,7 +97,7 @@
&& check_successes(function, r, result);
}
template <class RealType>
- bool check_dist_and_k(const char* function, const RealType& r, const RealType& p, RealType k, RealType* result)
+ inline bool check_dist_and_k(const char* function, const RealType& r, const RealType& p, RealType k, RealType* result)
{
if(check_dist(function, r, p, result) == false)
{
@@ -244,14 +244,14 @@
typedef negative_binomial_distribution<double> negative_binomial; // Reserved name of type double.
template <class RealType>
- const std::pair<RealType, RealType> range(const negative_binomial_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> range(const negative_binomial_distribution<RealType>& /* dist */)
{ // Range of permissible values for random variable k.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, max_value<RealType>()); // max_integer?
}
template <class RealType>
- const std::pair<RealType, RealType> support(const negative_binomial_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> support(const negative_binomial_distribution<RealType>& /* dist */)
{ // Range of supported values for random variable k.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -322,7 +322,7 @@
// chf of Negative Binomial distribution provided by derived accessors.
template <class RealType>
- RealType pdf(const negative_binomial_distribution<RealType>& dist, const RealType k)
+ inline RealType pdf(const negative_binomial_distribution<RealType>& dist, const RealType k)
{ // Probability Density/Mass Function.
BOOST_FPU_EXCEPTION_GUARD
@@ -336,7 +336,7 @@
} // negative_binomial_pdf
template <class RealType>
- RealType cdf(const negative_binomial_distribution<RealType>& dist, const RealType k)
+ inline RealType cdf(const negative_binomial_distribution<RealType>& dist, const RealType k)
{ // Cumulative Distribution Function of Negative Binomial.
using boost::math::ibeta; // Regularized incomplete beta function.
// k argument may be integral, signed, or unsigned, or floating point.
@@ -361,7 +361,7 @@
} // cdf Cumulative Distribution Function Negative Binomial.
template <class RealType>
- RealType cdf(const complemented2_type<negative_binomial_distribution<RealType>, RealType>& c)
+ inline RealType cdf(const complemented2_type<negative_binomial_distribution<RealType>, RealType>& c)
{ // Complemented Cumulative Distribution Function Negative Binomial.
using boost::math::ibetac; // Regularized incomplete beta function complement.
@@ -394,7 +394,7 @@
} // cdf Cumulative Distribution Function Negative Binomial.
template <class RealType>
- RealType quantile(const negative_binomial_distribution<RealType>& dist, const RealType& P)
+ inline RealType quantile(const negative_binomial_distribution<RealType>& dist, const RealType& P)
{ // Quantile, percentile/100 or Percent Point Negative Binomial function.
// Return the number of expected failures k for a given probability p.
@@ -438,7 +438,7 @@
} // RealType quantile(const negative_binomial_distribution dist, p)
template <class RealType>
- RealType quantile(const complemented2_type<negative_binomial_distribution<RealType>, RealType>& c)
+ inline RealType quantile(const complemented2_type<negative_binomial_distribution<RealType>, RealType>& c)
{ // Quantile or Percent Point Binomial function.
// Return the number of expected failures k for a given
// complement of the probability Q = 1 - P.
Modified: sandbox/math_toolkit/boost/math/distributions/normal.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/normal.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/normal.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -49,14 +49,14 @@
typedef normal_distribution<double> normal;
template <class RealType>
-const std::pair<RealType, RealType> range(const normal_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const normal_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(-max_value<RealType>(), max_value<RealType>()); // - to + infinity.
}
template <class RealType>
-const std::pair<RealType, RealType> support(const normal_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const normal_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -64,7 +64,7 @@
}
template <class RealType>
-RealType pdf(const normal_distribution<RealType>& dist, const RealType& x)
+inline RealType pdf(const normal_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -82,7 +82,7 @@
}
template <class RealType>
-RealType cdf(const normal_distribution<RealType>& dist, const RealType& x)
+inline RealType cdf(const normal_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -97,7 +97,7 @@
}
template <class RealType>
-RealType quantile(const normal_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const normal_distribution<RealType>& dist, const RealType& p)
{
using namespace std; // for ADL of std functions
@@ -115,7 +115,7 @@
}
template <class RealType>
-RealType cdf(const complemented2_type<normal_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<normal_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
@@ -132,7 +132,7 @@
}
template <class RealType>
-RealType quantile(const complemented2_type<normal_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<normal_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
Modified: sandbox/math_toolkit/boost/math/distributions/pareto.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/pareto.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/pareto.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -28,7 +28,7 @@
namespace detail
{ // Parameter checking.
template <class RealType>
- bool check_pareto_location(
+ inline bool check_pareto_location(
const char* function,
RealType location,
RealType* result)
@@ -57,7 +57,7 @@
} // bool check_pareto_location
template <class RealType>
- bool check_pareto_shape(
+ inline bool check_pareto_shape(
const char* function,
RealType shape,
RealType* result)
@@ -86,7 +86,7 @@
} // bool check_pareto_shape(
template <class RealType>
- bool check_pareto_x(
+ inline bool check_pareto_x(
const char* function,
RealType const& x,
RealType* result)
@@ -165,14 +165,14 @@
typedef pareto_distribution<double> pareto; // Convenience to allow pareto(2., 3.);
template <class RealType>
- const std::pair<RealType, RealType> range(const pareto_distribution<RealType>& /*dist*/)
+ inline const std::pair<RealType, RealType> range(const pareto_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, max_value<RealType>()); // location zero to + infinity.
} // range
template <class RealType>
- const std::pair<RealType, RealType> support(const pareto_distribution<RealType>& dist)
+ inline const std::pair<RealType, RealType> support(const pareto_distribution<RealType>& dist)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -180,7 +180,7 @@
} // support
template <class RealType>
- RealType pdf(const pareto_distribution<RealType>& dist, const RealType& x)
+ inline RealType pdf(const pareto_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std function pow.
RealType location = dist.location();
@@ -197,7 +197,7 @@
} // pdf
template <class RealType>
- RealType cdf(const pareto_distribution<RealType>& dist, const RealType& x)
+ inline RealType cdf(const pareto_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std function pow.
RealType location = dist.location();
@@ -215,7 +215,7 @@
} // cdf
template <class RealType>
- RealType quantile(const pareto_distribution<RealType>& dist, const RealType& p)
+ inline RealType quantile(const pareto_distribution<RealType>& dist, const RealType& p)
{
using namespace std; // for ADL of std function pow.
RealType result;
@@ -240,7 +240,7 @@
} // quantile
template <class RealType>
- RealType cdf(const complemented2_type<pareto_distribution<RealType>, RealType>& c)
+ inline RealType cdf(const complemented2_type<pareto_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std function pow.
RealType result;
@@ -261,7 +261,7 @@
} // cdf complement
template <class RealType>
- RealType quantile(const complemented2_type<pareto_distribution<RealType>, RealType>& c)
+ inline RealType quantile(const complemented2_type<pareto_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std function pow.
RealType result;
Modified: sandbox/math_toolkit/boost/math/distributions/poisson.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/poisson.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/poisson.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -108,7 +108,7 @@
} // bool check_k
template <class RealType>
- bool check_dist_and_k(const char* function, RealType mean, RealType k, RealType* result)
+ inline bool check_dist_and_k(const char* function, RealType mean, RealType k, RealType* result)
{
if((check_dist(function, mean, result) == false) ||
(check_k(function, k, result) == false))
@@ -132,7 +132,7 @@
} // bool check_prob
template <class RealType>
- bool check_dist_and_prob(const char* function, RealType mean, RealType p, RealType* result)
+ inline bool check_dist_and_prob(const char* function, RealType mean, RealType p, RealType* result)
{
if((check_dist(function, mean, result) == false) ||
(check_prob(function, p, result) == false))
@@ -177,14 +177,14 @@
// Non-member functions to give properties of the distribution.
template <class RealType>
- const std::pair<RealType, RealType> range(const poisson_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> range(const poisson_distribution<RealType>& /* dist */)
{ // Range of permissible values for random variable k.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, max_value<RealType>()); // Max integer?
}
template <class RealType>
- const std::pair<RealType, RealType> support(const poisson_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> support(const poisson_distribution<RealType>& /* dist */)
{ // Range of supported values for random variable k.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -401,7 +401,7 @@
} // poisson ccdf
template <class RealType>
- RealType quantile(const poisson_distribution<RealType>& dist, const RealType& p)
+ inline RealType quantile(const poisson_distribution<RealType>& dist, const RealType& p)
{ // Quantile (or Percent Point) Poisson function.
// Return the number of expected events k for a given probability p.
RealType result; // of Argument checks:
@@ -434,7 +434,7 @@
} // quantile
template <class RealType>
- RealType quantile(const complemented2_type<poisson_distribution<RealType>, RealType>& c)
+ inline RealType quantile(const complemented2_type<poisson_distribution<RealType>, RealType>& c)
{ // Quantile (or Percent Point) of Poisson function.
// Return the number of expected events k for a given
// complement of the probability q.
Modified: sandbox/math_toolkit/boost/math/distributions/rayleigh.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/rayleigh.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/rayleigh.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -76,14 +76,14 @@
typedef rayleigh_distribution<double> rayleigh;
template <class RealType>
-const std::pair<RealType, RealType> range(const rayleigh_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const rayleigh_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(static_cast<RealType>(1), max_value<RealType>());
}
template <class RealType>
-const std::pair<RealType, RealType> support(const rayleigh_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const rayleigh_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -91,7 +91,7 @@
}
template <class RealType>
-RealType pdf(const rayleigh_distribution<RealType>& dist, const RealType& x)
+inline RealType pdf(const rayleigh_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std function exp.
@@ -111,7 +111,7 @@
} // pdf
template <class RealType>
-RealType cdf(const rayleigh_distribution<RealType>& dist, const RealType& x)
+inline RealType cdf(const rayleigh_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -130,7 +130,7 @@
} // cdf
template <class RealType>
-RealType quantile(const rayleigh_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const rayleigh_distribution<RealType>& dist, const RealType& p)
{
using namespace std; // for ADL of std functions
@@ -154,7 +154,7 @@
} // quantile
template <class RealType>
-RealType cdf(const complemented2_type<rayleigh_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<rayleigh_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
@@ -174,7 +174,7 @@
} // cdf complement
template <class RealType>
-RealType quantile(const complemented2_type<rayleigh_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<rayleigh_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions, log & sqrt.
Modified: sandbox/math_toolkit/boost/math/distributions/students_t.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/students_t.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/students_t.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -59,14 +59,14 @@
typedef students_t_distribution<double> students_t;
template <class RealType>
-const std::pair<RealType, RealType> range(const students_t_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const students_t_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(-max_value<RealType>(), max_value<RealType>());
}
template <class RealType>
-const std::pair<RealType, RealType> support(const students_t_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const students_t_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -74,7 +74,7 @@
}
template <class RealType>
-RealType pdf(const students_t_distribution<RealType>& dist, const RealType& t)
+inline RealType pdf(const students_t_distribution<RealType>& dist, const RealType& t)
{
BOOST_FPU_EXCEPTION_GUARD
using namespace std; // for ADL of std functions
@@ -104,7 +104,7 @@
} // pdf
template <class RealType>
-RealType cdf(const students_t_distribution<RealType>& dist, const RealType& t)
+inline RealType cdf(const students_t_distribution<RealType>& dist, const RealType& t)
{
RealType degrees_of_freedom = dist.degrees_of_freedom();
// Error check:
@@ -164,7 +164,7 @@
} // cdf
template <class RealType>
-RealType quantile(const students_t_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const students_t_distribution<RealType>& dist, const RealType& p)
{
using namespace std; // for ADL of std functions
//
@@ -208,13 +208,13 @@
} // quantile
template <class RealType>
-RealType cdf(const complemented2_type<students_t_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<students_t_distribution<RealType>, RealType>& c)
{
return cdf(c.dist, -c.param);
}
template <class RealType>
-RealType quantile(const complemented2_type<students_t_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<students_t_distribution<RealType>, RealType>& c)
{
return -quantile(c.dist, c.param);
}
Modified: sandbox/math_toolkit/boost/math/distributions/triangular.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/triangular.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/triangular.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -22,7 +22,7 @@
namespace detail
{
template <class RealType>
- bool check_triangular_lower(
+ inline bool check_triangular_lower(
const char* function,
RealType lower,
RealType* result)
@@ -41,7 +41,7 @@
} // bool check_triangular_lower(
template <class RealType>
- bool check_triangular_mode(
+ inline bool check_triangular_mode(
const char* function,
RealType mode,
RealType* result)
@@ -60,7 +60,7 @@
} // bool check_triangular_mode(
template <class RealType>
- bool check_triangular_upper(
+ inline bool check_triangular_upper(
const char* function,
RealType upper,
RealType* result)
@@ -79,7 +79,7 @@
} // bool check_triangular_upper(
template <class RealType>
- bool check_triangular_x(
+ inline bool check_triangular_x(
const char* function,
RealType const& x,
RealType* result)
@@ -175,14 +175,14 @@
typedef triangular_distribution<double> triangular;
template <class RealType>
- const std::pair<RealType, RealType> range(const triangular_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> range(const triangular_distribution<RealType>& /* dist */)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(-max_value<RealType>(), max_value<RealType>());
}
template <class RealType>
- const std::pair<RealType, RealType> support(const triangular_distribution<RealType>& dist)
+ inline const std::pair<RealType, RealType> support(const triangular_distribution<RealType>& dist)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
return std::pair<RealType, RealType>(dist.lower(), dist.upper());
@@ -399,7 +399,7 @@
template <class RealType>
- RealType variance(const triangular_distribution<RealType>& dist)
+ inline RealType variance(const triangular_distribution<RealType>& dist)
{
RealType lower = dist.lower();
RealType mode = dist.mode();
Modified: sandbox/math_toolkit/boost/math/distributions/uniform.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/uniform.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/uniform.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -27,7 +27,7 @@
namespace detail
{
template <class RealType>
- bool check_uniform_lower(
+ inline bool check_uniform_lower(
const char* function,
RealType lower,
RealType* result)
@@ -46,7 +46,7 @@
} // bool check_uniform_lower(
template <class RealType>
- bool check_uniform_upper(
+ inline bool check_uniform_upper(
const char* function,
RealType upper,
RealType* result)
@@ -65,7 +65,7 @@
} // bool check_uniform_upper(
template <class RealType>
- bool check_uniform_x(
+ inline bool check_uniform_x(
const char* function,
RealType const& x,
RealType* result)
@@ -138,14 +138,14 @@
typedef uniform_distribution<double> uniform;
template <class RealType>
- const std::pair<RealType, RealType> range(const uniform_distribution<RealType>& /* dist */)
+ inline const std::pair<RealType, RealType> range(const uniform_distribution<RealType>& /* dist */)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(-max_value<RealType>(), max_value<RealType>()); // - to + infinity
}
template <class RealType>
- const std::pair<RealType, RealType> support(const uniform_distribution<RealType>& dist)
+ inline const std::pair<RealType, RealType> support(const uniform_distribution<RealType>& dist)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -153,7 +153,7 @@
}
template <class RealType>
- RealType pdf(const uniform_distribution<RealType>& dist, const RealType& x)
+ inline RealType pdf(const uniform_distribution<RealType>& dist, const RealType& x)
{
RealType lower = dist.lower();
RealType upper = dist.upper();
@@ -203,7 +203,7 @@
} // RealType cdf(const uniform_distribution<RealType>& dist, const RealType& x)
template <class RealType>
- RealType quantile(const uniform_distribution<RealType>& dist, const RealType& p)
+ inline RealType quantile(const uniform_distribution<RealType>& dist, const RealType& p)
{
RealType lower = dist.lower();
RealType upper = dist.upper();
@@ -228,7 +228,7 @@
} // RealType quantile(const uniform_distribution<RealType>& dist, const RealType& p)
template <class RealType>
- RealType cdf(const complemented2_type<uniform_distribution<RealType>, RealType>& c)
+ inline RealType cdf(const complemented2_type<uniform_distribution<RealType>, RealType>& c)
{
RealType lower = c.dist.lower();
RealType upper = c.dist.upper();
@@ -254,7 +254,7 @@
} // RealType cdf(const complemented2_type<uniform_distribution<RealType>, RealType>& c)
template <class RealType>
- RealType quantile(const complemented2_type<uniform_distribution<RealType>, RealType>& c)
+ inline RealType quantile(const complemented2_type<uniform_distribution<RealType>, RealType>& c)
{
RealType lower = c.dist.lower();
RealType upper = c.dist.upper();
@@ -290,7 +290,7 @@
} // RealType mean(const uniform_distribution<RealType>& dist)
template <class RealType>
- RealType variance(const uniform_distribution<RealType>& dist)
+ inline RealType variance(const uniform_distribution<RealType>& dist)
{
RealType lower = dist.lower();
RealType upper = dist.upper();
Modified: sandbox/math_toolkit/boost/math/distributions/weibull.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions/weibull.hpp (original)
+++ sandbox/math_toolkit/boost/math/distributions/weibull.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -21,7 +21,7 @@
namespace detail{
template <class RealType>
-bool check_weibull_shape(
+inline bool check_weibull_shape(
const char* function,
RealType shape,
RealType* result)
@@ -37,7 +37,7 @@
}
template <class RealType>
-bool check_weibull_x(
+inline bool check_weibull_x(
const char* function,
RealType const& x,
RealType* result)
@@ -97,14 +97,14 @@
typedef weibull_distribution<double> weibull;
template <class RealType>
-const std::pair<RealType, RealType> range(const weibull_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> range(const weibull_distribution<RealType>& /*dist*/)
{ // Range of permissible values for random variable x.
using boost::math::tools::max_value;
return std::pair<RealType, RealType>(0, max_value<RealType>());
}
template <class RealType>
-const std::pair<RealType, RealType> support(const weibull_distribution<RealType>& /*dist*/)
+inline const std::pair<RealType, RealType> support(const weibull_distribution<RealType>& /*dist*/)
{ // Range of supported values for random variable x.
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
using boost::math::tools::max_value;
@@ -112,7 +112,7 @@
}
template <class RealType>
-RealType pdf(const weibull_distribution<RealType>& dist, const RealType& x)
+inline RealType pdf(const weibull_distribution<RealType>& dist, const RealType& x)
{
using namespace std; // for ADL of std functions
@@ -154,7 +154,7 @@
}
template <class RealType>
-RealType quantile(const weibull_distribution<RealType>& dist, const RealType& p)
+inline RealType quantile(const weibull_distribution<RealType>& dist, const RealType& p)
{
using namespace std; // for ADL of std functions
@@ -176,7 +176,7 @@
}
template <class RealType>
-RealType cdf(const complemented2_type<weibull_distribution<RealType>, RealType>& c)
+inline RealType cdf(const complemented2_type<weibull_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
@@ -195,7 +195,7 @@
}
template <class RealType>
-RealType quantile(const complemented2_type<weibull_distribution<RealType>, RealType>& c)
+inline RealType quantile(const complemented2_type<weibull_distribution<RealType>, RealType>& c)
{
using namespace std; // for ADL of std functions
@@ -234,7 +234,7 @@
}
template <class RealType>
-RealType variance(const weibull_distribution<RealType>& dist)
+inline RealType variance(const weibull_distribution<RealType>& dist)
{
RealType shape = dist.shape();
RealType scale = dist.scale();
Modified: sandbox/math_toolkit/boost/math/special_functions/bessel.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/bessel.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/bessel.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -195,7 +195,7 @@
}
template <class T>
-T sph_bessel_j_imp(unsigned n, T x)
+inline T sph_bessel_j_imp(unsigned n, T x)
{
using namespace std; // ADL of std names
if(x < 0)
@@ -272,7 +272,7 @@
}
template <class T>
-T cyl_bessel_k_imp(T v, T x, const bessel_no_int_tag& t)
+inline T cyl_bessel_k_imp(T v, T x, const bessel_no_int_tag& t)
{
using namespace std;
if(x < 0)
@@ -370,7 +370,7 @@
}
template <class T>
-T sph_neumann_imp(unsigned v, T x)
+inline T sph_neumann_imp(unsigned v, T x)
{
using namespace std; // ADL of std names
//
Modified: sandbox/math_toolkit/boost/math/special_functions/beta.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/beta.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/beta.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -588,7 +588,7 @@
// Evaluate the incomplete beta via the continued fraction representation:
//
template <class T, class L>
-T ibeta_fraction2(T a, T b, T x, T y, const L& l, bool normalised, T* p_derivative)
+inline T ibeta_fraction2(T a, T b, T x, T y, const L& l, bool normalised, T* p_derivative)
{
using namespace std;
T result = ibeta_power_terms(a, b, x, y, l, normalised);
@@ -638,7 +638,7 @@
// it is currently only called for small k.
//
template <class T>
-T rising_factorial_ratio(T a, T b, int k)
+inline T rising_factorial_ratio(T a, T b, int k)
{
// calculate:
// (a)(a+1)(a+2)...(a+k-1)
@@ -802,7 +802,7 @@
// complement of the binomial distribution cdf and use this finite sum.
//
template <class T>
-T binomial_ccdf(T n, T k, T x, T y)
+inline T binomial_ccdf(T n, T k, T x, T y)
{
using namespace std; // ADL of std names
T result = pow(x, n);
@@ -1173,7 +1173,7 @@
// and forward to the implementation functions:
//
template <class RT1, class RT2>
-typename tools::promote_args<RT1, RT2>::type
+inline typename tools::promote_args<RT1, RT2>::type
beta(RT1 a, RT2 b)
{
BOOST_FPU_EXCEPTION_GUARD
@@ -1184,7 +1184,7 @@
}
template <class RT1, class RT2, class RT3>
-typename tools::promote_args<RT1, RT2, RT3>::type
+inline typename tools::promote_args<RT1, RT2, RT3>::type
beta(RT1 a, RT2 b, RT3 x)
{
BOOST_FPU_EXCEPTION_GUARD
@@ -1195,7 +1195,7 @@
}
template <class RT1, class RT2, class RT3>
-typename tools::promote_args<RT1, RT2, RT3>::type
+inline typename tools::promote_args<RT1, RT2, RT3>::type
betac(RT1 a, RT2 b, RT3 x)
{
BOOST_FPU_EXCEPTION_GUARD
@@ -1206,7 +1206,7 @@
}
template <class RT1, class RT2, class RT3>
-typename tools::promote_args<RT1, RT2, RT3>::type
+inline typename tools::promote_args<RT1, RT2, RT3>::type
ibeta(RT1 a, RT2 b, RT3 x)
{
BOOST_FPU_EXCEPTION_GUARD
@@ -1217,7 +1217,7 @@
}
template <class RT1, class RT2, class RT3>
-typename tools::promote_args<RT1, RT2, RT3>::type
+inline typename tools::promote_args<RT1, RT2, RT3>::type
ibetac(RT1 a, RT2 b, RT3 x)
{
BOOST_FPU_EXCEPTION_GUARD
@@ -1228,7 +1228,7 @@
}
template <class RT1, class RT2, class RT3>
-typename tools::promote_args<RT1, RT2, RT3>::type
+inline typename tools::promote_args<RT1, RT2, RT3>::type
ibeta_derivative(RT1 a, RT2 b, RT3 x)
{
BOOST_FPU_EXCEPTION_GUARD
Modified: sandbox/math_toolkit/boost/math/special_functions/detail/bessel_jv.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/bessel_jv.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/bessel_jv.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -1,27 +1,4 @@
// Copyright (c) 2006 Xiaogang Zhang
-//
-// This code may be used under either of the following two licences:
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE. OF SUCH DAMAGE.
-//
-// Or:
-//
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Modified: sandbox/math_toolkit/boost/math/special_functions/detail/bessel_jy_asym.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/bessel_jy_asym.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/bessel_jy_asym.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -17,7 +17,7 @@
namespace boost{ namespace math{ namespace detail{
template <class T>
-T asymptotic_bessel_j_large_x_P(T v, T x)
+inline T asymptotic_bessel_j_large_x_P(T v, T x)
{
// A&S 9.2.9
T s = 1;
@@ -30,7 +30,7 @@
}
template <class T>
-T asymptotic_bessel_j_large_x_Q(T v, T x)
+inline T asymptotic_bessel_j_large_x_Q(T v, T x)
{
// A&S 9.2.10
T s = 0;
@@ -42,7 +42,7 @@
}
template <class T>
-T asymptotic_bessel_j_large_x(T v, T x)
+inline T asymptotic_bessel_j_large_x(T v, T x)
{
//
// See http://functions.wolfram.com/BesselAiryStruveFunctions/BesselJ/06/02/02/0001/
@@ -57,7 +57,7 @@
}
template <class T>
-T asymptotic_bessel_y_large_x(T v, T x)
+inline T asymptotic_bessel_y_large_x(T v, T x)
{
//
// See http://functions.wolfram.com/BesselAiryStruveFunctions/BesselJ/06/02/02/0001/
@@ -72,7 +72,7 @@
}
template <class T>
-T asymptotic_bessel_amplitude(T v, T x)
+inline T asymptotic_bessel_amplitude(T v, T x)
{
// Calculate the amplitude of J(v, x) and Y(v, x) for large
// x: see A&S 9.2.28.
@@ -113,7 +113,7 @@
}
template <class T>
-T asymptotic_bessel_y_large_x_2(T v, T x)
+inline T asymptotic_bessel_y_large_x_2(T v, T x)
{
// See A&S 9.2.19.
using namespace std;
@@ -129,7 +129,7 @@
}
template <class T>
-T asymptotic_bessel_j_large_x_2(T v, T x)
+inline T asymptotic_bessel_j_large_x_2(T v, T x)
{
// See A&S 9.2.19.
using namespace std;
Modified: sandbox/math_toolkit/boost/math/special_functions/detail/bessel_kv.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/bessel_kv.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/bessel_kv.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -1,27 +1,4 @@
// Copyright (c) 2006 Xiaogang Zhang
-//
-// This code may be used under either of the following two licences:
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE. OF SUCH DAMAGE.
-//
-// Or:
-//
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Modified: sandbox/math_toolkit/boost/math/special_functions/detail/bessel_yv.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/bessel_yv.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/bessel_yv.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -1,27 +1,4 @@
// Copyright (c) 2006 Xiaogang Zhang
-//
-// This code may be used under either of the following two licences:
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE. OF SUCH DAMAGE.
-//
-// Or:
-//
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Modified: sandbox/math_toolkit/boost/math/special_functions/detail/ibeta_inverse.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/ibeta_inverse.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/ibeta_inverse.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -791,7 +791,7 @@
} // namespace detail
template <class T1, class T2, class T3, class T4>
-typename tools::promote_args<T1, T2, T3, T4>::type
+inline typename tools::promote_args<T1, T2, T3, T4>::type
ibeta_inv(T1 a, T2 b, T3 p, T4* py)
{
BOOST_FPU_EXCEPTION_GUARD
@@ -828,7 +828,7 @@
}
template <class T1, class T2, class T3, class T4>
-typename tools::promote_args<T1, T2, T3, T4>::type
+inline typename tools::promote_args<T1, T2, T3, T4>::type
ibetac_inv(T1 a, T2 b, T3 q, T4* py)
{
BOOST_FPU_EXCEPTION_GUARD
Modified: sandbox/math_toolkit/boost/math/special_functions/detail/igamma_inverse.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/detail/igamma_inverse.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/detail/igamma_inverse.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -72,7 +72,7 @@
}
template <class T>
-T didonato_FN(T p, T a, T x, unsigned N, T tolerance)
+inline T didonato_FN(T p, T a, T x, unsigned N, T tolerance)
{
//
// Computation of the Incomplete Gamma Function Ratios and their Inverse
Modified: sandbox/math_toolkit/boost/math/special_functions/digamma.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/digamma.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/digamma.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -35,7 +35,7 @@
// This first one gives 34-digit precision for x >= 20:
//
template <class T>
-T digamma_imp_large(T x, const mpl::int_<0>*)
+inline T digamma_imp_large(T x, const mpl::int_<0>*)
{
using namespace std; // ADL of std functions.
static const T P[] = {
@@ -68,7 +68,7 @@
// 19-digit precision for x >= 10:
//
template <class T>
-T digamma_imp_large(T x, const mpl::int_<64>*)
+inline T digamma_imp_large(T x, const mpl::int_<64>*)
{
using namespace std; // ADL of std functions.
static const T P[] = {
@@ -95,7 +95,7 @@
// 17-digit precision for x >= 10:
//
template <class T>
-T digamma_imp_large(T x, const mpl::int_<53>*)
+inline T digamma_imp_large(T x, const mpl::int_<53>*)
{
using namespace std; // ADL of std functions.
static const T P[] = {
@@ -119,7 +119,7 @@
// 9-digit precision for x >= 10:
//
template <class T>
-T digamma_imp_large(T x, const mpl::int_<24>*)
+inline T digamma_imp_large(T x, const mpl::int_<24>*)
{
using namespace std; // ADL of std functions.
static const T P[] = {
@@ -301,7 +301,7 @@
// 9-digit precision:
//
template <class T>
-T digamma_imp_1_2(T x, const mpl::int_<24>*)
+inline T digamma_imp_1_2(T x, const mpl::int_<24>*)
{
//
// Now the approximation, we use the form:
@@ -405,7 +405,7 @@
} // namespace detail
template <class T>
-typename tools::promote_args<T>::type
+inline typename tools::promote_args<T>::type
digamma(T x)
{
typedef typename tools::promote_args<T>::type result_type;
Modified: sandbox/math_toolkit/boost/math/special_functions/erf.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/erf.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/erf.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -711,7 +711,7 @@
} // namespace detail
template <class T>
-typename tools::promote_args<T>::type erf(T z)
+inline typename tools::promote_args<T>::type erf(T z)
{
typedef typename tools::promote_args<T>::type result_type;
typedef typename lanczos::lanczos_traits<result_type>::value_type value_type;
@@ -743,7 +743,7 @@
}
template <class T>
-typename tools::promote_args<T>::type erfc(T z)
+inline typename tools::promote_args<T>::type erfc(T z)
{
typedef typename tools::promote_args<T>::type result_type;
typedef typename lanczos::lanczos_traits<result_type>::value_type value_type;
Modified: sandbox/math_toolkit/boost/math/special_functions/expm1.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/expm1.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/expm1.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -185,7 +185,7 @@
} // namespace detail
template <class T>
-typename tools::promote_args<T>::type expm1(T x)
+inline typename tools::promote_args<T>::type expm1(T x)
{
typedef typename tools::promote_args<T>::type result_type;
typedef typename tools::evaluation<result_type>::type value_type;
Modified: sandbox/math_toolkit/boost/math/special_functions/factorials.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/factorials.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/factorials.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -24,7 +24,7 @@
{
template <class T>
-T factorial(unsigned i)
+inline T factorial(unsigned i)
{
using namespace std; // Aid ADL for floor.
Modified: sandbox/math_toolkit/boost/math/special_functions/fpclassify.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/fpclassify.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/fpclassify.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -82,7 +82,7 @@
#endif // defined(BOOST_HAS_FPCLASSIFY) || defined(isnan)
template <class T>
-int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const mpl::true_&)
+inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const mpl::true_&)
{
// whenever possible check for Nan's first:
#ifdef BOOST_HAS_FPCLASSIFY
@@ -116,7 +116,7 @@
}
template <class T>
-int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const mpl::false_&)
+inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const mpl::false_&)
{
//
// An unknown type with no numeric_limits support,
@@ -128,7 +128,7 @@
} // namespace detail
template <class T>
-int fpclassify BOOST_NO_MACRO_EXPAND(T t)
+inline int fpclassify BOOST_NO_MACRO_EXPAND(T t)
{
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
if(std::numeric_limits<T>::is_specialized)
Modified: sandbox/math_toolkit/boost/math/special_functions/gamma.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/gamma.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/gamma.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -750,7 +750,7 @@
};
template <class T>
-T upper_gamma_fraction(T a, T z, int bits)
+inline T upper_gamma_fraction(T a, T z, int bits)
{
// Multiply result by z^a * e^-z to get the full
// upper incomplete integral. Divide by tgamma(z)
@@ -778,7 +778,7 @@
};
template <class T>
-T lower_gamma_series(T a, T z, int bits)
+inline T lower_gamma_series(T a, T z, int bits)
{
// Multiply result by ((z^a) * (e^-z) / a) to get the full
// lower incomplete integral. Then divide by tgamma(a)
@@ -921,7 +921,7 @@
}
template <class T, class Tag>
-T tgammap1m1_imp(T dz, Tag const& /*tag*/,
+inline T tgammap1m1_imp(T dz, Tag const& /*tag*/,
const ::boost::math::lanczos::undefined_lanczos& l)
{
using namespace std; // ADL of std names
@@ -1036,7 +1036,7 @@
// Helper to compute log(1+x)-x:
//
template <class T>
-T log1pmx(T x)
+inline T log1pmx(T x)
{
boost::math::detail::log1p_series<T> s(x);
s();
@@ -1185,7 +1185,7 @@
// Upper gamma fraction for very small a:
//
template <class T, class L>
-T tgamma_small_upper_part(T a, T x, const L& l)
+inline T tgamma_small_upper_part(T a, T x, const L& l)
{
using namespace std; // ADL of std functions.
//
@@ -1208,7 +1208,7 @@
// Upper gamma fraction for integer a:
//
template <class T>
-T finite_gamma_q(T a, T x)
+inline T finite_gamma_q(T a, T x)
{
//
// Calculates normalised Q when a is an integer:
Modified: sandbox/math_toolkit/boost/math/special_functions/spherical_harmonic.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/spherical_harmonic.hpp (original)
+++ sandbox/math_toolkit/boost/math/special_functions/spherical_harmonic.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -21,7 +21,7 @@
// though.
//
template <class T>
-T spherical_harmonic_prefix(unsigned n, unsigned m, T theta)
+inline T spherical_harmonic_prefix(unsigned n, unsigned m, T theta)
{
using namespace std;
Modified: sandbox/math_toolkit/boost/math/tools/minima.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/minima.hpp (original)
+++ sandbox/math_toolkit/boost/math/tools/minima.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -132,7 +132,7 @@
}
template <class F, class T>
-std::pair<T, T> brent_find_minima(F f, T min, T max, int digits)
+inline std::pair<T, T> brent_find_minima(F f, T min, T max, int digits)
{
boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)();
return brent_find_minima(f, min, max, digits, m);
Modified: sandbox/math_toolkit/boost/math/tools/polynomial.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/polynomial.hpp (original)
+++ sandbox/math_toolkit/boost/math/tools/polynomial.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -141,7 +141,7 @@
};
template <class T>
-polynomial<T> operator + (const polynomial<T>& a, const polynomial<T>& b)
+inline polynomial<T> operator + (const polynomial<T>& a, const polynomial<T>& b)
{
polynomial<T> result(a);
result += b;
@@ -149,7 +149,7 @@
}
template <class T>
-polynomial<T> operator - (const polynomial<T>& a, const polynomial<T>& b)
+inline polynomial<T> operator - (const polynomial<T>& a, const polynomial<T>& b)
{
polynomial<T> result(a);
result -= b;
@@ -157,7 +157,7 @@
}
template <class T>
-polynomial<T> operator * (const polynomial<T>& a, const polynomial<T>& b)
+inline polynomial<T> operator * (const polynomial<T>& a, const polynomial<T>& b)
{
polynomial<T> result(a);
result *= b;
@@ -165,7 +165,7 @@
}
template <class T, class U>
-polynomial<T> operator + (const polynomial<T>& a, const U& b)
+inline polynomial<T> operator + (const polynomial<T>& a, const U& b)
{
polynomial<T> result(a);
result += b;
@@ -173,7 +173,7 @@
}
template <class T, class U>
-polynomial<T> operator - (const polynomial<T>& a, const U& b)
+inline polynomial<T> operator - (const polynomial<T>& a, const U& b)
{
polynomial<T> result(a);
result -= b;
@@ -181,7 +181,7 @@
}
template <class T, class U>
-polynomial<T> operator * (const polynomial<T>& a, const U& b)
+inline polynomial<T> operator * (const polynomial<T>& a, const U& b)
{
polynomial<T> result(a);
result *= b;
@@ -189,7 +189,7 @@
}
template <class U, class T>
-polynomial<T> operator + (const U& a, const polynomial<T>& b)
+inline polynomial<T> operator + (const U& a, const polynomial<T>& b)
{
polynomial<T> result(b);
result += a;
@@ -197,7 +197,7 @@
}
template <class U, class T>
-polynomial<T> operator - (const U& a, const polynomial<T>& b)
+inline polynomial<T> operator - (const U& a, const polynomial<T>& b)
{
polynomial<T> result(a);
result -= b;
@@ -205,7 +205,7 @@
}
template <class U, class T>
-polynomial<T> operator * (const U& a, const polynomial<T>& b)
+inline polynomial<T> operator * (const U& a, const polynomial<T>& b)
{
polynomial<T> result(b);
result *= a;
@@ -213,7 +213,7 @@
}
template <class charT, class traits, class T>
-std::basic_ostream<charT, traits>& operator << (std::basic_ostream<charT, traits>& os, const polynomial<T>& poly)
+inline std::basic_ostream<charT, traits>& operator << (std::basic_ostream<charT, traits>& os, const polynomial<T>& poly)
{
os << "{ ";
for(unsigned i = 0; i < poly.size(); ++i)
Modified: sandbox/math_toolkit/boost/math/tools/rational.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/rational.hpp (original)
+++ sandbox/math_toolkit/boost/math/tools/rational.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -60,7 +60,7 @@
// the loop expanded versions above:
//
template <class T, class U>
-U evaluate_polynomial(const T* poly, U const& z, std::size_t count)
+inline U evaluate_polynomial(const T* poly, U const& z, std::size_t count)
{
BOOST_ASSERT(count > 0);
U sum = static_cast<U>(poly[count - 1]);
Modified: sandbox/math_toolkit/boost/math/tools/roots.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/roots.hpp (original)
+++ sandbox/math_toolkit/boost/math/tools/roots.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -156,7 +156,7 @@
}
template <class F, class T, class Tol>
-std::pair<T, T> bisect(F f, T min, T max, Tol tol)
+inline std::pair<T, T> bisect(F f, T min, T max, Tol tol)
{
boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)();
return bisect(f, min, max, tol, m);
@@ -244,7 +244,7 @@
}
template <class F, class T>
-T newton_raphson_iterate(F f, T guess, T min, T max, int digits)
+inline T newton_raphson_iterate(F f, T guess, T min, T max, int digits)
{
boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)();
return newton_raphson_iterate(f, guess, min, max, digits, m);
@@ -391,7 +391,7 @@
}
template <class F, class T>
-T halley_iterate(F f, T guess, T min, T max, int digits)
+inline T halley_iterate(F f, T guess, T min, T max, int digits)
{
boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)();
return halley_iterate(f, guess, min, max, digits, m);
@@ -492,7 +492,7 @@
}
template <class F, class T>
-T schroeder_iterate(F f, T guess, T min, T max, int digits)
+inline T schroeder_iterate(F f, T guess, T min, T max, int digits)
{
boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)();
return schroeder_iterate(f, guess, min, max, digits, m);
Modified: sandbox/math_toolkit/boost/math/tools/series.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/series.hpp (original)
+++ sandbox/math_toolkit/boost/math/tools/series.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -163,48 +163,6 @@
return result;
}
-/*
-template <class T, std::size_t N>
-class wijngaarden_euler_sum
-{
-public:
- wijngaarden_euler_sum(T term1)
- {
- nterm=1;
- wksp[0] = 0;
- sum=0.5*(wksp[1]=term1);
- }
-
- void add(T term)
- {
- int j;
- T tmp,dum;
- tmp=wksp[1];
- wksp[1]=term;
- for (j=1;j<=nterm-1;j++)
- {
- dum=wksp[j+1];
- wksp[j+1]=0.5*(wksp[j]+tmp);
- tmp=dum;
- }
- wksp[nterm+1]=0.5*(wksp[nterm]+tmp);
- if (fabs(wksp[nterm+1]) <= fabs(wksp[nterm])) // Favorable to increase p,
- sum += (0.5*wksp[++nterm]); // and the table becomes longer.
- else // Favorable to increase n,
- sum += wksp[nterm+1];
- }
-
- T total()const
- {
- return sum;
- }
-
-private:
- T sum;
- T wksp[N];
- int nterm;
-};
-*/
} // namespace tools
} // namespace math
} // namespace boost
Modified: sandbox/math_toolkit/boost/math/tools/test_data.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/test_data.hpp (original)
+++ sandbox/math_toolkit/boost/math/tools/test_data.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -75,21 +75,21 @@
};
template <class T>
-parameter_info<T> make_random_param(T start_range, T end_range, int n_points)
+inline parameter_info<T> make_random_param(T start_range, T end_range, int n_points)
{
parameter_info<T> result = { random_in_range, start_range, end_range, n_points, 0 };
return result;
}
template <class T>
-parameter_info<T> make_periodic_param(T start_range, T end_range, int n_points)
+inline parameter_info<T> make_periodic_param(T start_range, T end_range, int n_points)
{
parameter_info<T> result = { periodic_in_range, start_range, end_range, n_points, 0 };
return result;
}
template <class T>
-parameter_info<T> make_power_param(T basis, int start_exponent, int end_exponent)
+inline parameter_info<T> make_power_param(T basis, int start_exponent, int end_exponent)
{
parameter_info<T> result = { power_series, basis, 0, start_exponent, end_exponent };
return result;
@@ -320,7 +320,7 @@
// truncation to float-precision only:
//
template <class T>
-float test_data<T>::truncate_to_float(float const * pf)
+inline float test_data<T>::truncate_to_float(float const * pf)
{
extern_val = *pf;
return *pf;
@@ -649,7 +649,7 @@
}
template <class charT, class traits, class T>
-std::basic_ostream<charT, traits>& write_csv(std::basic_ostream<charT, traits>& os,
+inline std::basic_ostream<charT, traits>& write_csv(std::basic_ostream<charT, traits>& os,
const test_data<T>& data)
{
const charT defarg[] = { ',', ' ', '\0' };
Modified: sandbox/math_toolkit/boost/math/tools/toms748_solve.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/tools/toms748_solve.hpp (original)
+++ sandbox/math_toolkit/boost/math/tools/toms748_solve.hpp 2007-05-24 13:36:46 EDT (Thu, 24 May 2007)
@@ -122,7 +122,7 @@
}
template <class T>
-T safe_div(T num, T denom, T r)
+inline T safe_div(T num, T denom, T r)
{
//
// return num / denom without overflow,
@@ -139,7 +139,7 @@
}
template <class T>
-T secant_interpolate(const T& a, const T& b, const T& fa, const T& fb)
+inline T secant_interpolate(const T& a, const T& b, const T& fa, const T& fb)
{
//
// Performs standard secant interpolation of [a,b] given
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk