Boost-Geometry-Utils
view release on metacpan or search on metacpan
src/boost/cstdint.hpp view on Meta::CPAN
#else // BOOST_HAS_STDINT_H
# include <boost/limits.hpp> // implementation artifact; not part of interface
# include <limits.h> // needed for limits macros
namespace boost
{
// These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
// platforms. For other systems, they will have to be hand tailored.
//
// Because the fast types are assumed to be the same as the undecorated types,
// it may be possible to hand tailor a more efficient implementation. Such
// an optimization may be illusionary; on the Intel x86-family 386 on, for
// example, byte arithmetic and load/stores are as fast as "int" sized ones.
// 8-bit types ------------------------------------------------------------//
# if UCHAR_MAX == 0xff
src/boost/integer.hpp view on Meta::CPAN
typedef typename int_fast_t<least>::type fast;
};
// unsigned
template< int Bits > // bits required
struct uint_t : public detail::exact_unsigned_base_helper<Bits>
{
BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::uintmax_t) * CHAR_BIT),
"No suitable unsigned integer type with the requested number of bits is available.");
#if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
// It's really not clear why this workaround should be needed... shrug I guess! JM
BOOST_STATIC_CONSTANT(int, s =
6 +
(Bits <= ::std::numeric_limits<unsigned long>::digits) +
(Bits <= ::std::numeric_limits<unsigned int>::digits) +
(Bits <= ::std::numeric_limits<unsigned short>::digits) +
(Bits <= ::std::numeric_limits<unsigned char>::digits));
typedef typename detail::int_least_helper< ::boost::uint_t<Bits>::s>::least least;
#else
typedef typename detail::uint_least_helper
<
src/boost/integer.hpp view on Meta::CPAN
// unsigned
#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
template< boost::ulong_long_type MaxValue > // minimum value to require support
#else
template< unsigned long MaxValue > // minimum value to require support
#endif
struct uint_value_t
{
#if (defined(__BORLANDC__) || defined(__CODEGEAR__))
// It's really not clear why this workaround should be needed... shrug I guess! JM
#if defined(BOOST_NO_INTEGRAL_INT64_T)
BOOST_STATIC_CONSTANT(unsigned, which =
1 +
(MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
(MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
(MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
(MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
#else // BOOST_NO_INTEGRAL_INT64_T
BOOST_STATIC_CONSTANT(unsigned, which =
src/boost/math/special_functions/cbrt.hpp view on Meta::CPAN
int i_exp, sign(1);
if(z < 0)
{
z = -z;
sign = -sign;
}
if(z == 0)
return 0;
T guess = frexp(z, &i_exp);
int original_i_exp = i_exp; // save for later
guess = tools::evaluate_polynomial(P, guess);
int i_exp3 = i_exp / 3;
typedef typename largest_cbrt_int_type<T>::type shift_type;
BOOST_STATIC_ASSERT( ::std::numeric_limits<shift_type>::radix == 2);
if(abs(i_exp3) < std::numeric_limits<shift_type>::digits)
{
if(i_exp3 > 0)
guess *= shift_type(1u) << i_exp3;
else
guess /= shift_type(1u) << -i_exp3;
}
else
{
guess = ldexp(guess, i_exp3);
}
i_exp %= 3;
guess *= correction[i_exp + 2];
//
// Now inline Halley iteration.
// We do this here rather than calling tools::halley_iterate since we can
// simplify the expressions algebraically, and don't need most of the error
// checking of the boilerplate version as we know in advance that the function
// is well behaved...
//
typedef typename policies::precision<T, Policy>::type prec;
typedef typename mpl::divides<prec, mpl::int_<3> >::type prec3;
typedef typename mpl::plus<prec3, mpl::int_<3> >::type new_prec;
src/boost/math/special_functions/cbrt.hpp view on Meta::CPAN
T eps = (new_prec::value > 3) ? policies::get_epsilon<T, new_policy>() : ldexp(T(1), -2 - tools::digits<T>() / 3);
T diff;
if(original_i_exp < std::numeric_limits<T>::max_exponent - 3)
{
//
// Safe from overflow, use the fast method:
//
do
{
T g3 = guess * guess * guess;
diff = (g3 + z + z) / (g3 + g3 + z);
guess *= diff;
}
while(fabs(1 - diff) > eps);
}
else
{
//
// Either we're ready to overflow, or we can't tell because numeric_limits isn't
// available for type T:
//
do
{
T g2 = guess * guess;
diff = (g2 - z / guess) / (2 * guess + z / g2);
guess -= diff;
}
while((guess * eps) < fabs(diff));
}
return sign * guess;
}
} // namespace detail
template <class T, class Policy>
inline typename tools::promote_args<T>::type cbrt(T z, const Policy& pol)
{
typedef typename tools::promote_args<T>::type result_type;
typedef typename policies::evaluation<result_type, Policy>::type value_type;
return static_cast<result_type>(detail::cbrt_imp(value_type(z), pol));
src/boost/math/special_functions/detail/erf_inv.hpp view on Meta::CPAN
T R = tools::evaluate_polynomial(P, xs) / tools::evaluate_polynomial(Q, xs);
result = Y * x + R * x;
}
}
return result;
}
template <class T, class Policy>
struct erf_roots
{
boost::math::tuple<T,T,T> operator()(const T& guess)
{
BOOST_MATH_STD_USING
T derivative = sign * (2 / sqrt(constants::pi<T>())) * exp(-(guess * guess));
T derivative2 = -2 * guess * derivative;
return boost::math::make_tuple(((sign > 0) ? static_cast<T>(boost::math::erf(guess, Policy()) - target) : static_cast<T>(boost::math::erfc(guess, Policy())) - target), derivative, derivative2);
}
erf_roots(T z, int s) : target(z), sign(s) {}
private:
T target;
int sign;
};
template <class T, class Policy>
T erf_inv_imp(const T& p, const T& q, const Policy& pol, const boost::mpl::int_<0>*)
{
//
// Generic version, get a guess that's accurate to 64-bits (10^-19)
//
T guess = erf_inv_imp(p, q, pol, static_cast<mpl::int_<64> const*>(0));
T result;
//
// If T has more bit's than 64 in it's mantissa then we need to iterate,
// otherwise we can just return the result:
//
if(policies::digits<T, Policy>() > 64)
{
boost::uintmax_t max_iter = policies::get_max_root_iterations<Policy>();
if(p <= 0.5)
{
result = tools::halley_iterate(detail::erf_roots<typename remove_cv<T>::type, Policy>(p, 1), guess, static_cast<T>(0), tools::max_value<T>(), (policies::digits<T, Policy>() * 2) / 3, max_iter);
}
else
{
result = tools::halley_iterate(detail::erf_roots<typename remove_cv<T>::type, Policy>(q, -1), guess, static_cast<T>(0), tools::max_value<T>(), (policies::digits<T, Policy>() * 2) / 3, max_iter);
}
policies::check_root_iterations<T>("boost::math::erf_inv<%1%>", max_iter, pol);
}
else
{
result = guess;
}
return result;
}
template <class T, class Policy>
struct erf_inv_initializer
{
struct init
{
init()
src/boost/math/special_functions/detail/gamma_inva.hpp view on Meta::CPAN
//
// Function object, this is the functor whose root
// we have to solve:
//
gamma_inva_t<T, Policy> f(z, (p < q) ? p : q, (p < q) ? false : true);
//
// Tolerance: full precision.
//
tools::eps_tolerance<T> tol(policies::digits<T, Policy>());
//
// Now figure out a starting guess for what a may be,
// we'll start out with a value that'll put p or q
// right bang in the middle of their range, the functions
// are quite sensitive so we should need too many steps
// to bracket the root from there:
//
T guess;
T factor = 8;
if(z >= 1)
{
//
// We can use the relationship between the incomplete
// gamma function and the poisson distribution to
// calculate an approximate inverse, for large z
// this is actually pretty accurate, but it fails badly
// when z is very small. Also set our step-factor according
// to how accurate we think the result is likely to be:
//
guess = 1 + inverse_poisson_cornish_fisher(z, q, p, pol);
if(z > 5)
{
if(z > 1000)
factor = 1.01f;
else if(z > 50)
factor = 1.1f;
else if(guess > 10)
factor = 1.25f;
else
factor = 2;
if(guess < 1.1)
factor = 8;
}
}
else if(z > 0.5)
{
guess = z * 1.2f;
}
else
{
guess = -0.4f / log(z);
}
//
// Max iterations permitted:
//
boost::uintmax_t max_iter = policies::get_max_root_iterations<Policy>();
//
// Use our generic derivative-free root finding procedure.
// We could use Newton steps here, taking the PDF of the
// Poisson distribution as our derivative, but that's
// even worse performance-wise than the generic method :-(
//
std::pair<T, T> r = bracket_and_solve_root(f, guess, factor, false, tol, max_iter, pol);
if(max_iter >= policies::get_max_root_iterations<Policy>())
policies::raise_evaluation_error<T>("boost::math::gamma_p_inva<%1%>(%1%, %1%)", "Unable to locate the root within a reasonable number of iterations, closest approximation so far was %1%", r.first, pol);
return (r.first + r.second) / 2;
}
} // namespace detail
template <class T1, class T2, class Policy>
inline typename tools::promote_args<T1, T2>::type
gamma_p_inva(T1 x, T2 p, const Policy& pol)
src/boost/math/special_functions/detail/ibeta_inv_ab.hpp view on Meta::CPAN
//
// Function object, this is the functor whose root
// we have to solve:
//
beta_inv_ab_t<T, Policy> f(b, z, (p < q) ? p : q, (p < q) ? false : true, swap_ab);
//
// Tolerance: full precision.
//
tools::eps_tolerance<T> tol(policies::digits<T, Policy>());
//
// Now figure out a starting guess for what a may be,
// we'll start out with a value that'll put p or q
// right bang in the middle of their range, the functions
// are quite sensitive so we should need too many steps
// to bracket the root from there:
//
T guess = 0;
T factor = 5;
//
// Convert variables to parameters of a negative binomial distribution:
//
T n = b;
T sf = swap_ab ? z : 1-z;
T sfc = swap_ab ? 1-z : z;
T u = swap_ab ? p : q;
T v = swap_ab ? q : p;
if(u <= pow(sf, n))
{
//
// Result is less than 1, negative binomial approximation
// is useless....
//
if((p < q) != swap_ab)
{
guess = (std::min)(T(b * 2), T(1));
}
else
{
guess = (std::min)(T(b / 2), T(1));
}
}
if(n * n * n * u * sf > 0.005)
guess = 1 + inverse_negative_binomial_cornish_fisher(n, sf, sfc, u, v, pol);
if(guess < 10)
{
//
// Negative binomial approximation not accurate in this area:
//
if((p < q) != swap_ab)
{
guess = (std::min)(T(b * 2), T(10));
}
else
{
guess = (std::min)(T(b / 2), T(10));
}
}
else
factor = (v < sqrt(tools::epsilon<T>())) ? 2 : (guess < 20 ? 1.2f : 1.1f);
BOOST_MATH_INSTRUMENT_CODE("guess = " << guess);
//
// Max iterations permitted:
//
boost::uintmax_t max_iter = policies::get_max_root_iterations<Policy>();
std::pair<T, T> r = bracket_and_solve_root(f, guess, factor, swap_ab ? true : false, tol, max_iter, pol);
if(max_iter >= policies::get_max_root_iterations<Policy>())
policies::raise_evaluation_error<T>("boost::math::ibeta_invab_imp<%1%>(%1%,%1%,%1%)", "Unable to locate the root within a reasonable number of iterations, closest approximation so far was %1%", r.first, pol);
return (r.first + r.second) / 2;
}
} // namespace detail
template <class RT1, class RT2, class RT3, class Policy>
typename tools::promote_args<RT1, RT2, RT3>::type
ibeta_inva(RT1 b, RT2 x, RT3 p, const Policy& pol)
src/boost/math/special_functions/detail/ibeta_inverse.hpp view on Meta::CPAN
//
// cross < x <= 1 ; iff eta < mu
// x == cross ; iff eta == mu
// 0 <= x < cross ; iff eta > mu
//
// Where cross == 1 / (1 + mu)
// Many thanks to Prof Temme for clarifying this point.
//
// Therefore we'll just jump straight into Newton iterations
// to solve Eq 4.2 using these bounds, and simple bisection
// as the first guess, in practice this converges pretty quickly
// and we only need a few digits correct anyway:
//
if(eta <= 0)
eta = tools::min_value<T>();
T u = eta - mu * log(eta) + (1 + mu) * log(1 + mu) - mu;
T cross = 1 / (1 + mu);
T lower = eta < mu ? cross : 0;
T upper = eta < mu ? 1 : cross;
T x = (lower + upper) / 2;
x = tools::newton_raphson_iterate(
src/boost/math/special_functions/detail/ibeta_inverse.hpp view on Meta::CPAN
{
// model a distorted quarter circle:
y = pow(1 - pow(p, b * boost::math::beta(a, b, pol)), 1/b);
if(y == 0)
y = boost::math::tools::min_value<T>();
x = 1 - y;
}
}
//
// Now we have a guess for x (and for y) we can set things up for
// iteration. If x > 0.5 it pays to swap things round:
//
if(x > 0.5)
{
std::swap(a, b);
std::swap(p, q);
std::swap(x, y);
invert = !invert;
T l = 1 - upper;
T u = 1 - lower;
src/boost/math/special_functions/detail/igamma_inverse.hpp view on Meta::CPAN
if(a <= 0)
policies::raise_domain_error<T>(function, "Argument a in the incomplete gamma function inverse must be >= 0 (got a=%1%).", a, pol);
if((p < 0) || (p > 1))
policies::raise_domain_error<T>(function, "Probabilty must be in the range [0,1] in the incomplete gamma function inverse (got p=%1%).", p, pol);
if(p == 1)
return tools::max_value<T>();
if(p == 0)
return 0;
bool has_10_digits;
T guess = detail::find_inverse_gamma<T>(a, p, 1 - p, pol, &has_10_digits);
if((policies::digits<T, Policy>() <= 36) && has_10_digits)
return guess;
T lower = tools::min_value<T>();
if(guess <= lower)
guess = tools::min_value<T>();
BOOST_MATH_INSTRUMENT_VARIABLE(guess);
//
// Work out how many digits to converge to, normally this is
// 2/3 of the digits in T, but if the first derivative is very
// large convergence is slow, so we'll bump it up to full
// precision to prevent premature termination of the root-finding routine.
//
unsigned digits = policies::digits<T, Policy>();
if(digits < 30)
{
digits *= 2;
digits /= 3;
}
else
{
digits /= 2;
digits -= 1;
}
if((a < 0.125) && (fabs(gamma_p_derivative(a, guess, pol)) > 1 / sqrt(tools::epsilon<T>())))
digits = policies::digits<T, Policy>() - 2;
//
// Go ahead and iterate:
//
boost::uintmax_t max_iter = policies::get_max_root_iterations<Policy>();
guess = tools::halley_iterate(
detail::gamma_p_inverse_func<T, Policy>(a, p, false),
guess,
lower,
tools::max_value<T>(),
digits,
max_iter);
policies::check_root_iterations<T>(function, max_iter, pol);
BOOST_MATH_INSTRUMENT_VARIABLE(guess);
if(guess == lower)
guess = policies::raise_underflow_error<T>(function, "Expected result known to be non-zero, but is smaller than the smallest available number.", pol);
return guess;
}
template <class T, class Policy>
T gamma_q_inv_imp(T a, T q, const Policy& pol)
{
BOOST_MATH_STD_USING // ADL of std functions.
static const char* function = "boost::math::gamma_q_inv<%1%>(%1%, %1%)";
if(a <= 0)
policies::raise_domain_error<T>(function, "Argument a in the incomplete gamma function inverse must be >= 0 (got a=%1%).", a, pol);
if((q < 0) || (q > 1))
policies::raise_domain_error<T>(function, "Probabilty must be in the range [0,1] in the incomplete gamma function inverse (got q=%1%).", q, pol);
if(q == 0)
return tools::max_value<T>();
if(q == 1)
return 0;
bool has_10_digits;
T guess = detail::find_inverse_gamma<T>(a, 1 - q, q, pol, &has_10_digits);
if((policies::digits<T, Policy>() <= 36) && has_10_digits)
return guess;
T lower = tools::min_value<T>();
if(guess <= lower)
guess = tools::min_value<T>();
//
// Work out how many digits to converge to, normally this is
// 2/3 of the digits in T, but if the first derivative is very
// large convergence is slow, so we'll bump it up to full
// precision to prevent premature termination of the root-finding routine.
//
unsigned digits = policies::digits<T, Policy>();
if(digits < 30)
{
digits *= 2;
digits /= 3;
}
else
{
digits /= 2;
digits -= 1;
}
if((a < 0.125) && (fabs(gamma_p_derivative(a, guess, pol)) > 1 / sqrt(tools::epsilon<T>())))
digits = policies::digits<T, Policy>();
//
// Go ahead and iterate:
//
boost::uintmax_t max_iter = policies::get_max_root_iterations<Policy>();
guess = tools::halley_iterate(
detail::gamma_p_inverse_func<T, Policy>(a, q, true),
guess,
lower,
tools::max_value<T>(),
digits,
max_iter);
policies::check_root_iterations<T>(function, max_iter, pol);
if(guess == lower)
guess = policies::raise_underflow_error<T>(function, "Expected result known to be non-zero, but is smaller than the smallest available number.", pol);
return guess;
}
} // namespace detail
template <class T1, class T2, class Policy>
inline typename tools::promote_args<T1, T2>::type
gamma_p_inv(T1 a, T2 p, const Policy& pol)
{
typedef typename tools::promote_args<T1, T2>::type result_type;
return detail::gamma_p_inv_imp(
src/boost/math/special_functions/ellint_3.hpp view on Meta::CPAN
{
// A&S 17.7.18 & 19
return (k == 0) ? phi : ellint_f_imp(phi, k, pol);
}
if(phi == constants::pi<T>() / 2)
{
// Have to filter this case out before the next
// special case, otherwise we might get an infinity from
// tan(phi).
// Also note that since we can't represent PI/2 exactly
// in a T, this is a bit of a guess as to the users true
// intent...
//
return ellint_pi_imp(v, k, vc, pol);
}
if(k == 0)
{
// A&S 17.7.20:
if(v < 1)
{
T vcr = sqrt(vc);
src/boost/math/special_functions/owens_t.hpp view on Meta::CPAN
RealType vi = a * exp( -ah*ah*half<RealType>() ) / root_two_pi<RealType>();
RealType z = owens_t_znorm1(ah)/h;
RealType last_z = fabs(z);
RealType lim = policies::get_epsilon<RealType, Policy>();
while( true )
{
val += z;
//
// This series stops converging after a while, so put a limit
// on how far we go before returning our best guess:
//
if((fabs(lim * val) > fabs(z)) || ((ii > maxii) && (fabs(z) > last_z)) || (z == 0))
{
val *= exp( -hs*half<RealType>() ) / root_two_pi<RealType>();
break;
} // if( maxii <= ii )
last_z = fabs(z);
z = y * ( vi - static_cast<RealType>(ii) * z );
vi *= as;
ii += 2;
src/boost/math/tools/roots.hpp view on Meta::CPAN
template <class Tuple, class T>
inline void unpack_0(const Tuple& t, T& val)
{ val = boost::math::get<0>(t); }
template <class F, class T>
void handle_zero_derivative(F f,
T& last_f0,
const T& f0,
T& delta,
T& result,
T& guess,
const T& min,
const T& max)
{
if(last_f0 == 0)
{
// this must be the first iteration, pretend that we had a
// previous one at either min or max:
if(result == min)
{
guess = max;
}
else
{
guess = min;
}
unpack_0(f(guess), last_f0);
delta = guess - result;
}
if(sign(last_f0) * sign(f0) < 0)
{
// we've crossed over so move in opposite direction to last step:
if(delta < 0)
{
delta = (result - min) / 2;
}
else
{
src/boost/math/tools/roots.hpp view on Meta::CPAN
}
template <class F, class T, class 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, policies::policy<>());
}
template <class F, class T>
T newton_raphson_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter)
{
BOOST_MATH_STD_USING
T f0(0), f1, last_f0(0);
T result = guess;
T factor = static_cast<T>(ldexp(1.0, 1 - digits));
T delta = 1;
T delta1 = tools::max_value<T>();
T delta2 = tools::max_value<T>();
boost::uintmax_t count(max_iter);
do{
last_f0 = f0;
src/boost/math/tools/roots.hpp view on Meta::CPAN
delta1 = delta;
boost::math::tie(f0, f1) = f(result);
if(0 == f0)
break;
if(f1 == 0)
{
// Oops zero derivative!!!
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Newton iteration, zero derivative found" << std::endl;
#endif
detail::handle_zero_derivative(f, last_f0, f0, delta, result, guess, min, max);
}
else
{
delta = f0 / f1;
}
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Newton iteration, delta = " << delta << std::endl;
#endif
if(fabs(delta * 2) > fabs(delta2))
{
// last two steps haven't converged, try bisection:
delta = (delta > 0) ? (result - min) / 2 : (result - max) / 2;
}
guess = result;
result -= delta;
if(result <= min)
{
delta = 0.5F * (guess - min);
result = guess - delta;
if((result == min) || (result == max))
break;
}
else if(result >= max)
{
delta = 0.5F * (guess - max);
result = guess - delta;
if((result == min) || (result == max))
break;
}
// update brackets:
if(delta > 0)
max = guess;
else
min = guess;
}while(--count && (fabs(result * factor) < fabs(delta)));
max_iter -= count;
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Newton Raphson iteration, final count = " << max_iter << std::endl;
static boost::uintmax_t max_count = 0;
if(max_iter > max_count)
{
max_count = max_iter;
std::cout << "Maximum iterations: " << max_iter << std::endl;
}
#endif
return result;
}
template <class F, class T>
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);
}
template <class F, class T>
T halley_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter)
{
BOOST_MATH_STD_USING
T f0(0), f1, f2;
T result = guess;
T factor = static_cast<T>(ldexp(1.0, 1 - digits));
T delta = (std::max)(T(10000000 * guess), T(10000000)); // arbitarily large delta
T last_f0 = 0;
T delta1 = delta;
T delta2 = delta;
bool out_of_bounds_sentry = false;
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Halley iteration, limit = " << factor << std::endl;
#endif
src/boost/math/tools/roots.hpp view on Meta::CPAN
BOOST_MATH_INSTRUMENT_VARIABLE(f2);
if(0 == f0)
break;
if((f1 == 0) && (f2 == 0))
{
// Oops zero derivative!!!
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Halley iteration, zero derivative found" << std::endl;
#endif
detail::handle_zero_derivative(f, last_f0, f0, delta, result, guess, min, max);
}
else
{
if(f2 != 0)
{
T denom = 2 * f0;
T num = 2 * f1 - f0 * (f2 / f1);
BOOST_MATH_INSTRUMENT_VARIABLE(denom);
BOOST_MATH_INSTRUMENT_VARIABLE(num);
src/boost/math/tools/roots.hpp view on Meta::CPAN
{
// last two steps haven't converged, try bisection:
delta = (delta > 0) ? (result - min) / 2 : (result - max) / 2;
if(fabs(delta) > result)
delta = sign(delta) * result; // protect against huge jumps!
// reset delta2 so that this branch will *not* be taken on the
// next iteration:
delta2 = delta * 3;
BOOST_MATH_INSTRUMENT_VARIABLE(delta);
}
guess = result;
result -= delta;
BOOST_MATH_INSTRUMENT_VARIABLE(result);
// check for out of bounds step:
if(result < min)
{
T diff = ((fabs(min) < 1) && (fabs(result) > 1) && (tools::max_value<T>() / fabs(result) < fabs(min))) ? T(1000) : T(result / min);
if(fabs(diff) < 1)
diff = 1 / diff;
if(!out_of_bounds_sentry && (diff > 0) && (diff < 3))
{
// Only a small out of bounds step, lets assume that the result
// is probably approximately at min:
delta = 0.99f * (guess - min);
result = guess - delta;
out_of_bounds_sentry = true; // only take this branch once!
}
else
{
delta = (guess - min) / 2;
result = guess - delta;
if((result == min) || (result == max))
break;
}
}
else if(result > max)
{
T diff = ((fabs(max) < 1) && (fabs(result) > 1) && (tools::max_value<T>() / fabs(result) < fabs(max))) ? T(1000) : T(result / max);
if(fabs(diff) < 1)
diff = 1 / diff;
if(!out_of_bounds_sentry && (diff > 0) && (diff < 3))
{
// Only a small out of bounds step, lets assume that the result
// is probably approximately at min:
delta = 0.99f * (guess - max);
result = guess - delta;
out_of_bounds_sentry = true; // only take this branch once!
}
else
{
delta = (guess - max) / 2;
result = guess - delta;
if((result == min) || (result == max))
break;
}
}
// update brackets:
if(delta > 0)
max = guess;
else
min = guess;
}while(--count && (fabs(result * factor) < fabs(delta)));
max_iter -= count;
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Halley iteration, final count = " << max_iter << std::endl;
#endif
return result;
}
template <class F, class T>
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);
}
template <class F, class T>
T schroeder_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter)
{
BOOST_MATH_STD_USING
T f0(0), f1, f2, last_f0(0);
T result = guess;
T factor = static_cast<T>(ldexp(1.0, 1 - digits));
T delta = 0;
T delta1 = tools::max_value<T>();
T delta2 = tools::max_value<T>();
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Schroeder iteration, limit = " << factor << std::endl;
#endif
src/boost/math/tools/roots.hpp view on Meta::CPAN
delta1 = delta;
boost::math::tie(f0, f1, f2) = f(result);
if(0 == f0)
break;
if((f1 == 0) && (f2 == 0))
{
// Oops zero derivative!!!
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Halley iteration, zero derivative found" << std::endl;
#endif
detail::handle_zero_derivative(f, last_f0, f0, delta, result, guess, min, max);
}
else
{
T ratio = f0 / f1;
if(ratio / result < 0.1)
{
delta = ratio + (f2 / (2 * f1)) * ratio * ratio;
// check second derivative doesn't over compensate:
if(delta * ratio < 0)
delta = ratio;
}
else
delta = ratio; // fall back to Newton iteration.
}
if(fabs(delta * 2) > fabs(delta2))
{
// last two steps haven't converged, try bisection:
delta = (delta > 0) ? (result - min) / 2 : (result - max) / 2;
}
guess = result;
result -= delta;
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Halley iteration, delta = " << delta << std::endl;
#endif
if(result <= min)
{
delta = 0.5F * (guess - min);
result = guess - delta;
if((result == min) || (result == max))
break;
}
else if(result >= max)
{
delta = 0.5F * (guess - max);
result = guess - delta;
if((result == min) || (result == max))
break;
}
// update brackets:
if(delta > 0)
max = guess;
else
min = guess;
}while(--count && (fabs(result * factor) < fabs(delta)));
max_iter -= count;
#ifdef BOOST_MATH_INSTRUMENT
std::cout << "Schroeder iteration, final count = " << max_iter << std::endl;
static boost::uintmax_t max_count = 0;
if(max_iter > max_count)
{
max_count = max_iter;
std::cout << "Maximum iterations: " << max_iter << std::endl;
}
#endif
return result;
}
template <class F, class T>
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);
}
} // namespace tools
} // namespace math
} // namespace boost
#endif // BOOST_MATH_TOOLS_NEWTON_SOLVER_HPP
src/boost/math/tools/toms748_solve.hpp view on Meta::CPAN
namespace detail{
template <class F, class T>
void bracket(F f, T& a, T& b, T c, T& fa, T& fb, T& d, T& fd)
{
//
// Given a point c inside the existing enclosing interval
// [a, b] sets a = c if f(c) == 0, otherwise finds the new
// enclosing interval: either [a, c] or [c, b] and sets
// d and fd to the point that has just been removed from
// the interval. In other words d is the third best guess
// to the root.
//
BOOST_MATH_STD_USING // For ADL of std math functions
T tol = tools::epsilon<T>() * 2;
//
// If the interval [a,b] is very small, or if c is too close
// to one end of the interval then we need to adjust the
// location of c accordingly:
//
if((b - a) < 2 * tol * a)
src/boost/math/tools/toms748_solve.hpp view on Meta::CPAN
return r;
}
template <class F, class T, class Tol>
inline std::pair<T, T> toms748_solve(F f, const T& ax, const T& bx, Tol tol, boost::uintmax_t& max_iter)
{
return toms748_solve(f, ax, bx, tol, max_iter, policies::policy<>());
}
template <class F, class T, class Tol, class Policy>
std::pair<T, T> bracket_and_solve_root(F f, const T& guess, T factor, bool rising, Tol tol, boost::uintmax_t& max_iter, const Policy& pol)
{
BOOST_MATH_STD_USING
static const char* function = "boost::math::tools::bracket_and_solve_root<%1%>";
//
// Set up inital brackets:
//
T a = guess;
T b = a;
T fa = f(a);
T fb = fa;
//
// Set up invocation count:
//
boost::uintmax_t count = max_iter - 1;
if((fa < 0) == (guess < 0 ? !rising : rising))
{
//
// Zero is to the right of b, so walk upwards
// until we find it:
//
while((boost::math::sign)(fb) == (boost::math::sign)(fa))
{
if(count == 0)
policies::raise_evaluation_error(function, "Unable to bracket root, last nearest value was %1%", b, pol);
//
// Heuristic: every 20 iterations we double the growth factor in case the
// initial guess was *really* bad !
//
if((max_iter - count) % 20 == 0)
factor *= 2;
//
// Now go ahead and move our guess by "factor":
//
a = b;
fa = fb;
b *= factor;
fb = f(b);
--count;
BOOST_MATH_INSTRUMENT_CODE("a = " << a << " b = " << b << " fa = " << fa << " fb = " << fb << " count = " << count);
}
}
else
src/boost/math/tools/toms748_solve.hpp view on Meta::CPAN
{
// Escape route just in case the answer is zero!
max_iter -= count;
max_iter += 1;
return a > 0 ? std::make_pair(T(0), T(a)) : std::make_pair(T(a), T(0));
}
if(count == 0)
policies::raise_evaluation_error(function, "Unable to bracket root, last nearest value was %1%", a, pol);
//
// Heuristic: every 20 iterations we double the growth factor in case the
// initial guess was *really* bad !
//
if((max_iter - count) % 20 == 0)
factor *= 2;
//
// Now go ahead and move are guess by "factor":
//
b = a;
fb = fa;
a /= factor;
fa = f(a);
--count;
BOOST_MATH_INSTRUMENT_CODE("a = " << a << " b = " << b << " fa = " << fa << " fb = " << fb << " count = " << count);
}
}
max_iter -= count;
src/boost/math/tools/toms748_solve.hpp view on Meta::CPAN
(a < 0 ? fa : fb),
tol,
count,
pol);
max_iter += count;
BOOST_MATH_INSTRUMENT_CODE("max_iter = " << max_iter << " count = " << count);
return r;
}
template <class F, class T, class Tol>
inline std::pair<T, T> bracket_and_solve_root(F f, const T& guess, const T& factor, bool rising, Tol tol, boost::uintmax_t& max_iter)
{
return bracket_and_solve_root(f, guess, factor, rising, tol, max_iter, policies::policy<>());
}
} // namespace tools
} // namespace math
} // namespace boost
#endif // BOOST_MATH_TOOLS_SOLVE_ROOT_HPP
src/boost/polygon/rectangle_concept.hpp view on Meta::CPAN
typedef typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::manhattan_area_type area_type;
return (area_type)delta(rectangle, HORIZONTAL) * (area_type)delta(rectangle, VERTICAL);
}
struct y_r_go : gtl_yes {};
// returns the orientation of the longest side
template <typename rectangle_type>
typename enable_if<typename gtl_and<y_r_go, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
orientation_2d>::type
guess_orientation(const rectangle_type& rectangle) {
return delta(rectangle, HORIZONTAL) >= delta(rectangle, VERTICAL) ?
HORIZONTAL : VERTICAL;
}
struct y_r_half_p : gtl_yes {};
// get the half perimeter of the rectangle
template <typename rectangle_type>
typename enable_if< typename gtl_and<y_r_half_p, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
typename rectangle_difference_type<rectangle_type>::type>::type
src/boost/program_options/cmdline.hpp view on Meta::CPAN
which start with either "-" or "/". Both kinds can be allowed or
disallowed, see allow_long and allow_short. The allowed character
for short options is also configurable.
Option's value can be specified in the same token as name
("--foo=bar"), or in the next token.
It's possible to introduce long options by the same character as
short options, see allow_long_disguise.
Finally, guessing (specifying only prefix of option) and case
insensitive processing are supported.
*/
enum style_t {
/// Allow "--long_name" style
allow_long = 1,
/// Allow "-<single character" style
allow_short = allow_long << 1,
/// Allow "-" in short options
allow_dash_for_short = allow_short << 1,
/// Allow "/" in short options
src/boost/program_options/cmdline.hpp view on Meta::CPAN
so that "-s -k" become "-sk". All of the options
but last should accept no parameter. For example, if
"-s" accept a parameter, then "k" will be taken as
parameter, not another short option.
Dos-style short options cannot be sticky.
*/
allow_sticky = short_allow_next << 1,
/** Allow abbreviated spellings for long options,
if they unambiguously identify long option.
No long option name should be prefix of other
long option name if guessing is in effect.
*/
allow_guessing = allow_sticky << 1,
/** Ignore the difference in case for long options.
*/
long_case_insensitive = allow_guessing << 1,
/** Ignore the difference in case for short options.
*/
short_case_insensitive = long_case_insensitive << 1,
/** Ignore the difference in case for all options.
*/
case_insensitive = (long_case_insensitive | short_case_insensitive),
/** Allow long options with single option starting character,
e.g <tt>-foo=10</tt>
*/
allow_long_disguise = short_case_insensitive << 1,
/** The more-or-less traditional unix style. */
unix_style = (allow_short | short_allow_adjacent | short_allow_next
| allow_long | long_allow_adjacent | long_allow_next
| allow_sticky | allow_guessing
| allow_dash_for_short),
/** The default style. */
default_style = unix_style
};
}}}
#endif
src/boost/program_options/detail/cmdline.hpp view on Meta::CPAN
Sometimes the registered option name is not equal to the encountered
one, for example, because name abbreviation is supported. Therefore
two option names can be obtained:
- the registered one
- the one found at the command line
There are lot of style options, which can be used to tune the command
line parsing. In addition, it's possible to install additional parser
which will process custom option styles.
@todo mininal match length for guessing?
*/
class BOOST_PROGRAM_OPTIONS_DECL cmdline {
public:
typedef ::boost::program_options::command_line_style::style_t style_t;
typedef function1<std::pair<std::string, std::string>,
const std::string&>
additional_parser;
src/boost/program_options/positional_options.hpp view on Meta::CPAN
#if defined(BOOST_MSVC)
# pragma warning (push)
# pragma warning (disable:4251) // class 'std::vector<_Ty>' needs to have dll-interface to be used by clients of class 'boost::program_options::positional_options_description'
#endif
namespace boost { namespace program_options {
/** Describes positional options.
The class allows to guess option names for positional options, which
are specified on the command line and are identified by the position.
The class uses the information provided by the user to associate a name
with every positional option, or tell that no name is known.
The primary assumption is that only the relative order of the
positional options themselves matters, and that any interleaving
ordinary options don't affect interpretation of positional options.
The user initializes the class by specifying that first N positional
options should be given the name X1, following M options should be given
src/boost/test/impl/unit_test_parameters.ipp view on Meta::CPAN
} // local namespace
void
init( int& argc, char** argv )
{
using namespace cla;
try {
s_cla_parser - cla::ignore_mismatch
<< cla::dual_name_parameter<bool>( AUTO_START_DBG + "|d" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Automatically starts debugger if system level error (signal) occurs")
<< cla::named_parameter<std::string>( BREAK_EXEC_PATH )
- (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
cla::description = "For the exception safety testing allows to break at specific execution path")
<< cla::dual_name_parameter<bool>( BUILD_INFO + "|i" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Shows library build information" )
<< cla::dual_name_parameter<bool>( CATCH_SYS_ERRORS + "|s" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Allows to switch between catching and ignoring system errors (signals)")
<< cla::named_parameter<bool>( DETECT_FP_EXCEPT )
- (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
cla::description = "Allows to switch between catching and ignoring floating point exceptions")
<< cla::named_parameter<long>( DETECT_MEM_LEAKS )
- (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
cla::description = "Allows to switch between catching and ignoring memory leaks")
<< cla::dual_name_parameter<unit_test::output_format>( LOG_FORMAT + "|f" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Specifies log format")
<< cla::dual_name_parameter<unit_test::log_level>( LOG_LEVEL + "|l" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Specifies log level")
<< cla::dual_name_parameter<std::string>( LOG_SINK + "|k" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Specifies log sink:stdout(default),stderr or file name")
<< cla::dual_name_parameter<unit_test::output_format>( OUTPUT_FORMAT + "|o" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Specifies output format (both log and report)")
<< cla::dual_name_parameter<int>( RANDOM_SEED + "|a" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,cla::optional_value,
cla::description = "Allows to switch between sequential and random order of test units execution.\n"
"Optionally allows to specify concrete seed for random number generator")
<< cla::dual_name_parameter<unit_test::output_format>( REPORT_FORMAT + "|m" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Specifies report format")
<< cla::dual_name_parameter<unit_test::report_level>(REPORT_LEVEL + "|r")
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Specifies report level")
<< cla::dual_name_parameter<std::string>( REPORT_SINK + "|e" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Specifies report sink:stderr(default),stdout or file name")
<< cla::dual_name_parameter<bool>( RESULT_CODE + "|c" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Allows to disable test modules's result code generation")
<< cla::dual_name_parameter<std::string>( TESTS_TO_RUN + "|t" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Allows to filter which test units to run")
<< cla::named_parameter<bool>( SAVE_TEST_PATTERN )
- (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
cla::description = "Allows to switch between saving and matching against test pattern file")
<< cla::dual_name_parameter<bool>( SHOW_PROGRESS + "|p" )
- (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
cla::description = "Turns on progress display")
<< cla::named_parameter<bool>( USE_ALT_STACK )
- (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
cla::description = "Turns on/off usage of an alternative stack for signal handling")
<< cla::dual_name_parameter<bool>( "help|?" )
- (cla::prefix = "--|-",cla::separator = "=",cla::guess_name,cla::optional,
cla::description = "this help message")
;
s_cla_parser.parse( argc, argv );
if( s_cla_parser["help"] ) {
s_cla_parser.help( std::cout );
throw framework::nothing_to_test();
}
src/boost/test/utils/runtime/cla/modifier.hpp view on Meta::CPAN
// ************************************************************************** //
namespace {
nfp::typed_keyword<bool,struct optional_t> optional_m;
nfp::named_parameter<bool,optional_t,bool> optional( true );
nfp::typed_keyword<bool,struct required_t> required_m;
nfp::named_parameter<bool,required_t,bool> required( true );
nfp::typed_keyword<bool,struct multiplicable_t> multiplicable_m;
nfp::named_parameter<bool,multiplicable_t,bool> multiplicable( true );
nfp::typed_keyword<bool,struct guess_name_t> guess_name_m;
nfp::named_parameter<bool,guess_name_t,bool> guess_name( true );
nfp::typed_keyword<bool,struct ignore_mismatch_t> ignore_mismatch_m;
nfp::named_parameter<bool,ignore_mismatch_t,bool> ignore_mismatch( true );
nfp::typed_keyword<bool,struct optional_value_t> optional_value_m;
nfp::named_parameter<bool,optional_value_t,bool> optional_value( true );
nfp::typed_keyword<char_type,struct input_separator_t> input_separator;
nfp::typed_keyword<cstring,struct prefix_t> prefix;
nfp::typed_keyword<cstring,struct name_t> name;
nfp::typed_keyword<cstring,struct separator_t> separator;
nfp::typed_keyword<cstring,struct description_t> description;
src/boost/test/utils/runtime/cla/named_parameter.hpp view on Meta::CPAN
// policy interface
virtual bool responds_to( cstring name ) const;
virtual bool conflict_with( identification_policy const& ) const;
// Accept modifier
template<typename Modifier>
void accept_modifier( Modifier const& m )
{
basic_naming_policy::accept_modifier( m );
if( m.has( guess_name_m ) )
m_guess_name = true;
}
private:
// Naming policy interface
virtual bool match_name( argv_traverser& tr ) const;
// Data members
bool m_guess_name;
};
// ************************************************************************** //
// ************** runtime::cla::named_parameter ************** //
// ************************************************************************** //
template<typename T>
class named_parameter_t : public basic_parameter<T,string_name_policy> {
typedef basic_parameter<T,string_name_policy> base;
public:
src/boost/test/utils/runtime/cla/named_parameter.ipp view on Meta::CPAN
namespace cla {
// ************************************************************************** //
// ************** string_name_policy ************** //
// ************************************************************************** //
BOOST_RT_PARAM_INLINE
string_name_policy::string_name_policy()
: basic_naming_policy( rtti::type_id<string_name_policy>() )
, m_guess_name( false )
{
assign_op( p_prefix.value, BOOST_RT_PARAM_CSTRING_LITERAL( "-" ), 0 );
}
//____________________________________________________________________________//
BOOST_RT_PARAM_INLINE bool
string_name_policy::responds_to( cstring name ) const
{
std::pair<cstring::iterator,dstring::const_iterator> mm_pos;
mm_pos = unit_test::mismatch( name.begin(), name.end(), p_name->begin(), p_name->end() );
return mm_pos.first == name.end() && (m_guess_name || (mm_pos.second == p_name->end()) );
}
//____________________________________________________________________________//
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable:4244)
#endif
BOOST_RT_PARAM_INLINE bool
src/boost/test/utils/runtime/cla/named_parameter.ipp view on Meta::CPAN
if( p_name->empty() || snp.p_name->empty() )
return false;
if( p_prefix != snp.p_prefix )
return false;
std::pair<dstring::const_iterator,dstring::const_iterator> mm_pos =
unit_test::mismatch( p_name->begin(), p_name->end(), snp.p_name->begin(), snp.p_name->end() );
return mm_pos.first != p_name->begin() && // there is common substring
((m_guess_name && (mm_pos.second == snp.p_name->end()) ) || // that match other guy and I am guessing
(snp.m_guess_name && (mm_pos.first == p_name->end()) )); // or me and the other guy is
}
if( id.p_type_id == rtti::type_id<char_name_policy>() ) {
char_name_policy const& cnp = static_cast<char_name_policy const&>( id );
return m_guess_name &&
(p_prefix == cnp.p_prefix) &&
unit_test::first_char( cstring( p_name ) ) == unit_test::first_char( cstring( cnp.p_name ) );
}
return false;
}
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
//____________________________________________________________________________//
BOOST_RT_PARAM_INLINE bool
string_name_policy::match_name( argv_traverser& tr ) const
{
if( !m_guess_name )
return basic_naming_policy::match_name( tr );
cstring in = tr.input();
std::pair<cstring::iterator,dstring::const_iterator> mm_pos;
mm_pos = unit_test::mismatch( in.begin(), in.end(), p_name->begin(), p_name->end() );
if( mm_pos.first == in.begin() )
return false;
src/ppport.h view on Meta::CPAN
#ifndef UV_MAX
# define UV_MAX PERL_ULONG_MAX
#endif
#endif
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
#ifndef UVSIZE
# define UVSIZE IVSIZE
#endif
#ifndef sv_setuv
( run in 0.623 second using v1.01-cache-2.11-cpan-748bfb374f4 )