aabc2/KOS_qrcodes
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

sdk: build libsupc++ from libstdc++ source

Browse Source 
git-svn-id: svn://kolibrios.org@5134 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Sergey Semyonov (Serge)
2014-09-21 10:51:57 +00:00
parent c993fd46f8
commit 9d5ad505ec
863 changed files with 369722 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

251
contrib/sdk/sources/libstdc++-v3/include/tr1/array Normal file
View File

@@ -0,0 +1,251 @@
// class template array -*- C++ -*-
// Copyright (C) 2004-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/array
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_ARRAY
#define _GLIBCXX_TR1_ARRAY 1
#pragma GCC system_header
#include <bits/stl_algobase.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief A standard container for storing a fixed size sequence of elements.
*
* @ingroup sequences
*
* Meets the requirements of a <a href="tables.html#65">container</a>, a
* <a href="tables.html#66">reversible container</a>, and a
* <a href="tables.html#67">sequence</a>.
*
* Sets support random access iterators.
*
* @param Tp Type of element. Required to be a complete type.
* @param N Number of elements.
*/
template<typename _Tp, std::size_t _Nm>
struct array
{
typedef _Tp value_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// Support for zero-sized arrays mandatory.
value_type _M_instance[_Nm ? _Nm : 1];
// No explicit construct/copy/destroy for aggregate type.
void
assign(const value_type& __u)
{ std::fill_n(begin(), size(), __u); }
void
swap(array& __other)
{ std::swap_ranges(begin(), end(), __other.begin()); }
// Iterators.
iterator
begin()
{ return iterator(std::__addressof(_M_instance[0])); }
const_iterator
begin() const
{ return const_iterator(std::__addressof(_M_instance[0])); }
iterator
end()
{ return iterator(std::__addressof(_M_instance[_Nm])); }
const_iterator
end() const
{ return const_iterator(std::__addressof(_M_instance[_Nm])); }
reverse_iterator
rbegin()
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
reverse_iterator
rend()
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const
{ return const_reverse_iterator(begin()); }
// Capacity.
size_type
size() const { return _Nm; }
size_type
max_size() const { return _Nm; }
bool
empty() const { return size() == 0; }
// Element access.
reference
operator[](size_type __n)
{ return _M_instance[__n]; }
const_reference
operator[](size_type __n) const
{ return _M_instance[__n]; }
reference
at(size_type __n)
{
if (__n >= _Nm)
std::__throw_out_of_range(__N("array::at"));
return _M_instance[__n];
}
const_reference
at(size_type __n) const
{
if (__n >= _Nm)
std::__throw_out_of_range(__N("array::at"));
return _M_instance[__n];
}
reference
front()
{ return *begin(); }
const_reference
front() const
{ return *begin(); }
reference
back()
{ return _Nm ? *(end() - 1) : *end(); }
const_reference
back() const
{ return _Nm ? *(end() - 1) : *end(); }
_Tp*
data()
{ return std::__addressof(_M_instance[0]); }
const _Tp*
data() const
{ return std::__addressof(_M_instance[0]); }
};
// Array comparisons.
template<typename _Tp, std::size_t _Nm>
inline bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return std::equal(__one.begin(), __one.end(), __two.begin()); }
template<typename _Tp, std::size_t _Nm>
inline bool
operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one == __two); }
template<typename _Tp, std::size_t _Nm>
inline bool
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
{
return std::lexicographical_compare(__a.begin(), __a.end(),
__b.begin(), __b.end());
}
template<typename _Tp, std::size_t _Nm>
inline bool
operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return __two < __one; }
template<typename _Tp, std::size_t _Nm>
inline bool
operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one > __two); }
template<typename _Tp, std::size_t _Nm>
inline bool
operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one < __two); }
// Specialized algorithms [6.2.2.2].
template<typename _Tp, std::size_t _Nm>
inline void
swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
{ __one.swap(__two); }
// Tuple interface to class template array [6.2.2.5].
/// tuple_size
template<typename _Tp>
class tuple_size;
/// tuple_element
template<int _Int, typename _Tp>
class tuple_element;
template<typename _Tp, std::size_t _Nm>
struct tuple_size<array<_Tp, _Nm> >
{ static const int value = _Nm; };
template<typename _Tp, std::size_t _Nm>
const int
tuple_size<array<_Tp, _Nm> >::value;
template<int _Int, typename _Tp, std::size_t _Nm>
struct tuple_element<_Int, array<_Tp, _Nm> >
{ typedef _Tp type; };
template<int _Int, typename _Tp, std::size_t _Nm>
inline _Tp&
get(array<_Tp, _Nm>& __arr)
{ return __arr[_Int]; }
template<int _Int, typename _Tp, std::size_t _Nm>
inline const _Tp&
get(const array<_Tp, _Nm>& __arr)
{ return __arr[_Int]; }
_GLIBCXX_END_NAMESPACE_VERSION
}
}
#endif // _GLIBCXX_TR1_ARRAY

628
contrib/sdk/sources/libstdc++-v3/include/tr1/bessel_function.tcc Normal file
View File

@@ -0,0 +1,628 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/bessel_function.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland.
//
// References:
// (1) Handbook of Mathematical Functions,
// ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications,
// Section 9, pp. 355-434, Section 10 pp. 435-478
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
// (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 240-245
#ifndef _GLIBCXX_TR1_BESSEL_FUNCTION_TCC
#define _GLIBCXX_TR1_BESSEL_FUNCTION_TCC 1
#include "special_function_util.h"
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Compute the gamma functions required by the Temme series
* expansions of @f$ N_\nu(x) @f$ and @f$ K_\nu(x) @f$.
* @f[
* \Gamma_1 = \frac{1}{2\mu}
* [\frac{1}{\Gamma(1 - \mu)} - \frac{1}{\Gamma(1 + \mu)}]
* @f]
* and
* @f[
* \Gamma_2 = \frac{1}{2}
* [\frac{1}{\Gamma(1 - \mu)} + \frac{1}{\Gamma(1 + \mu)}]
* @f]
* where @f$ -1/2 <= \mu <= 1/2 @f$ is @f$ \mu = \nu - N @f$ and @f$ N @f$.
* is the nearest integer to @f$ \nu @f$.
* The values of \f$ \Gamma(1 + \mu) \f$ and \f$ \Gamma(1 - \mu) \f$
* are returned as well.
*
* The accuracy requirements on this are exquisite.
*
* @param __mu The input parameter of the gamma functions.
* @param __gam1 The output function \f$ \Gamma_1(\mu) \f$
* @param __gam2 The output function \f$ \Gamma_2(\mu) \f$
* @param __gampl The output function \f$ \Gamma(1 + \mu) \f$
* @param __gammi The output function \f$ \Gamma(1 - \mu) \f$
*/
template <typename _Tp>
void
__gamma_temme(_Tp __mu,
_Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi)
{
#if _GLIBCXX_USE_C99_MATH_TR1
__gampl = _Tp(1) / std::tr1::tgamma(_Tp(1) + __mu);
__gammi = _Tp(1) / std::tr1::tgamma(_Tp(1) - __mu);
#else
__gampl = _Tp(1) / __gamma(_Tp(1) + __mu);
__gammi = _Tp(1) / __gamma(_Tp(1) - __mu);
#endif
if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon())
__gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e());
else
__gam1 = (__gammi - __gampl) / (_Tp(2) * __mu);
__gam2 = (__gammi + __gampl) / (_Tp(2));
return;
}
/**
* @brief Compute the Bessel @f$ J_\nu(x) @f$ and Neumann
* @f$ N_\nu(x) @f$ functions and their first derivatives
* @f$ J'_\nu(x) @f$ and @f$ N'_\nu(x) @f$ respectively.
* These four functions are computed together for numerical
* stability.
*
* @param __nu The order of the Bessel functions.
* @param __x The argument of the Bessel functions.
* @param __Jnu The output Bessel function of the first kind.
* @param __Nnu The output Neumann function (Bessel function of the second kind).
* @param __Jpnu The output derivative of the Bessel function of the first kind.
* @param __Npnu The output derivative of the Neumann function.
*/
template <typename _Tp>
void
__bessel_jn(_Tp __nu, _Tp __x,
_Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu)
{
if (__x == _Tp(0))
{
if (__nu == _Tp(0))
{
__Jnu = _Tp(1);
__Jpnu = _Tp(0);
}
else if (__nu == _Tp(1))
{
__Jnu = _Tp(0);
__Jpnu = _Tp(0.5L);
}
else
{
__Jnu = _Tp(0);
__Jpnu = _Tp(0);
}
__Nnu = -std::numeric_limits<_Tp>::infinity();
__Npnu = std::numeric_limits<_Tp>::infinity();
return;
}
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
// When the multiplier is N i.e.
// fp_min = N * min()
// Then J_0 and N_0 tank at x = 8 * N (J_0 = 0 and N_0 = nan)!
//const _Tp __fp_min = _Tp(20) * std::numeric_limits<_Tp>::min();
const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min());
const int __max_iter = 15000;
const _Tp __x_min = _Tp(2);
const int __nl = (__x < __x_min
? static_cast<int>(__nu + _Tp(0.5L))
: std::max(0, static_cast<int>(__nu - __x + _Tp(1.5L))));
const _Tp __mu = __nu - __nl;
const _Tp __mu2 = __mu * __mu;
const _Tp __xi = _Tp(1) / __x;
const _Tp __xi2 = _Tp(2) * __xi;
_Tp __w = __xi2 / __numeric_constants<_Tp>::__pi();
int __isign = 1;
_Tp __h = __nu * __xi;
if (__h < __fp_min)
__h = __fp_min;
_Tp __b = __xi2 * __nu;
_Tp __d = _Tp(0);
_Tp __c = __h;
int __i;
for (__i = 1; __i <= __max_iter; ++__i)
{
__b += __xi2;
__d = __b - __d;
if (std::abs(__d) < __fp_min)
__d = __fp_min;
__c = __b - _Tp(1) / __c;
if (std::abs(__c) < __fp_min)
__c = __fp_min;
__d = _Tp(1) / __d;
const _Tp __del = __c * __d;
__h *= __del;
if (__d < _Tp(0))
__isign = -__isign;
if (std::abs(__del - _Tp(1)) < __eps)
break;
}
if (__i > __max_iter)
std::__throw_runtime_error(__N("Argument x too large in __bessel_jn; "
"try asymptotic expansion."));
_Tp __Jnul = __isign * __fp_min;
_Tp __Jpnul = __h * __Jnul;
_Tp __Jnul1 = __Jnul;
_Tp __Jpnu1 = __Jpnul;
_Tp __fact = __nu * __xi;
for ( int __l = __nl; __l >= 1; --__l )
{
const _Tp __Jnutemp = __fact * __Jnul + __Jpnul;
__fact -= __xi;
__Jpnul = __fact * __Jnutemp - __Jnul;
__Jnul = __Jnutemp;
}
if (__Jnul == _Tp(0))
__Jnul = __eps;
_Tp __f= __Jpnul / __Jnul;
_Tp __Nmu, __Nnu1, __Npmu, __Jmu;
if (__x < __x_min)
{
const _Tp __x2 = __x / _Tp(2);
const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
_Tp __fact = (std::abs(__pimu) < __eps
? _Tp(1) : __pimu / std::sin(__pimu));
_Tp __d = -std::log(__x2);
_Tp __e = __mu * __d;
_Tp __fact2 = (std::abs(__e) < __eps
? _Tp(1) : std::sinh(__e) / __e);
_Tp __gam1, __gam2, __gampl, __gammi;
__gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
_Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi())
* __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
__e = std::exp(__e);
_Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl);
_Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi);
const _Tp __pimu2 = __pimu / _Tp(2);
_Tp __fact3 = (std::abs(__pimu2) < __eps
? _Tp(1) : std::sin(__pimu2) / __pimu2 );
_Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3;
_Tp __c = _Tp(1);
__d = -__x2 * __x2;
_Tp __sum = __ff + __r * __q;
_Tp __sum1 = __p;
for (__i = 1; __i <= __max_iter; ++__i)
{
__ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
__c *= __d / _Tp(__i);
__p /= _Tp(__i) - __mu;
__q /= _Tp(__i) + __mu;
const _Tp __del = __c * (__ff + __r * __q);
__sum += __del;
const _Tp __del1 = __c * __p - __i * __del;
__sum1 += __del1;
if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) )
break;
}
if ( __i > __max_iter )
std::__throw_runtime_error(__N("Bessel y series failed to converge "
"in __bessel_jn."));
__Nmu = -__sum;
__Nnu1 = -__sum1 * __xi2;
__Npmu = __mu * __xi * __Nmu - __Nnu1;
__Jmu = __w / (__Npmu - __f * __Nmu);
}
else
{
_Tp __a = _Tp(0.25L) - __mu2;
_Tp __q = _Tp(1);
_Tp __p = -__xi / _Tp(2);
_Tp __br = _Tp(2) * __x;
_Tp __bi = _Tp(2);
_Tp __fact = __a * __xi / (__p * __p + __q * __q);
_Tp __cr = __br + __q * __fact;
_Tp __ci = __bi + __p * __fact;
_Tp __den = __br * __br + __bi * __bi;
_Tp __dr = __br / __den;
_Tp __di = -__bi / __den;
_Tp __dlr = __cr * __dr - __ci * __di;
_Tp __dli = __cr * __di + __ci * __dr;
_Tp __temp = __p * __dlr - __q * __dli;
__q = __p * __dli + __q * __dlr;
__p = __temp;
int __i;
for (__i = 2; __i <= __max_iter; ++__i)
{
__a += _Tp(2 * (__i - 1));
__bi += _Tp(2);
__dr = __a * __dr + __br;
__di = __a * __di + __bi;
if (std::abs(__dr) + std::abs(__di) < __fp_min)
__dr = __fp_min;
__fact = __a / (__cr * __cr + __ci * __ci);
__cr = __br + __cr * __fact;
__ci = __bi - __ci * __fact;
if (std::abs(__cr) + std::abs(__ci) < __fp_min)
__cr = __fp_min;
__den = __dr * __dr + __di * __di;
__dr /= __den;
__di /= -__den;
__dlr = __cr * __dr - __ci * __di;
__dli = __cr * __di + __ci * __dr;
__temp = __p * __dlr - __q * __dli;
__q = __p * __dli + __q * __dlr;
__p = __temp;
if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps)
break;
}
if (__i > __max_iter)
std::__throw_runtime_error(__N("Lentz's method failed "
"in __bessel_jn."));
const _Tp __gam = (__p - __f) / __q;
__Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q));
#if _GLIBCXX_USE_C99_MATH_TR1
__Jmu = std::tr1::copysign(__Jmu, __Jnul);
#else
if (__Jmu * __Jnul < _Tp(0))
__Jmu = -__Jmu;
#endif
__Nmu = __gam * __Jmu;
__Npmu = (__p + __q / __gam) * __Nmu;
__Nnu1 = __mu * __xi * __Nmu - __Npmu;
}
__fact = __Jmu / __Jnul;
__Jnu = __fact * __Jnul1;
__Jpnu = __fact * __Jpnu1;
for (__i = 1; __i <= __nl; ++__i)
{
const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu;
__Nmu = __Nnu1;
__Nnu1 = __Nnutemp;
}
__Nnu = __Nmu;
__Npnu = __nu * __xi * __Nmu - __Nnu1;
return;
}
/**
* @brief This routine computes the asymptotic cylindrical Bessel
* and Neumann functions of order nu: \f$ J_{\nu} \f$,
* \f$ N_{\nu} \f$.
*
* References:
* (1) Handbook of Mathematical Functions,
* ed. Milton Abramowitz and Irene A. Stegun,
* Dover Publications,
* Section 9 p. 364, Equations 9.2.5-9.2.10
*
* @param __nu The order of the Bessel functions.
* @param __x The argument of the Bessel functions.
* @param __Jnu The output Bessel function of the first kind.
* @param __Nnu The output Neumann function (Bessel function of the second kind).
*/
template <typename _Tp>
void
__cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu)
{
const _Tp __mu = _Tp(4) * __nu * __nu;
const _Tp __mum1 = __mu - _Tp(1);
const _Tp __mum9 = __mu - _Tp(9);
const _Tp __mum25 = __mu - _Tp(25);
const _Tp __mum49 = __mu - _Tp(49);
const _Tp __xx = _Tp(64) * __x * __x;
const _Tp __P = _Tp(1) - __mum1 * __mum9 / (_Tp(2) * __xx)
* (_Tp(1) - __mum25 * __mum49 / (_Tp(12) * __xx));
const _Tp __Q = __mum1 / (_Tp(8) * __x)
* (_Tp(1) - __mum9 * __mum25 / (_Tp(6) * __xx));
const _Tp __chi = __x - (__nu + _Tp(0.5L))
* __numeric_constants<_Tp>::__pi_2();
const _Tp __c = std::cos(__chi);
const _Tp __s = std::sin(__chi);
const _Tp __coef = std::sqrt(_Tp(2)
/ (__numeric_constants<_Tp>::__pi() * __x));
__Jnu = __coef * (__c * __P - __s * __Q);
__Nnu = __coef * (__s * __P + __c * __Q);
return;
}
/**
* @brief This routine returns the cylindrical Bessel functions
* of order \f$ \nu \f$: \f$ J_{\nu} \f$ or \f$ I_{\nu} \f$
* by series expansion.
*
* The modified cylindrical Bessel function is:
* @f[
* Z_{\nu}(x) = \sum_{k=0}^{\infty}
* \frac{\sigma^k (x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
* @f]
* where \f$ \sigma = +1 \f$ or\f$ -1 \f$ for
* \f$ Z = I \f$ or \f$ J \f$ respectively.
*
* See Abramowitz & Stegun, 9.1.10
* Abramowitz & Stegun, 9.6.7
* (1) Handbook of Mathematical Functions,
* ed. Milton Abramowitz and Irene A. Stegun,
* Dover Publications,
* Equation 9.1.10 p. 360 and Equation 9.6.10 p. 375
*
* @param __nu The order of the Bessel function.
* @param __x The argument of the Bessel function.
* @param __sgn The sign of the alternate terms
* -1 for the Bessel function of the first kind.
* +1 for the modified Bessel function of the first kind.
* @return The output Bessel function.
*/
template <typename _Tp>
_Tp
__cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn,
unsigned int __max_iter)
{
if (__x == _Tp(0))
return __nu == _Tp(0) ? _Tp(1) : _Tp(0);
const _Tp __x2 = __x / _Tp(2);
_Tp __fact = __nu * std::log(__x2);
#if _GLIBCXX_USE_C99_MATH_TR1
__fact -= std::tr1::lgamma(__nu + _Tp(1));
#else
__fact -= __log_gamma(__nu + _Tp(1));
#endif
__fact = std::exp(__fact);
const _Tp __xx4 = __sgn * __x2 * __x2;
_Tp __Jn = _Tp(1);
_Tp __term = _Tp(1);
for (unsigned int __i = 1; __i < __max_iter; ++__i)
{
__term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i)));
__Jn += __term;
if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon())
break;
}
return __fact * __Jn;
}
/**
* @brief Return the Bessel function of order \f$ \nu \f$:
* \f$ J_{\nu}(x) \f$.
*
* The cylindrical Bessel function is:
* @f[
* J_{\nu}(x) = \sum_{k=0}^{\infty}
* \frac{(-1)^k (x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
* @f]
*
* @param __nu The order of the Bessel function.
* @param __x The argument of the Bessel function.
* @return The output Bessel function.
*/
template<typename _Tp>
_Tp
__cyl_bessel_j(_Tp __nu, _Tp __x)
{
if (__nu < _Tp(0) || __x < _Tp(0))
std::__throw_domain_error(__N("Bad argument "
"in __cyl_bessel_j."));
else if (__isnan(__nu) || __isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200);
else if (__x > _Tp(1000))
{
_Tp __J_nu, __N_nu;
__cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
return __J_nu;
}
else
{
_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
return __J_nu;
}
}
/**
* @brief Return the Neumann function of order \f$ \nu \f$:
* \f$ N_{\nu}(x) \f$.
*
* The Neumann function is defined by:
* @f[
* N_{\nu}(x) = \frac{J_{\nu}(x) \cos \nu\pi - J_{-\nu}(x)}
* {\sin \nu\pi}
* @f]
* where for integral \f$ \nu = n \f$ a limit is taken:
* \f$ lim_{\nu \to n} \f$.
*
* @param __nu The order of the Neumann function.
* @param __x The argument of the Neumann function.
* @return The output Neumann function.
*/
template<typename _Tp>
_Tp
__cyl_neumann_n(_Tp __nu, _Tp __x)
{
if (__nu < _Tp(0) || __x < _Tp(0))
std::__throw_domain_error(__N("Bad argument "
"in __cyl_neumann_n."));
else if (__isnan(__nu) || __isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__x > _Tp(1000))
{
_Tp __J_nu, __N_nu;
__cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
return __N_nu;
}
else
{
_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
return __N_nu;
}
}
/**
* @brief Compute the spherical Bessel @f$ j_n(x) @f$
* and Neumann @f$ n_n(x) @f$ functions and their first
* derivatives @f$ j'_n(x) @f$ and @f$ n'_n(x) @f$
* respectively.
*
* @param __n The order of the spherical Bessel function.
* @param __x The argument of the spherical Bessel function.
* @param __j_n The output spherical Bessel function.
* @param __n_n The output spherical Neumann function.
* @param __jp_n The output derivative of the spherical Bessel function.
* @param __np_n The output derivative of the spherical Neumann function.
*/
template <typename _Tp>
void
__sph_bessel_jn(unsigned int __n, _Tp __x,
_Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n)
{
const _Tp __nu = _Tp(__n) + _Tp(0.5L);
_Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
__bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
/ std::sqrt(__x);
__j_n = __factor * __J_nu;
__n_n = __factor * __N_nu;
__jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x);
__np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x);
return;
}
/**
* @brief Return the spherical Bessel function
* @f$ j_n(x) @f$ of order n.
*
* The spherical Bessel function is defined by:
* @f[
* j_n(x) = \left( \frac{\pi}{2x} \right) ^{1/2} J_{n+1/2}(x)
* @f]
*
* @param __n The order of the spherical Bessel function.
* @param __x The argument of the spherical Bessel function.
* @return The output spherical Bessel function.
*/
template <typename _Tp>
_Tp
__sph_bessel(unsigned int __n, _Tp __x)
{
if (__x < _Tp(0))
std::__throw_domain_error(__N("Bad argument "
"in __sph_bessel."));
else if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__x == _Tp(0))
{
if (__n == 0)
return _Tp(1);
else
return _Tp(0);
}
else
{
_Tp __j_n, __n_n, __jp_n, __np_n;
__sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
return __j_n;
}
}
/**
* @brief Return the spherical Neumann function
* @f$ n_n(x) @f$.
*
* The spherical Neumann function is defined by:
* @f[
* n_n(x) = \left( \frac{\pi}{2x} \right) ^{1/2} N_{n+1/2}(x)
* @f]
*
* @param __n The order of the spherical Neumann function.
* @param __x The argument of the spherical Neumann function.
* @return The output spherical Neumann function.
*/
template <typename _Tp>
_Tp
__sph_neumann(unsigned int __n, _Tp __x)
{
if (__x < _Tp(0))
std::__throw_domain_error(__N("Bad argument "
"in __sph_neumann."));
else if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__x == _Tp(0))
return -std::numeric_limits<_Tp>::infinity();
else
{
_Tp __j_n, __n_n, __jp_n, __np_n;
__sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
return __n_n;
}
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_BESSEL_FUNCTION_TCC

197
contrib/sdk/sources/libstdc++-v3/include/tr1/beta_function.tcc Normal file
View File

@@ -0,0 +1,197 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/beta_function.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on:
// (1) Handbook of Mathematical Functions,
// ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications,
// Section 6, pp. 253-266
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
// (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 213-216
// (4) Gamma, Exploring Euler's Constant, Julian Havil,
// Princeton, 2003.
#ifndef _GLIBCXX_TR1_BETA_FUNCTION_TCC
#define _GLIBCXX_TR1_BETA_FUNCTION_TCC 1
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Return the beta function: \f$B(x,y)\f$.
*
* The beta function is defined by
* @f[
* B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}
* @f]
*
* @param __x The first argument of the beta function.
* @param __y The second argument of the beta function.
* @return The beta function.
*/
template<typename _Tp>
_Tp
__beta_gamma(_Tp __x, _Tp __y)
{
_Tp __bet;
#if _GLIBCXX_USE_C99_MATH_TR1
if (__x > __y)
{
__bet = std::tr1::tgamma(__x)
/ std::tr1::tgamma(__x + __y);
__bet *= std::tr1::tgamma(__y);
}
else
{
__bet = std::tr1::tgamma(__y)
/ std::tr1::tgamma(__x + __y);
__bet *= std::tr1::tgamma(__x);
}
#else
if (__x > __y)
{
__bet = __gamma(__x) / __gamma(__x + __y);
__bet *= __gamma(__y);
}
else
{
__bet = __gamma(__y) / __gamma(__x + __y);
__bet *= __gamma(__x);
}
#endif
return __bet;
}
/**
* @brief Return the beta function \f$B(x,y)\f$ using
* the log gamma functions.
*
* The beta function is defined by
* @f[
* B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}
* @f]
*
* @param __x The first argument of the beta function.
* @param __y The second argument of the beta function.
* @return The beta function.
*/
template<typename _Tp>
_Tp
__beta_lgamma(_Tp __x, _Tp __y)
{
#if _GLIBCXX_USE_C99_MATH_TR1
_Tp __bet = std::tr1::lgamma(__x)
+ std::tr1::lgamma(__y)
- std::tr1::lgamma(__x + __y);
#else
_Tp __bet = __log_gamma(__x)
+ __log_gamma(__y)
- __log_gamma(__x + __y);
#endif
__bet = std::exp(__bet);
return __bet;
}
/**
* @brief Return the beta function \f$B(x,y)\f$ using
* the product form.
*
* The beta function is defined by
* @f[
* B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}
* @f]
*
* @param __x The first argument of the beta function.
* @param __y The second argument of the beta function.
* @return The beta function.
*/
template<typename _Tp>
_Tp
__beta_product(_Tp __x, _Tp __y)
{
_Tp __bet = (__x + __y) / (__x * __y);
unsigned int __max_iter = 1000000;
for (unsigned int __k = 1; __k < __max_iter; ++__k)
{
_Tp __term = (_Tp(1) + (__x + __y) / __k)
/ ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k));
__bet *= __term;
}
return __bet;
}
/**
* @brief Return the beta function \f$ B(x,y) \f$.
*
* The beta function is defined by
* @f[
* B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}
* @f]
*
* @param __x The first argument of the beta function.
* @param __y The second argument of the beta function.
* @return The beta function.
*/
template<typename _Tp>
inline _Tp
__beta(_Tp __x, _Tp __y)
{
if (__isnan(__x) || __isnan(__y))
return std::numeric_limits<_Tp>::quiet_NaN();
else
return __beta_lgamma(__x, __y);
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // __GLIBCXX_TR1_BETA_FUNCTION_TCC

34
contrib/sdk/sources/libstdc++-v3/include/tr1/ccomplex Normal file
View File

@@ -0,0 +1,34 @@
// TR1 ccomplex -*- C++ -*-
// Copyright (C) 2007-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/ccomplex
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CCOMPLEX
#define _GLIBCXX_TR1_CCOMPLEX 1
#include <tr1/complex>
#endif // _GLIBCXX_TR1_CCOMPLEX

49
contrib/sdk/sources/libstdc++-v3/include/tr1/cctype Normal file
View File

@@ -0,0 +1,49 @@
// TR1 cctype -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cctype
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CCTYPE
#define _GLIBCXX_TR1_CCTYPE 1
#include <bits/c++config.h>
#include <cctype>
#ifdef _GLIBCXX_USE_C99_CTYPE_TR1
#undef isblank
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
using ::isblank;
}
}
#endif
#endif // _GLIBCXX_TR1_CCTYPE

81
contrib/sdk/sources/libstdc++-v3/include/tr1/cfenv Normal file
View File

@@ -0,0 +1,81 @@
// TR1 cfenv -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cfenv
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CFENV
#define _GLIBCXX_TR1_CFENV 1
#pragma GCC system_header
#include <bits/c++config.h>
#if _GLIBCXX_HAVE_FENV_H
# include <fenv.h>
#endif
#ifdef _GLIBCXX_USE_C99_FENV_TR1
#undef feclearexcept
#undef fegetexceptflag
#undef feraiseexcept
#undef fesetexceptflag
#undef fetestexcept
#undef fegetround
#undef fesetround
#undef fegetenv
#undef feholdexcept
#undef fesetenv
#undef feupdateenv
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// types
using ::fenv_t;
using ::fexcept_t;
// functions
using ::feclearexcept;
using ::fegetexceptflag;
using ::feraiseexcept;
using ::fesetexceptflag;
using ::fetestexcept;
using ::fegetround;
using ::fesetround;
using ::fegetenv;
using ::feholdexcept;
using ::fesetenv;
using ::feupdateenv;
}
}
#endif // _GLIBCXX_USE_C99_FENV_TR1
#endif // _GLIBCXX_TR1_CFENV

42
contrib/sdk/sources/libstdc++-v3/include/tr1/cfloat Normal file
View File

@@ -0,0 +1,42 @@
// TR1 cfloat -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cfloat
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CFLOAT
#define _GLIBCXX_TR1_CFLOAT 1
#include <cfloat>
#ifndef DECIMAL_DIG
#define DECIMAL_DIG __DECIMAL_DIG__
#endif
#ifndef FLT_EVAL_METHOD
#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
#endif
#endif //_GLIBCXX_TR1_CFLOAT

84
contrib/sdk/sources/libstdc++-v3/include/tr1/cinttypes Normal file
View File

@@ -0,0 +1,84 @@
// TR1 cinttypes -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cinttypes
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CINTTYPES
#define _GLIBCXX_TR1_CINTTYPES 1
#pragma GCC system_header
#include <tr1/cstdint>
// For 8.11.1/1 (see C99, Note 184)
#if _GLIBCXX_HAVE_INTTYPES_H
# ifndef __STDC_FORMAT_MACROS
# define _UNDEF__STDC_FORMAT_MACROS
# define __STDC_FORMAT_MACROS
# endif
# include <inttypes.h>
# ifdef _UNDEF__STDC_FORMAT_MACROS
# undef __STDC_FORMAT_MACROS
# undef _UNDEF__STDC_FORMAT_MACROS
# endif
#endif
#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// types
using ::imaxdiv_t;
// functions
using ::imaxabs;
// May collide with _Longlong abs(_Longlong), and is not described
// anywhere outside the synopsis. Likely, a defect.
//
// intmax_t abs(intmax_t)
using ::imaxdiv;
// Likewise, with lldiv_t div(_Longlong, _Longlong).
//
// imaxdiv_t div(intmax_t, intmax_t)
using ::strtoimax;
using ::strtoumax;
#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1
using ::wcstoimax;
using ::wcstoumax;
#endif
}
}
#endif // _GLIBCXX_USE_C99_INTTYPES_TR1
#endif // _GLIBCXX_TR1_CINTTYPES

46
contrib/sdk/sources/libstdc++-v3/include/tr1/climits Normal file
View File

@@ -0,0 +1,46 @@
// TR1 climits -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/climits
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CLIMITS
#define _GLIBCXX_TR1_CLIMITS 1
#include <climits>
#ifndef LLONG_MIN
#define LLONG_MIN (-__LONG_LONG_MAX__ - 1)
#endif
#ifndef LLONG_MAX
#define LLONG_MAX __LONG_LONG_MAX__
#endif
#ifndef ULLONG_MAX
#define ULLONG_MAX (__LONG_LONG_MAX__ * 2ULL + 1)
#endif
#endif // _GLIBCXX_TR1_CLIMITS

1440
contrib/sdk/sources/libstdc++-v3/include/tr1/cmath Normal file
View File

File diff suppressed because it is too large Load Diff

418
contrib/sdk/sources/libstdc++-v3/include/tr1/complex Normal file
View File

@@ -0,0 +1,418 @@
// TR1 complex -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/complex
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_COMPLEX
#define _GLIBCXX_TR1_COMPLEX 1
#pragma GCC system_header
#include <complex>
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup complex_numbers
* @{
*/
#if __cplusplus >= 201103L
using std::acos;
using std::asin;
using std::atan;
#else
template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
#endif
template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
// The std::fabs return type in C++0x mode is different (just _Tp).
template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);
#if __cplusplus < 201103L
template<typename _Tp>
inline std::complex<_Tp>
__complex_acos(const std::complex<_Tp>& __z)
{
const std::complex<_Tp> __t = std::tr1::asin(__z);
const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
}
#if _GLIBCXX_USE_C99_COMPLEX_TR1
inline __complex__ float
__complex_acos(__complex__ float __z)
{ return __builtin_cacosf(__z); }
inline __complex__ double
__complex_acos(__complex__ double __z)
{ return __builtin_cacos(__z); }
inline __complex__ long double
__complex_acos(const __complex__ long double& __z)
{ return __builtin_cacosl(__z); }
template<typename _Tp>
inline std::complex<_Tp>
acos(const std::complex<_Tp>& __z)
{ return __complex_acos(__z.__rep()); }
#else
/// acos(__z) [8.1.2].
// Effects: Behaves the same as C99 function cacos, defined
// in subclause 7.3.5.1.
template<typename _Tp>
inline std::complex<_Tp>
acos(const std::complex<_Tp>& __z)
{ return __complex_acos(__z); }
#endif
template<typename _Tp>
inline std::complex<_Tp>
__complex_asin(const std::complex<_Tp>& __z)
{
std::complex<_Tp> __t(-__z.imag(), __z.real());
__t = std::tr1::asinh(__t);
return std::complex<_Tp>(__t.imag(), -__t.real());
}
#if _GLIBCXX_USE_C99_COMPLEX_TR1
inline __complex__ float
__complex_asin(__complex__ float __z)
{ return __builtin_casinf(__z); }
inline __complex__ double
__complex_asin(__complex__ double __z)
{ return __builtin_casin(__z); }
inline __complex__ long double
__complex_asin(const __complex__ long double& __z)
{ return __builtin_casinl(__z); }
template<typename _Tp>
inline std::complex<_Tp>
asin(const std::complex<_Tp>& __z)
{ return __complex_asin(__z.__rep()); }
#else
/// asin(__z) [8.1.3].
// Effects: Behaves the same as C99 function casin, defined
// in subclause 7.3.5.2.
template<typename _Tp>
inline std::complex<_Tp>
asin(const std::complex<_Tp>& __z)
{ return __complex_asin(__z); }
#endif
template<typename _Tp>
std::complex<_Tp>
__complex_atan(const std::complex<_Tp>& __z)
{
const _Tp __r2 = __z.real() * __z.real();
const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
_Tp __num = __z.imag() + _Tp(1.0);
_Tp __den = __z.imag() - _Tp(1.0);
__num = __r2 + __num * __num;
__den = __r2 + __den * __den;
return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
_Tp(0.25) * log(__num / __den));
}
#if _GLIBCXX_USE_C99_COMPLEX_TR1
inline __complex__ float
__complex_atan(__complex__ float __z)
{ return __builtin_catanf(__z); }
inline __complex__ double
__complex_atan(__complex__ double __z)
{ return __builtin_catan(__z); }
inline __complex__ long double
__complex_atan(const __complex__ long double& __z)
{ return __builtin_catanl(__z); }
template<typename _Tp>
inline std::complex<_Tp>
atan(const std::complex<_Tp>& __z)
{ return __complex_atan(__z.__rep()); }
#else
/// atan(__z) [8.1.4].
// Effects: Behaves the same as C99 function catan, defined
// in subclause 7.3.5.3.
template<typename _Tp>
inline std::complex<_Tp>
atan(const std::complex<_Tp>& __z)
{ return __complex_atan(__z); }
#endif
#endif // C++11
template<typename _Tp>
std::complex<_Tp>
__complex_acosh(const std::complex<_Tp>& __z)
{
// Kahan's formula.
return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
+ std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
}
#if _GLIBCXX_USE_C99_COMPLEX_TR1
inline __complex__ float
__complex_acosh(__complex__ float __z)
{ return __builtin_cacoshf(__z); }
inline __complex__ double
__complex_acosh(__complex__ double __z)
{ return __builtin_cacosh(__z); }
inline __complex__ long double
__complex_acosh(const __complex__ long double& __z)
{ return __builtin_cacoshl(__z); }
template<typename _Tp>
inline std::complex<_Tp>
acosh(const std::complex<_Tp>& __z)
{ return __complex_acosh(__z.__rep()); }
#else
/// acosh(__z) [8.1.5].
// Effects: Behaves the same as C99 function cacosh, defined
// in subclause 7.3.6.1.
template<typename _Tp>
inline std::complex<_Tp>
acosh(const std::complex<_Tp>& __z)
{ return __complex_acosh(__z); }
#endif
template<typename _Tp>
std::complex<_Tp>
__complex_asinh(const std::complex<_Tp>& __z)
{
std::complex<_Tp> __t((__z.real() - __z.imag())
* (__z.real() + __z.imag()) + _Tp(1.0),
_Tp(2.0) * __z.real() * __z.imag());
__t = std::sqrt(__t);
return std::log(__t + __z);
}
#if _GLIBCXX_USE_C99_COMPLEX_TR1
inline __complex__ float
__complex_asinh(__complex__ float __z)
{ return __builtin_casinhf(__z); }
inline __complex__ double
__complex_asinh(__complex__ double __z)
{ return __builtin_casinh(__z); }
inline __complex__ long double
__complex_asinh(const __complex__ long double& __z)
{ return __builtin_casinhl(__z); }
template<typename _Tp>
inline std::complex<_Tp>
asinh(const std::complex<_Tp>& __z)
{ return __complex_asinh(__z.__rep()); }
#else
/// asinh(__z) [8.1.6].
// Effects: Behaves the same as C99 function casin, defined
// in subclause 7.3.6.2.
template<typename _Tp>
inline std::complex<_Tp>
asinh(const std::complex<_Tp>& __z)
{ return __complex_asinh(__z); }
#endif
template<typename _Tp>
std::complex<_Tp>
__complex_atanh(const std::complex<_Tp>& __z)
{
const _Tp __i2 = __z.imag() * __z.imag();
const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
_Tp __num = _Tp(1.0) + __z.real();
_Tp __den = _Tp(1.0) - __z.real();
__num = __i2 + __num * __num;
__den = __i2 + __den * __den;
return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
_Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
}
#if _GLIBCXX_USE_C99_COMPLEX_TR1
inline __complex__ float
__complex_atanh(__complex__ float __z)
{ return __builtin_catanhf(__z); }
inline __complex__ double
__complex_atanh(__complex__ double __z)
{ return __builtin_catanh(__z); }
inline __complex__ long double
__complex_atanh(const __complex__ long double& __z)
{ return __builtin_catanhl(__z); }
template<typename _Tp>
inline std::complex<_Tp>
atanh(const std::complex<_Tp>& __z)
{ return __complex_atanh(__z.__rep()); }
#else
/// atanh(__z) [8.1.7].
// Effects: Behaves the same as C99 function catanh, defined
// in subclause 7.3.6.3.
template<typename _Tp>
inline std::complex<_Tp>
atanh(const std::complex<_Tp>& __z)
{ return __complex_atanh(__z); }
#endif
template<typename _Tp>
inline std::complex<_Tp>
/// fabs(__z) [8.1.8].
// Effects: Behaves the same as C99 function cabs, defined
// in subclause 7.3.8.1.
fabs(const std::complex<_Tp>& __z)
{ return std::abs(__z); }
/// Additional overloads [8.1.9].
#if __cplusplus < 201103L
template<typename _Tp>
inline typename __gnu_cxx::__promote<_Tp>::__type
arg(_Tp __x)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
: __type();
#else
return std::arg(std::complex<__type>(__x));
#endif
}
template<typename _Tp>
inline typename __gnu_cxx::__promote<_Tp>::__type
imag(_Tp)
{ return _Tp(); }
template<typename _Tp>
inline typename __gnu_cxx::__promote<_Tp>::__type
norm(_Tp __x)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __type(__x) * __type(__x);
}
template<typename _Tp>
inline typename __gnu_cxx::__promote<_Tp>::__type
real(_Tp __x)
{ return __x; }
#endif
template<typename _Tp, typename _Up>
inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
pow(const std::complex<_Tp>& __x, const _Up& __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return std::pow(std::complex<__type>(__x), __type(__y));
}
template<typename _Tp, typename _Up>
inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
pow(const _Tp& __x, const std::complex<_Up>& __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return std::pow(__type(__x), std::complex<__type>(__y));
}
template<typename _Tp, typename _Up>
inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return std::pow(std::complex<__type>(__x),
std::complex<__type>(__y));
}
using std::arg;
template<typename _Tp>
inline std::complex<_Tp>
conj(const std::complex<_Tp>& __z)
{ return std::conj(__z); }
template<typename _Tp>
inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
conj(_Tp __x)
{ return __x; }
using std::imag;
using std::norm;
using std::polar;
template<typename _Tp, typename _Up>
inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
polar(const _Tp& __rho, const _Up& __theta)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return std::polar(__type(__rho), __type(__theta));
}
using std::real;
template<typename _Tp>
inline std::complex<_Tp>
pow(const std::complex<_Tp>& __x, const _Tp& __y)
{ return std::pow(__x, __y); }
template<typename _Tp>
inline std::complex<_Tp>
pow(const _Tp& __x, const std::complex<_Tp>& __y)
{ return std::pow(__x, __y); }
template<typename _Tp>
inline std::complex<_Tp>
pow(const std::complex<_Tp>& __x, const std::complex<_Tp>& __y)
{ return std::pow(__x, __y); }
// @} group complex_numbers
_GLIBCXX_END_NAMESPACE_VERSION
}
}
#endif // _GLIBCXX_TR1_COMPLEX

34
contrib/sdk/sources/libstdc++-v3/include/tr1/complex.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 complex.h -*- C++ -*-
// Copyright (C) 2007-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/complex.h
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_COMPLEX_H
#define _GLIBCXX_TR1_COMPLEX_H 1
#include <tr1/ccomplex>
#endif // _GLIBCXX_TR1_COMPLEX_H

34
contrib/sdk/sources/libstdc++-v3/include/tr1/cstdarg Normal file
View File

@@ -0,0 +1,34 @@
// TR1 cstdarg -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cstdarg
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CSTDARG
#define _GLIBCXX_TR1_CSTDARG 1
#include <cstdarg>
#endif // _GLIBCXX_TR1_CSTDARG

40
contrib/sdk/sources/libstdc++-v3/include/tr1/cstdbool Normal file
View File

@@ -0,0 +1,40 @@
// TR1 cstdbool -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cstdbool
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CSTDBOOL
#define _GLIBCXX_TR1_CSTDBOOL 1
#pragma GCC system_header
#include <bits/c++config.h>
#if _GLIBCXX_HAVE_STDBOOL_H
#include <stdbool.h>
#endif
#endif // _GLIBCXX_TR1_CSTDBOOL

104
contrib/sdk/sources/libstdc++-v3/include/tr1/cstdint Normal file
View File

@@ -0,0 +1,104 @@
// TR1 cstdint -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cstdint
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CSTDINT
#define _GLIBCXX_TR1_CSTDINT 1
#pragma GCC system_header
#include <bits/c++config.h>
// For 8.22.1/1 (see C99, Notes 219, 220, 222)
# if _GLIBCXX_HAVE_STDINT_H
# ifndef __STDC_LIMIT_MACROS
# define _UNDEF__STDC_LIMIT_MACROS
# define __STDC_LIMIT_MACROS
# endif
# ifndef __STDC_CONSTANT_MACROS
# define _UNDEF__STDC_CONSTANT_MACROS
# define __STDC_CONSTANT_MACROS
# endif
# include <stdint.h>
# ifdef _UNDEF__STDC_LIMIT_MACROS
# undef __STDC_LIMIT_MACROS
# undef _UNDEF__STDC_LIMIT_MACROS
# endif
# ifdef _UNDEF__STDC_CONSTANT_MACROS
# undef __STDC_CONSTANT_MACROS
# undef _UNDEF__STDC_CONSTANT_MACROS
# endif
# endif
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
using ::int8_t;
using ::int16_t;
using ::int32_t;
using ::int64_t;
using ::int_fast8_t;
using ::int_fast16_t;
using ::int_fast32_t;
using ::int_fast64_t;
using ::int_least8_t;
using ::int_least16_t;
using ::int_least32_t;
using ::int_least64_t;
using ::intmax_t;
using ::intptr_t;
using ::uint8_t;
using ::uint16_t;
using ::uint32_t;
using ::uint64_t;
using ::uint_fast8_t;
using ::uint_fast16_t;
using ::uint_fast32_t;
using ::uint_fast64_t;
using ::uint_least8_t;
using ::uint_least16_t;
using ::uint_least32_t;
using ::uint_least64_t;
using ::uintmax_t;
using ::uintptr_t;
}
}
#endif // _GLIBCXX_USE_C99_STDINT_TR1
#endif // _GLIBCXX_TR1_CSTDINT

53
contrib/sdk/sources/libstdc++-v3/include/tr1/cstdio Normal file
View File

@@ -0,0 +1,53 @@
// TR1 cstdio -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cstdio
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CSTDIO
#define _GLIBCXX_TR1_CSTDIO 1
#pragma GCC system_header
#include <cstdio>
#if _GLIBCXX_USE_C99
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
using std::snprintf;
using std::vsnprintf;
using std::vfscanf;
using std::vscanf;
using std::vsscanf;
}
}
#endif
#endif // _GLIBCXX_TR1_CSTDIO

72
contrib/sdk/sources/libstdc++-v3/include/tr1/cstdlib Normal file
View File

@@ -0,0 +1,72 @@
// TR1 cstdlib -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cstdlib
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CSTDLIB
#define _GLIBCXX_TR1_CSTDLIB 1
#pragma GCC system_header
#include <cstdlib>
#if _GLIBCXX_HOSTED
#if _GLIBCXX_USE_C99
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
// types
using std::lldiv_t;
// functions
using std::llabs;
using std::lldiv;
#endif
using std::atoll;
using std::strtoll;
using std::strtoull;
using std::strtof;
using std::strtold;
// overloads
using std::abs;
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using std::div;
#endif
}
}
#endif // _GLIBCXX_USE_C99
#endif // _GLIBCXX_HOSTED
#endif // _GLIBCXX_TR1_CSTDLIB

34
contrib/sdk/sources/libstdc++-v3/include/tr1/ctgmath Normal file
View File

@@ -0,0 +1,34 @@
// TR1 ctgmath -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/ctgmath
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CTGMATH
#define _GLIBCXX_TR1_CTGMATH 1
#include <tr1/cmath>
#endif // _GLIBCXX_TR1_CTGMATH

34
contrib/sdk/sources/libstdc++-v3/include/tr1/ctime Normal file
View File

@@ -0,0 +1,34 @@
// TR1 ctime -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/ctime
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CTIME
#define _GLIBCXX_TR1_CTIME 1
#include <ctime>
#endif // _GLIBCXX_TR1_CTIME

34
contrib/sdk/sources/libstdc++-v3/include/tr1/ctype.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 ctype.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/ctype.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_CTYPE_H
#define _TR1_CTYPE_H 1
#include <tr1/cctype>
#endif

65
contrib/sdk/sources/libstdc++-v3/include/tr1/cwchar Normal file
View File

@@ -0,0 +1,65 @@
// TR1 cwchar -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cwchar
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CWCHAR
#define _GLIBCXX_TR1_CWCHAR 1
#pragma GCC system_header
#include <cwchar>
#ifdef _GLIBCXX_USE_WCHAR_T
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#if _GLIBCXX_HAVE_WCSTOF
using std::wcstof;
#endif
#if _GLIBCXX_HAVE_VFWSCANF
using std::vfwscanf;
#endif
#if _GLIBCXX_HAVE_VSWSCANF
using std::vswscanf;
#endif
#if _GLIBCXX_HAVE_VWSCANF
using std::vwscanf;
#endif
#if _GLIBCXX_USE_C99
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
#endif
}
}
#endif // _GLIBCXX_USE_WCHAR_T
#endif // _GLIBCXX_TR1_CWCHAR

50
contrib/sdk/sources/libstdc++-v3/include/tr1/cwctype Normal file
View File

@@ -0,0 +1,50 @@
// TR1 cwctype -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/cwctype
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_CWCTYPE
#define _GLIBCXX_TR1_CWCTYPE 1
#pragma GCC system_header
#include <cwctype>
#ifdef _GLIBCXX_USE_WCHAR_T
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#if _GLIBCXX_HAVE_ISWBLANK
using std::iswblank;
#endif
}
}
#endif // _GLIBCXX_USE_WCHAR_T
#endif // _GLIBCXX_TR1_CWCTYPE

750
contrib/sdk/sources/libstdc++-v3/include/tr1/ell_integral.tcc Normal file
View File

@@ -0,0 +1,750 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/ell_integral.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on:
// (1) B. C. Carlson Numer. Math. 33, 1 (1979)
// (2) B. C. Carlson, Special Functions of Applied Mathematics (1977)
// (3) The Gnu Scientific Library, http://www.gnu.org/software/gsl
// (4) Numerical Recipes in C, 2nd ed, by W. H. Press, S. A. Teukolsky,
// W. T. Vetterling, B. P. Flannery, Cambridge University Press
// (1992), pp. 261-269
#ifndef _GLIBCXX_TR1_ELL_INTEGRAL_TCC
#define _GLIBCXX_TR1_ELL_INTEGRAL_TCC 1
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Return the Carlson elliptic function @f$ R_F(x,y,z) @f$
* of the first kind.
*
* The Carlson elliptic function of the first kind is defined by:
* @f[
* R_F(x,y,z) = \frac{1}{2} \int_0^\infty
* \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{1/2}}
* @f]
*
* @param __x The first of three symmetric arguments.
* @param __y The second of three symmetric arguments.
* @param __z The third of three symmetric arguments.
* @return The Carlson elliptic function of the first kind.
*/
template<typename _Tp>
_Tp
__ellint_rf(_Tp __x, _Tp __y, _Tp __z)
{
const _Tp __min = std::numeric_limits<_Tp>::min();
const _Tp __max = std::numeric_limits<_Tp>::max();
const _Tp __lolim = _Tp(5) * __min;
const _Tp __uplim = __max / _Tp(5);
if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
std::__throw_domain_error(__N("Argument less than zero "
"in __ellint_rf."));
else if (__x + __y < __lolim || __x + __z < __lolim
|| __y + __z < __lolim)
std::__throw_domain_error(__N("Argument too small in __ellint_rf"));
else
{
const _Tp __c0 = _Tp(1) / _Tp(4);
const _Tp __c1 = _Tp(1) / _Tp(24);
const _Tp __c2 = _Tp(1) / _Tp(10);
const _Tp __c3 = _Tp(3) / _Tp(44);
const _Tp __c4 = _Tp(1) / _Tp(14);
_Tp __xn = __x;
_Tp __yn = __y;
_Tp __zn = __z;
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6));
_Tp __mu;
_Tp __xndev, __yndev, __zndev;
const unsigned int __max_iter = 100;
for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
{
__mu = (__xn + __yn + __zn) / _Tp(3);
__xndev = 2 - (__mu + __xn) / __mu;
__yndev = 2 - (__mu + __yn) / __mu;
__zndev = 2 - (__mu + __zn) / __mu;
_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
__epsilon = std::max(__epsilon, std::abs(__zndev));
if (__epsilon < __errtol)
break;
const _Tp __xnroot = std::sqrt(__xn);
const _Tp __ynroot = std::sqrt(__yn);
const _Tp __znroot = std::sqrt(__zn);
const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+ __ynroot * __znroot;
__xn = __c0 * (__xn + __lambda);
__yn = __c0 * (__yn + __lambda);
__zn = __c0 * (__zn + __lambda);
}
const _Tp __e2 = __xndev * __yndev - __zndev * __zndev;
const _Tp __e3 = __xndev * __yndev * __zndev;
const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2
+ __c4 * __e3;
return __s / std::sqrt(__mu);
}
}
/**
* @brief Return the complete elliptic integral of the first kind
* @f$ K(k) @f$ by series expansion.
*
* The complete elliptic integral of the first kind is defined as
* @f[
* K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta}
* {\sqrt{1 - k^2sin^2\theta}}
* @f]
*
* This routine is not bad as long as |k| is somewhat smaller than 1
* but is not is good as the Carlson elliptic integral formulation.
*
* @param __k The argument of the complete elliptic function.
* @return The complete elliptic function of the first kind.
*/
template<typename _Tp>
_Tp
__comp_ellint_1_series(_Tp __k)
{
const _Tp __kk = __k * __k;
_Tp __term = __kk / _Tp(4);
_Tp __sum = _Tp(1) + __term;
const unsigned int __max_iter = 1000;
for (unsigned int __i = 2; __i < __max_iter; ++__i)
{
__term *= (2 * __i - 1) * __kk / (2 * __i);
if (__term < std::numeric_limits<_Tp>::epsilon())
break;
__sum += __term;
}
return __numeric_constants<_Tp>::__pi_2() * __sum;
}
/**
* @brief Return the complete elliptic integral of the first kind
* @f$ K(k) @f$ using the Carlson formulation.
*
* The complete elliptic integral of the first kind is defined as
* @f[
* K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta}
* {\sqrt{1 - k^2 sin^2\theta}}
* @f]
* where @f$ F(k,\phi) @f$ is the incomplete elliptic integral of the
* first kind.
*
* @param __k The argument of the complete elliptic function.
* @return The complete elliptic function of the first kind.
*/
template<typename _Tp>
_Tp
__comp_ellint_1(_Tp __k)
{
if (__isnan(__k))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (std::abs(__k) >= _Tp(1))
return std::numeric_limits<_Tp>::quiet_NaN();
else
return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
}
/**
* @brief Return the incomplete elliptic integral of the first kind
* @f$ F(k,\phi) @f$ using the Carlson formulation.
*
* The incomplete elliptic integral of the first kind is defined as
* @f[
* F(k,\phi) = \int_0^{\phi}\frac{d\theta}
* {\sqrt{1 - k^2 sin^2\theta}}
* @f]
*
* @param __k The argument of the elliptic function.
* @param __phi The integral limit argument of the elliptic function.
* @return The elliptic function of the first kind.
*/
template<typename _Tp>
_Tp
__ellint_1(_Tp __k, _Tp __phi)
{
if (__isnan(__k) || __isnan(__phi))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (std::abs(__k) > _Tp(1))
std::__throw_domain_error(__N("Bad argument in __ellint_1."));
else
{
// Reduce phi to -pi/2 < phi < +pi/2.
const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+ _Tp(0.5L));
const _Tp __phi_red = __phi
- __n * __numeric_constants<_Tp>::__pi();
const _Tp __s = std::sin(__phi_red);
const _Tp __c = std::cos(__phi_red);
const _Tp __F = __s
* __ellint_rf(__c * __c,
_Tp(1) - __k * __k * __s * __s, _Tp(1));
if (__n == 0)
return __F;
else
return __F + _Tp(2) * __n * __comp_ellint_1(__k);
}
}
/**
* @brief Return the complete elliptic integral of the second kind
* @f$ E(k) @f$ by series expansion.
*
* The complete elliptic integral of the second kind is defined as
* @f[
* E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta}
* @f]
*
* This routine is not bad as long as |k| is somewhat smaller than 1
* but is not is good as the Carlson elliptic integral formulation.
*
* @param __k The argument of the complete elliptic function.
* @return The complete elliptic function of the second kind.
*/
template<typename _Tp>
_Tp
__comp_ellint_2_series(_Tp __k)
{
const _Tp __kk = __k * __k;
_Tp __term = __kk;
_Tp __sum = __term;
const unsigned int __max_iter = 1000;
for (unsigned int __i = 2; __i < __max_iter; ++__i)
{
const _Tp __i2m = 2 * __i - 1;
const _Tp __i2 = 2 * __i;
__term *= __i2m * __i2m * __kk / (__i2 * __i2);
if (__term < std::numeric_limits<_Tp>::epsilon())
break;
__sum += __term / __i2m;
}
return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
}
/**
* @brief Return the Carlson elliptic function of the second kind
* @f$ R_D(x,y,z) = R_J(x,y,z,z) @f$ where
* @f$ R_J(x,y,z,p) @f$ is the Carlson elliptic function
* of the third kind.
*
* The Carlson elliptic function of the second kind is defined by:
* @f[
* R_D(x,y,z) = \frac{3}{2} \int_0^\infty
* \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{3/2}}
* @f]
*
* Based on Carlson's algorithms:
* - B. C. Carlson Numer. Math. 33, 1 (1979)
* - B. C. Carlson, Special Functions of Applied Mathematics (1977)
* - Numerical Recipes in C, 2nd ed, pp. 261-269,
* by Press, Teukolsky, Vetterling, Flannery (1992)
*
* @param __x The first of two symmetric arguments.
* @param __y The second of two symmetric arguments.
* @param __z The third argument.
* @return The Carlson elliptic function of the second kind.
*/
template<typename _Tp>
_Tp
__ellint_rd(_Tp __x, _Tp __y, _Tp __z)
{
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
const _Tp __min = std::numeric_limits<_Tp>::min();
const _Tp __max = std::numeric_limits<_Tp>::max();
const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3));
const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3));
if (__x < _Tp(0) || __y < _Tp(0))
std::__throw_domain_error(__N("Argument less than zero "
"in __ellint_rd."));
else if (__x + __y < __lolim || __z < __lolim)
std::__throw_domain_error(__N("Argument too small "
"in __ellint_rd."));
else
{
const _Tp __c0 = _Tp(1) / _Tp(4);
const _Tp __c1 = _Tp(3) / _Tp(14);
const _Tp __c2 = _Tp(1) / _Tp(6);
const _Tp __c3 = _Tp(9) / _Tp(22);
const _Tp __c4 = _Tp(3) / _Tp(26);
_Tp __xn = __x;
_Tp __yn = __y;
_Tp __zn = __z;
_Tp __sigma = _Tp(0);
_Tp __power4 = _Tp(1);
_Tp __mu;
_Tp __xndev, __yndev, __zndev;
const unsigned int __max_iter = 100;
for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
{
__mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5);
__xndev = (__mu - __xn) / __mu;
__yndev = (__mu - __yn) / __mu;
__zndev = (__mu - __zn) / __mu;
_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
__epsilon = std::max(__epsilon, std::abs(__zndev));
if (__epsilon < __errtol)
break;
_Tp __xnroot = std::sqrt(__xn);
_Tp __ynroot = std::sqrt(__yn);
_Tp __znroot = std::sqrt(__zn);
_Tp __lambda = __xnroot * (__ynroot + __znroot)
+ __ynroot * __znroot;
__sigma += __power4 / (__znroot * (__zn + __lambda));
__power4 *= __c0;
__xn = __c0 * (__xn + __lambda);
__yn = __c0 * (__yn + __lambda);
__zn = __c0 * (__zn + __lambda);
}
// Note: __ea is an SPU badname.
_Tp __eaa = __xndev * __yndev;
_Tp __eb = __zndev * __zndev;
_Tp __ec = __eaa - __eb;
_Tp __ed = __eaa - _Tp(6) * __eb;
_Tp __ef = __ed + __ec + __ec;
_Tp __s1 = __ed * (-__c1 + __c3 * __ed
/ _Tp(3) - _Tp(3) * __c4 * __zndev * __ef
/ _Tp(2));
_Tp __s2 = __zndev
* (__c2 * __ef
+ __zndev * (-__c3 * __ec - __zndev * __c4 - __eaa));
return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2)
/ (__mu * std::sqrt(__mu));
}
}
/**
* @brief Return the complete elliptic integral of the second kind
* @f$ E(k) @f$ using the Carlson formulation.
*
* The complete elliptic integral of the second kind is defined as
* @f[
* E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta}
* @f]
*
* @param __k The argument of the complete elliptic function.
* @return The complete elliptic function of the second kind.
*/
template<typename _Tp>
_Tp
__comp_ellint_2(_Tp __k)
{
if (__isnan(__k))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (std::abs(__k) == 1)
return _Tp(1);
else if (std::abs(__k) > _Tp(1))
std::__throw_domain_error(__N("Bad argument in __comp_ellint_2."));
else
{
const _Tp __kk = __k * __k;
return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
- __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3);
}
}
/**
* @brief Return the incomplete elliptic integral of the second kind
* @f$ E(k,\phi) @f$ using the Carlson formulation.
*
* The incomplete elliptic integral of the second kind is defined as
* @f[
* E(k,\phi) = \int_0^{\phi} \sqrt{1 - k^2 sin^2\theta}
* @f]
*
* @param __k The argument of the elliptic function.
* @param __phi The integral limit argument of the elliptic function.
* @return The elliptic function of the second kind.
*/
template<typename _Tp>
_Tp
__ellint_2(_Tp __k, _Tp __phi)
{
if (__isnan(__k) || __isnan(__phi))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (std::abs(__k) > _Tp(1))
std::__throw_domain_error(__N("Bad argument in __ellint_2."));
else
{
// Reduce phi to -pi/2 < phi < +pi/2.
const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+ _Tp(0.5L));
const _Tp __phi_red = __phi
- __n * __numeric_constants<_Tp>::__pi();
const _Tp __kk = __k * __k;
const _Tp __s = std::sin(__phi_red);
const _Tp __ss = __s * __s;
const _Tp __sss = __ss * __s;
const _Tp __c = std::cos(__phi_red);
const _Tp __cc = __c * __c;
const _Tp __E = __s
* __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
- __kk * __sss
* __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1))
/ _Tp(3);
if (__n == 0)
return __E;
else
return __E + _Tp(2) * __n * __comp_ellint_2(__k);
}
}
/**
* @brief Return the Carlson elliptic function
* @f$ R_C(x,y) = R_F(x,y,y) @f$ where @f$ R_F(x,y,z) @f$
* is the Carlson elliptic function of the first kind.
*
* The Carlson elliptic function is defined by:
* @f[
* R_C(x,y) = \frac{1}{2} \int_0^\infty
* \frac{dt}{(t + x)^{1/2}(t + y)}
* @f]
*
* Based on Carlson's algorithms:
* - B. C. Carlson Numer. Math. 33, 1 (1979)
* - B. C. Carlson, Special Functions of Applied Mathematics (1977)
* - Numerical Recipes in C, 2nd ed, pp. 261-269,
* by Press, Teukolsky, Vetterling, Flannery (1992)
*
* @param __x The first argument.
* @param __y The second argument.
* @return The Carlson elliptic function.
*/
template<typename _Tp>
_Tp
__ellint_rc(_Tp __x, _Tp __y)
{
const _Tp __min = std::numeric_limits<_Tp>::min();
const _Tp __max = std::numeric_limits<_Tp>::max();
const _Tp __lolim = _Tp(5) * __min;
const _Tp __uplim = __max / _Tp(5);
if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim)
std::__throw_domain_error(__N("Argument less than zero "
"in __ellint_rc."));
else
{
const _Tp __c0 = _Tp(1) / _Tp(4);
const _Tp __c1 = _Tp(1) / _Tp(7);
const _Tp __c2 = _Tp(9) / _Tp(22);
const _Tp __c3 = _Tp(3) / _Tp(10);
const _Tp __c4 = _Tp(3) / _Tp(8);
_Tp __xn = __x;
_Tp __yn = __y;
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6));
_Tp __mu;
_Tp __sn;
const unsigned int __max_iter = 100;
for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
{
__mu = (__xn + _Tp(2) * __yn) / _Tp(3);
__sn = (__yn + __mu) / __mu - _Tp(2);
if (std::abs(__sn) < __errtol)
break;
const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn)
+ __yn;
__xn = __c0 * (__xn + __lambda);
__yn = __c0 * (__yn + __lambda);
}
_Tp __s = __sn * __sn
* (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2)));
return (_Tp(1) + __s) / std::sqrt(__mu);
}
}
/**
* @brief Return the Carlson elliptic function @f$ R_J(x,y,z,p) @f$
* of the third kind.
*
* The Carlson elliptic function of the third kind is defined by:
* @f[
* R_J(x,y,z,p) = \frac{3}{2} \int_0^\infty
* \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{1/2}(t + p)}
* @f]
*
* Based on Carlson's algorithms:
* - B. C. Carlson Numer. Math. 33, 1 (1979)
* - B. C. Carlson, Special Functions of Applied Mathematics (1977)
* - Numerical Recipes in C, 2nd ed, pp. 261-269,
* by Press, Teukolsky, Vetterling, Flannery (1992)
*
* @param __x The first of three symmetric arguments.
* @param __y The second of three symmetric arguments.
* @param __z The third of three symmetric arguments.
* @param __p The fourth argument.
* @return The Carlson elliptic function of the fourth kind.
*/
template<typename _Tp>
_Tp
__ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p)
{
const _Tp __min = std::numeric_limits<_Tp>::min();
const _Tp __max = std::numeric_limits<_Tp>::max();
const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3));
const _Tp __uplim = _Tp(0.3L)
* std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3));
if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
std::__throw_domain_error(__N("Argument less than zero "
"in __ellint_rj."));
else if (__x + __y < __lolim || __x + __z < __lolim
|| __y + __z < __lolim || __p < __lolim)
std::__throw_domain_error(__N("Argument too small "
"in __ellint_rj"));
else
{
const _Tp __c0 = _Tp(1) / _Tp(4);
const _Tp __c1 = _Tp(3) / _Tp(14);
const _Tp __c2 = _Tp(1) / _Tp(3);
const _Tp __c3 = _Tp(3) / _Tp(22);
const _Tp __c4 = _Tp(3) / _Tp(26);
_Tp __xn = __x;
_Tp __yn = __y;
_Tp __zn = __z;
_Tp __pn = __p;
_Tp __sigma = _Tp(0);
_Tp __power4 = _Tp(1);
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
_Tp __lambda, __mu;
_Tp __xndev, __yndev, __zndev, __pndev;
const unsigned int __max_iter = 100;
for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
{
__mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5);
__xndev = (__mu - __xn) / __mu;
__yndev = (__mu - __yn) / __mu;
__zndev = (__mu - __zn) / __mu;
__pndev = (__mu - __pn) / __mu;
_Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
__epsilon = std::max(__epsilon, std::abs(__zndev));
__epsilon = std::max(__epsilon, std::abs(__pndev));
if (__epsilon < __errtol)
break;
const _Tp __xnroot = std::sqrt(__xn);
const _Tp __ynroot = std::sqrt(__yn);
const _Tp __znroot = std::sqrt(__zn);
const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+ __ynroot * __znroot;
const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
+ __xnroot * __ynroot * __znroot;
const _Tp __alpha2 = __alpha1 * __alpha1;
const _Tp __beta = __pn * (__pn + __lambda)
* (__pn + __lambda);
__sigma += __power4 * __ellint_rc(__alpha2, __beta);
__power4 *= __c0;
__xn = __c0 * (__xn + __lambda);
__yn = __c0 * (__yn + __lambda);
__zn = __c0 * (__zn + __lambda);
__pn = __c0 * (__pn + __lambda);
}
// Note: __ea is an SPU badname.
_Tp __eaa = __xndev * (__yndev + __zndev) + __yndev * __zndev;
_Tp __eb = __xndev * __yndev * __zndev;
_Tp __ec = __pndev * __pndev;
_Tp __e2 = __eaa - _Tp(3) * __ec;
_Tp __e3 = __eb + _Tp(2) * __pndev * (__eaa - __ec);
_Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4)
- _Tp(3) * __c4 * __e3 / _Tp(2));
_Tp __s2 = __eb * (__c2 / _Tp(2)
+ __pndev * (-__c3 - __c3 + __pndev * __c4));
_Tp __s3 = __pndev * __eaa * (__c2 - __pndev * __c3)
- __c2 * __pndev * __ec;
return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3)
/ (__mu * std::sqrt(__mu));
}
}
/**
* @brief Return the complete elliptic integral of the third kind
* @f$ \Pi(k,\nu) = \Pi(k,\nu,\pi/2) @f$ using the
* Carlson formulation.
*
* The complete elliptic integral of the third kind is defined as
* @f[
* \Pi(k,\nu) = \int_0^{\pi/2}
* \frac{d\theta}
* {(1 - \nu \sin^2\theta)\sqrt{1 - k^2 \sin^2\theta}}
* @f]
*
* @param __k The argument of the elliptic function.
* @param __nu The second argument of the elliptic function.
* @return The complete elliptic function of the third kind.
*/
template<typename _Tp>
_Tp
__comp_ellint_3(_Tp __k, _Tp __nu)
{
if (__isnan(__k) || __isnan(__nu))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__nu == _Tp(1))
return std::numeric_limits<_Tp>::infinity();
else if (std::abs(__k) > _Tp(1))
std::__throw_domain_error(__N("Bad argument in __comp_ellint_3."));
else
{
const _Tp __kk = __k * __k;
return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
- __nu
* __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) + __nu)
/ _Tp(3);
}
}
/**
* @brief Return the incomplete elliptic integral of the third kind
* @f$ \Pi(k,\nu,\phi) @f$ using the Carlson formulation.
*
* The incomplete elliptic integral of the third kind is defined as
* @f[
* \Pi(k,\nu,\phi) = \int_0^{\phi}
* \frac{d\theta}
* {(1 - \nu \sin^2\theta)
* \sqrt{1 - k^2 \sin^2\theta}}
* @f]
*
* @param __k The argument of the elliptic function.
* @param __nu The second argument of the elliptic function.
* @param __phi The integral limit argument of the elliptic function.
* @return The elliptic function of the third kind.
*/
template<typename _Tp>
_Tp
__ellint_3(_Tp __k, _Tp __nu, _Tp __phi)
{
if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (std::abs(__k) > _Tp(1))
std::__throw_domain_error(__N("Bad argument in __ellint_3."));
else
{
// Reduce phi to -pi/2 < phi < +pi/2.
const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+ _Tp(0.5L));
const _Tp __phi_red = __phi
- __n * __numeric_constants<_Tp>::__pi();
const _Tp __kk = __k * __k;
const _Tp __s = std::sin(__phi_red);
const _Tp __ss = __s * __s;
const _Tp __sss = __ss * __s;
const _Tp __c = std::cos(__phi_red);
const _Tp __cc = __c * __c;
const _Tp __Pi = __s
* __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
- __nu * __sss
* __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
_Tp(1) + __nu * __ss) / _Tp(3);
if (__n == 0)
return __Pi;
else
return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
}
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_ELL_INTEGRAL_TCC

526
contrib/sdk/sources/libstdc++-v3/include/tr1/exp_integral.tcc Normal file
View File

@@ -0,0 +1,526 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/exp_integral.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on:
//
// (1) Handbook of Mathematical Functions,
// Ed. by Milton Abramowitz and Irene A. Stegun,
// Dover Publications, New-York, Section 5, pp. 228-251.
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
// (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 222-225.
//
#ifndef _GLIBCXX_TR1_EXP_INTEGRAL_TCC
#define _GLIBCXX_TR1_EXP_INTEGRAL_TCC 1
#include "special_function_util.h"
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> _Tp __expint_E1(_Tp);
/**
* @brief Return the exponential integral @f$ E_1(x) @f$
* by series summation. This should be good
* for @f$ x < 1 @f$.
*
* The exponential integral is given by
* \f[
* E_1(x) = \int_{1}^{\infty} \frac{e^{-xt}}{t} dt
* \f]
*
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_E1_series(_Tp __x)
{
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
_Tp __term = _Tp(1);
_Tp __esum = _Tp(0);
_Tp __osum = _Tp(0);
const unsigned int __max_iter = 100;
for (unsigned int __i = 1; __i < __max_iter; ++__i)
{
__term *= - __x / __i;
if (std::abs(__term) < __eps)
break;
if (__term >= _Tp(0))
__esum += __term / __i;
else
__osum += __term / __i;
}
return - __esum - __osum
- __numeric_constants<_Tp>::__gamma_e() - std::log(__x);
}
/**
* @brief Return the exponential integral @f$ E_1(x) @f$
* by asymptotic expansion.
*
* The exponential integral is given by
* \f[
* E_1(x) = \int_{1}^\infty \frac{e^{-xt}}{t} dt
* \f]
*
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_E1_asymp(_Tp __x)
{
_Tp __term = _Tp(1);
_Tp __esum = _Tp(1);
_Tp __osum = _Tp(0);
const unsigned int __max_iter = 1000;
for (unsigned int __i = 1; __i < __max_iter; ++__i)
{
_Tp __prev = __term;
__term *= - __i / __x;
if (std::abs(__term) > std::abs(__prev))
break;
if (__term >= _Tp(0))
__esum += __term;
else
__osum += __term;
}
return std::exp(- __x) * (__esum + __osum) / __x;
}
/**
* @brief Return the exponential integral @f$ E_n(x) @f$
* by series summation.
*
* The exponential integral is given by
* \f[
* E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
* \f]
*
* @param __n The order of the exponential integral function.
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_En_series(unsigned int __n, _Tp __x)
{
const unsigned int __max_iter = 100;
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const int __nm1 = __n - 1;
_Tp __ans = (__nm1 != 0
? _Tp(1) / __nm1 : -std::log(__x)
- __numeric_constants<_Tp>::__gamma_e());
_Tp __fact = _Tp(1);
for (int __i = 1; __i <= __max_iter; ++__i)
{
__fact *= -__x / _Tp(__i);
_Tp __del;
if ( __i != __nm1 )
__del = -__fact / _Tp(__i - __nm1);
else
{
_Tp __psi = -__numeric_constants<_Tp>::gamma_e();
for (int __ii = 1; __ii <= __nm1; ++__ii)
__psi += _Tp(1) / _Tp(__ii);
__del = __fact * (__psi - std::log(__x));
}
__ans += __del;
if (std::abs(__del) < __eps * std::abs(__ans))
return __ans;
}
std::__throw_runtime_error(__N("Series summation failed "
"in __expint_En_series."));
}
/**
* @brief Return the exponential integral @f$ E_n(x) @f$
* by continued fractions.
*
* The exponential integral is given by
* \f[
* E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
* \f]
*
* @param __n The order of the exponential integral function.
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_En_cont_frac(unsigned int __n, _Tp __x)
{
const unsigned int __max_iter = 100;
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __fp_min = std::numeric_limits<_Tp>::min();
const int __nm1 = __n - 1;
_Tp __b = __x + _Tp(__n);
_Tp __c = _Tp(1) / __fp_min;
_Tp __d = _Tp(1) / __b;
_Tp __h = __d;
for ( unsigned int __i = 1; __i <= __max_iter; ++__i )
{
_Tp __a = -_Tp(__i * (__nm1 + __i));
__b += _Tp(2);
__d = _Tp(1) / (__a * __d + __b);
__c = __b + __a / __c;
const _Tp __del = __c * __d;
__h *= __del;
if (std::abs(__del - _Tp(1)) < __eps)
{
const _Tp __ans = __h * std::exp(-__x);
return __ans;
}
}
std::__throw_runtime_error(__N("Continued fraction failed "
"in __expint_En_cont_frac."));
}
/**
* @brief Return the exponential integral @f$ E_n(x) @f$
* by recursion. Use upward recursion for @f$ x < n @f$
* and downward recursion (Miller's algorithm) otherwise.
*
* The exponential integral is given by
* \f[
* E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
* \f]
*
* @param __n The order of the exponential integral function.
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_En_recursion(unsigned int __n, _Tp __x)
{
_Tp __En;
_Tp __E1 = __expint_E1(__x);
if (__x < _Tp(__n))
{
// Forward recursion is stable only for n < x.
__En = __E1;
for (unsigned int __j = 2; __j < __n; ++__j)
__En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1);
}
else
{
// Backward recursion is stable only for n >= x.
__En = _Tp(1);
const int __N = __n + 20; // TODO: Check this starting number.
_Tp __save = _Tp(0);
for (int __j = __N; __j > 0; --__j)
{
__En = (std::exp(-__x) - __j * __En) / __x;
if (__j == __n)
__save = __En;
}
_Tp __norm = __En / __E1;
__En /= __norm;
}
return __En;
}
/**
* @brief Return the exponential integral @f$ Ei(x) @f$
* by series summation.
*
* The exponential integral is given by
* \f[
* Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
* \f]
*
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_Ei_series(_Tp __x)
{
_Tp __term = _Tp(1);
_Tp __sum = _Tp(0);
const unsigned int __max_iter = 1000;
for (unsigned int __i = 1; __i < __max_iter; ++__i)
{
__term *= __x / __i;
__sum += __term / __i;
if (__term < std::numeric_limits<_Tp>::epsilon() * __sum)
break;
}
return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x);
}
/**
* @brief Return the exponential integral @f$ Ei(x) @f$
* by asymptotic expansion.
*
* The exponential integral is given by
* \f[
* Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
* \f]
*
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_Ei_asymp(_Tp __x)
{
_Tp __term = _Tp(1);
_Tp __sum = _Tp(1);
const unsigned int __max_iter = 1000;
for (unsigned int __i = 1; __i < __max_iter; ++__i)
{
_Tp __prev = __term;
__term *= __i / __x;
if (__term < std::numeric_limits<_Tp>::epsilon())
break;
if (__term >= __prev)
break;
__sum += __term;
}
return std::exp(__x) * __sum / __x;
}
/**
* @brief Return the exponential integral @f$ Ei(x) @f$.
*
* The exponential integral is given by
* \f[
* Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
* \f]
*
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_Ei(_Tp __x)
{
if (__x < _Tp(0))
return -__expint_E1(-__x);
else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon()))
return __expint_Ei_series(__x);
else
return __expint_Ei_asymp(__x);
}
/**
* @brief Return the exponential integral @f$ E_1(x) @f$.
*
* The exponential integral is given by
* \f[
* E_1(x) = \int_{1}^\infty \frac{e^{-xt}}{t} dt
* \f]
*
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_E1(_Tp __x)
{
if (__x < _Tp(0))
return -__expint_Ei(-__x);
else if (__x < _Tp(1))
return __expint_E1_series(__x);
else if (__x < _Tp(100)) // TODO: Find a good asymptotic switch point.
return __expint_En_cont_frac(1, __x);
else
return __expint_E1_asymp(__x);
}
/**
* @brief Return the exponential integral @f$ E_n(x) @f$
* for large argument.
*
* The exponential integral is given by
* \f[
* E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
* \f]
*
* This is something of an extension.
*
* @param __n The order of the exponential integral function.
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_asymp(unsigned int __n, _Tp __x)
{
_Tp __term = _Tp(1);
_Tp __sum = _Tp(1);
for (unsigned int __i = 1; __i <= __n; ++__i)
{
_Tp __prev = __term;
__term *= -(__n - __i + 1) / __x;
if (std::abs(__term) > std::abs(__prev))
break;
__sum += __term;
}
return std::exp(-__x) * __sum / __x;
}
/**
* @brief Return the exponential integral @f$ E_n(x) @f$
* for large order.
*
* The exponential integral is given by
* \f[
* E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
* \f]
*
* This is something of an extension.
*
* @param __n The order of the exponential integral function.
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint_large_n(unsigned int __n, _Tp __x)
{
const _Tp __xpn = __x + __n;
const _Tp __xpn2 = __xpn * __xpn;
_Tp __term = _Tp(1);
_Tp __sum = _Tp(1);
for (unsigned int __i = 1; __i <= __n; ++__i)
{
_Tp __prev = __term;
__term *= (__n - 2 * (__i - 1) * __x) / __xpn2;
if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
break;
__sum += __term;
}
return std::exp(-__x) * __sum / __xpn;
}
/**
* @brief Return the exponential integral @f$ E_n(x) @f$.
*
* The exponential integral is given by
* \f[
* E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt
* \f]
* This is something of an extension.
*
* @param __n The order of the exponential integral function.
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
_Tp
__expint(unsigned int __n, _Tp __x)
{
// Return NaN on NaN input.
if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__n <= 1 && __x == _Tp(0))
return std::numeric_limits<_Tp>::infinity();
else
{
_Tp __E0 = std::exp(__x) / __x;
if (__n == 0)
return __E0;
_Tp __E1 = __expint_E1(__x);
if (__n == 1)
return __E1;
if (__x == _Tp(0))
return _Tp(1) / static_cast<_Tp>(__n - 1);
_Tp __En = __expint_En_recursion(__n, __x);
return __En;
}
}
/**
* @brief Return the exponential integral @f$ Ei(x) @f$.
*
* The exponential integral is given by
* \f[
* Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
* \f]
*
* @param __x The argument of the exponential integral function.
* @return The exponential integral.
*/
template<typename _Tp>
inline _Tp
__expint(_Tp __x)
{
if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else
return __expint_Ei(__x);
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_EXP_INTEGRAL_TCC

34
contrib/sdk/sources/libstdc++-v3/include/tr1/fenv.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 fenv.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/fenv.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_FENV_H
#define _TR1_FENV_H 1
#include <tr1/cfenv>
#endif

34
contrib/sdk/sources/libstdc++-v3/include/tr1/float.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 float.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/float.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_FLOAT_H
#define _TR1_FLOAT_H 1
#include <tr1/cfloat>
#endif

2308
contrib/sdk/sources/libstdc++-v3/include/tr1/functional Normal file
View File

File diff suppressed because it is too large Load Diff

196
contrib/sdk/sources/libstdc++-v3/include/tr1/functional_hash.h Normal file
View File

@@ -0,0 +1,196 @@
// TR1 functional_hash.h header -*- C++ -*-
// Copyright (C) 2007-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/functional_hash.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/functional}
*/
#ifndef _GLIBCXX_TR1_FUNCTIONAL_HASH_H
#define _GLIBCXX_TR1_FUNCTIONAL_HASH_H 1
#pragma GCC system_header
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Class template hash.
// Declaration of default hash functor std::tr1::hash. The types for
// which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR.
template<typename _Tp>
struct hash : public std::unary_function<_Tp, size_t>
{
size_t
operator()(_Tp __val) const;
};
/// Partial specializations for pointer types.
template<typename _Tp>
struct hash<_Tp*> : public std::unary_function<_Tp*, size_t>
{
size_t
operator()(_Tp* __p) const
{ return reinterpret_cast<size_t>(__p); }
};
/// Explicit specializations for integer types.
#define _TR1_hashtable_define_trivial_hash(_Tp) \
template<> \
inline size_t \
hash<_Tp>::operator()(_Tp __val) const \
{ return static_cast<size_t>(__val); }
_TR1_hashtable_define_trivial_hash(bool);
_TR1_hashtable_define_trivial_hash(char);
_TR1_hashtable_define_trivial_hash(signed char);
_TR1_hashtable_define_trivial_hash(unsigned char);
_TR1_hashtable_define_trivial_hash(wchar_t);
_TR1_hashtable_define_trivial_hash(short);
_TR1_hashtable_define_trivial_hash(int);
_TR1_hashtable_define_trivial_hash(long);
_TR1_hashtable_define_trivial_hash(long long);
_TR1_hashtable_define_trivial_hash(unsigned short);
_TR1_hashtable_define_trivial_hash(unsigned int);
_TR1_hashtable_define_trivial_hash(unsigned long);
_TR1_hashtable_define_trivial_hash(unsigned long long);
#undef _TR1_hashtable_define_trivial_hash
// Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
// (Used by the next specializations of std::tr1::hash.)
/// Dummy generic implementation (for sizeof(size_t) != 4, 8).
template<size_t>
struct _Fnv_hash_base
{
template<typename _Tp>
static size_t
hash(const _Tp* __ptr, size_t __clength)
{
size_t __result = 0;
const char* __cptr = reinterpret_cast<const char*>(__ptr);
for (; __clength; --__clength)
__result = (__result * 131) + *__cptr++;
return __result;
}
};
template<>
struct _Fnv_hash_base<4>
{
template<typename _Tp>
static size_t
hash(const _Tp* __ptr, size_t __clength)
{
size_t __result = static_cast<size_t>(2166136261UL);
const char* __cptr = reinterpret_cast<const char*>(__ptr);
for (; __clength; --__clength)
{
__result ^= static_cast<size_t>(*__cptr++);
__result *= static_cast<size_t>(16777619UL);
}
return __result;
}
};
template<>
struct _Fnv_hash_base<8>
{
template<typename _Tp>
static size_t
hash(const _Tp* __ptr, size_t __clength)
{
size_t __result
= static_cast<size_t>(14695981039346656037ULL);
const char* __cptr = reinterpret_cast<const char*>(__ptr);
for (; __clength; --__clength)
{
__result ^= static_cast<size_t>(*__cptr++);
__result *= static_cast<size_t>(1099511628211ULL);
}
return __result;
}
};
struct _Fnv_hash
: public _Fnv_hash_base<sizeof(size_t)>
{
using _Fnv_hash_base<sizeof(size_t)>::hash;
template<typename _Tp>
static size_t
hash(const _Tp& __val)
{ return hash(&__val, sizeof(__val)); }
};
/// Explicit specializations for float.
template<>
inline size_t
hash<float>::operator()(float __val) const
{
// 0 and -0 both hash to zero.
return __val != 0.0f ? std::tr1::_Fnv_hash::hash(__val) : 0;
}
/// Explicit specializations for double.
template<>
inline size_t
hash<double>::operator()(double __val) const
{
// 0 and -0 both hash to zero.
return __val != 0.0 ? std::tr1::_Fnv_hash::hash(__val) : 0;
}
/// Explicit specializations for long double.
template<>
_GLIBCXX_PURE size_t
hash<long double>::operator()(long double __val) const;
/// Explicit specialization of member operator for non-builtin types.
template<>
_GLIBCXX_PURE size_t
hash<string>::operator()(string) const;
template<>
_GLIBCXX_PURE size_t
hash<const string&>::operator()(const string&) const;
#ifdef _GLIBCXX_USE_WCHAR_T
template<>
_GLIBCXX_PURE size_t
hash<wstring>::operator()(wstring) const;
template<>
_GLIBCXX_PURE size_t
hash<const wstring&>::operator()(const wstring&) const;
#endif
_GLIBCXX_END_NAMESPACE_VERSION
}
}
#endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H

469
contrib/sdk/sources/libstdc++-v3/include/tr1/gamma.tcc Normal file
View File

@@ -0,0 +1,469 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/gamma.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on:
// (1) Handbook of Mathematical Functions,
// ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications,
// Section 6, pp. 253-266
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
// (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 213-216
// (4) Gamma, Exploring Euler's Constant, Julian Havil,
// Princeton, 2003.
#ifndef _GLIBCXX_TR1_GAMMA_TCC
#define _GLIBCXX_TR1_GAMMA_TCC 1
#include "special_function_util.h"
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief This returns Bernoulli numbers from a table or by summation
* for larger values.
*
* Recursion is unstable.
*
* @param __n the order n of the Bernoulli number.
* @return The Bernoulli number of order n.
*/
template <typename _Tp>
_Tp
__bernoulli_series(unsigned int __n)
{
static const _Tp __num[28] = {
_Tp(1UL), -_Tp(1UL) / _Tp(2UL),
_Tp(1UL) / _Tp(6UL), _Tp(0UL),
-_Tp(1UL) / _Tp(30UL), _Tp(0UL),
_Tp(1UL) / _Tp(42UL), _Tp(0UL),
-_Tp(1UL) / _Tp(30UL), _Tp(0UL),
_Tp(5UL) / _Tp(66UL), _Tp(0UL),
-_Tp(691UL) / _Tp(2730UL), _Tp(0UL),
_Tp(7UL) / _Tp(6UL), _Tp(0UL),
-_Tp(3617UL) / _Tp(510UL), _Tp(0UL),
_Tp(43867UL) / _Tp(798UL), _Tp(0UL),
-_Tp(174611) / _Tp(330UL), _Tp(0UL),
_Tp(854513UL) / _Tp(138UL), _Tp(0UL),
-_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL),
_Tp(8553103UL) / _Tp(6UL), _Tp(0UL)
};
if (__n == 0)
return _Tp(1);
if (__n == 1)
return -_Tp(1) / _Tp(2);
// Take care of the rest of the odd ones.
if (__n % 2 == 1)
return _Tp(0);
// Take care of some small evens that are painful for the series.
if (__n < 28)
return __num[__n];
_Tp __fact = _Tp(1);
if ((__n / 2) % 2 == 0)
__fact *= _Tp(-1);
for (unsigned int __k = 1; __k <= __n; ++__k)
__fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi());
__fact *= _Tp(2);
_Tp __sum = _Tp(0);
for (unsigned int __i = 1; __i < 1000; ++__i)
{
_Tp __term = std::pow(_Tp(__i), -_Tp(__n));
if (__term < std::numeric_limits<_Tp>::epsilon())
break;
__sum += __term;
}
return __fact * __sum;
}
/**
* @brief This returns Bernoulli number \f$B_n\f$.
*
* @param __n the order n of the Bernoulli number.
* @return The Bernoulli number of order n.
*/
template<typename _Tp>
inline _Tp
__bernoulli(int __n)
{ return __bernoulli_series<_Tp>(__n); }
/**
* @brief Return \f$log(\Gamma(x))\f$ by asymptotic expansion
* with Bernoulli number coefficients. This is like
* Sterling's approximation.
*
* @param __x The argument of the log of the gamma function.
* @return The logarithm of the gamma function.
*/
template<typename _Tp>
_Tp
__log_gamma_bernoulli(_Tp __x)
{
_Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x
+ _Tp(0.5L) * std::log(_Tp(2)
* __numeric_constants<_Tp>::__pi());
const _Tp __xx = __x * __x;
_Tp __help = _Tp(1) / __x;
for ( unsigned int __i = 1; __i < 20; ++__i )
{
const _Tp __2i = _Tp(2 * __i);
__help /= __2i * (__2i - _Tp(1)) * __xx;
__lg += __bernoulli<_Tp>(2 * __i) * __help;
}
return __lg;
}
/**
* @brief Return \f$log(\Gamma(x))\f$ by the Lanczos method.
* This method dominates all others on the positive axis I think.
*
* @param __x The argument of the log of the gamma function.
* @return The logarithm of the gamma function.
*/
template<typename _Tp>
_Tp
__log_gamma_lanczos(_Tp __x)
{
const _Tp __xm1 = __x - _Tp(1);
static const _Tp __lanczos_cheb_7[9] = {
_Tp( 0.99999999999980993227684700473478L),
_Tp( 676.520368121885098567009190444019L),
_Tp(-1259.13921672240287047156078755283L),
_Tp( 771.3234287776530788486528258894L),
_Tp(-176.61502916214059906584551354L),
_Tp( 12.507343278686904814458936853L),
_Tp(-0.13857109526572011689554707L),
_Tp( 9.984369578019570859563e-6L),
_Tp( 1.50563273514931155834e-7L)
};
static const _Tp __LOGROOT2PI
= _Tp(0.9189385332046727417803297364056176L);
_Tp __sum = __lanczos_cheb_7[0];
for(unsigned int __k = 1; __k < 9; ++__k)
__sum += __lanczos_cheb_7[__k] / (__xm1 + __k);
const _Tp __term1 = (__xm1 + _Tp(0.5L))
* std::log((__xm1 + _Tp(7.5L))
/ __numeric_constants<_Tp>::__euler());
const _Tp __term2 = __LOGROOT2PI + std::log(__sum);
const _Tp __result = __term1 + (__term2 - _Tp(7));
return __result;
}
/**
* @brief Return \f$ log(|\Gamma(x)|) \f$.
* This will return values even for \f$ x < 0 \f$.
* To recover the sign of \f$ \Gamma(x) \f$ for
* any argument use @a __log_gamma_sign.
*
* @param __x The argument of the log of the gamma function.
* @return The logarithm of the gamma function.
*/
template<typename _Tp>
_Tp
__log_gamma(_Tp __x)
{
if (__x > _Tp(0.5L))
return __log_gamma_lanczos(__x);
else
{
const _Tp __sin_fact
= std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x));
if (__sin_fact == _Tp(0))
std::__throw_domain_error(__N("Argument is nonpositive integer "
"in __log_gamma"));
return __numeric_constants<_Tp>::__lnpi()
- std::log(__sin_fact)
- __log_gamma_lanczos(_Tp(1) - __x);
}
}
/**
* @brief Return the sign of \f$ \Gamma(x) \f$.
* At nonpositive integers zero is returned.
*
* @param __x The argument of the gamma function.
* @return The sign of the gamma function.
*/
template<typename _Tp>
_Tp
__log_gamma_sign(_Tp __x)
{
if (__x > _Tp(0))
return _Tp(1);
else
{
const _Tp __sin_fact
= std::sin(__numeric_constants<_Tp>::__pi() * __x);
if (__sin_fact > _Tp(0))
return (1);
else if (__sin_fact < _Tp(0))
return -_Tp(1);
else
return _Tp(0);
}
}
/**
* @brief Return the logarithm of the binomial coefficient.
* The binomial coefficient is given by:
* @f[
* \left( \right) = \frac{n!}{(n-k)! k!}
* @f]
*
* @param __n The first argument of the binomial coefficient.
* @param __k The second argument of the binomial coefficient.
* @return The binomial coefficient.
*/
template<typename _Tp>
_Tp
__log_bincoef(unsigned int __n, unsigned int __k)
{
// Max e exponent before overflow.
static const _Tp __max_bincoeff
= std::numeric_limits<_Tp>::max_exponent10
* std::log(_Tp(10)) - _Tp(1);
#if _GLIBCXX_USE_C99_MATH_TR1
_Tp __coeff = std::tr1::lgamma(_Tp(1 + __n))
- std::tr1::lgamma(_Tp(1 + __k))
- std::tr1::lgamma(_Tp(1 + __n - __k));
#else
_Tp __coeff = __log_gamma(_Tp(1 + __n))
- __log_gamma(_Tp(1 + __k))
- __log_gamma(_Tp(1 + __n - __k));
#endif
}
/**
* @brief Return the binomial coefficient.
* The binomial coefficient is given by:
* @f[
* \left( \right) = \frac{n!}{(n-k)! k!}
* @f]
*
* @param __n The first argument of the binomial coefficient.
* @param __k The second argument of the binomial coefficient.
* @return The binomial coefficient.
*/
template<typename _Tp>
_Tp
__bincoef(unsigned int __n, unsigned int __k)
{
// Max e exponent before overflow.
static const _Tp __max_bincoeff
= std::numeric_limits<_Tp>::max_exponent10
* std::log(_Tp(10)) - _Tp(1);
const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k);
if (__log_coeff > __max_bincoeff)
return std::numeric_limits<_Tp>::quiet_NaN();
else
return std::exp(__log_coeff);
}
/**
* @brief Return \f$ \Gamma(x) \f$.
*
* @param __x The argument of the gamma function.
* @return The gamma function.
*/
template<typename _Tp>
inline _Tp
__gamma(_Tp __x)
{ return std::exp(__log_gamma(__x)); }
/**
* @brief Return the digamma function by series expansion.
* The digamma or @f$ \psi(x) @f$ function is defined by
* @f[
* \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)}
* @f]
*
* The series is given by:
* @f[
* \psi(x) = -\gamma_E - \frac{1}{x}
* \sum_{k=1}^{\infty} \frac{x}{k(x + k)}
* @f]
*/
template<typename _Tp>
_Tp
__psi_series(_Tp __x)
{
_Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x;
const unsigned int __max_iter = 100000;
for (unsigned int __k = 1; __k < __max_iter; ++__k)
{
const _Tp __term = __x / (__k * (__k + __x));
__sum += __term;
if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
break;
}
return __sum;
}
/**
* @brief Return the digamma function for large argument.
* The digamma or @f$ \psi(x) @f$ function is defined by
* @f[
* \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)}
* @f]
*
* The asymptotic series is given by:
* @f[
* \psi(x) = \ln(x) - \frac{1}{2x}
* - \sum_{n=1}^{\infty} \frac{B_{2n}}{2 n x^{2n}}
* @f]
*/
template<typename _Tp>
_Tp
__psi_asymp(_Tp __x)
{
_Tp __sum = std::log(__x) - _Tp(0.5L) / __x;
const _Tp __xx = __x * __x;
_Tp __xp = __xx;
const unsigned int __max_iter = 100;
for (unsigned int __k = 1; __k < __max_iter; ++__k)
{
const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp);
__sum -= __term;
if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
break;
__xp *= __xx;
}
return __sum;
}
/**
* @brief Return the digamma function.
* The digamma or @f$ \psi(x) @f$ function is defined by
* @f[
* \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)}
* @f]
* For negative argument the reflection formula is used:
* @f[
* \psi(x) = \psi(1-x) - \pi \cot(\pi x)
* @f]
*/
template<typename _Tp>
_Tp
__psi(_Tp __x)
{
const int __n = static_cast<int>(__x + 0.5L);
const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon();
if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps)
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__x < _Tp(0))
{
const _Tp __pi = __numeric_constants<_Tp>::__pi();
return __psi(_Tp(1) - __x)
- __pi * std::cos(__pi * __x) / std::sin(__pi * __x);
}
else if (__x > _Tp(100))
return __psi_asymp(__x);
else
return __psi_series(__x);
}
/**
* @brief Return the polygamma function @f$ \psi^{(n)}(x) @f$.
*
* The polygamma function is related to the Hurwitz zeta function:
* @f[
* \psi^{(n)}(x) = (-1)^{n+1} m! \zeta(m+1,x)
* @f]
*/
template<typename _Tp>
_Tp
__psi(unsigned int __n, _Tp __x)
{
if (__x <= _Tp(0))
std::__throw_domain_error(__N("Argument out of range "
"in __psi"));
else if (__n == 0)
return __psi(__x);
else
{
const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);
#if _GLIBCXX_USE_C99_MATH_TR1
const _Tp __ln_nfact = std::tr1::lgamma(_Tp(__n + 1));
#else
const _Tp __ln_nfact = __log_gamma(_Tp(__n + 1));
#endif
_Tp __result = std::exp(__ln_nfact) * __hzeta;
if (__n % 2 == 1)
__result = -__result;
return __result;
}
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_GAMMA_TCC

1181
contrib/sdk/sources/libstdc++-v3/include/tr1/hashtable.h Normal file
View File

File diff suppressed because it is too large Load Diff

783
contrib/sdk/sources/libstdc++-v3/include/tr1/hashtable_policy.h Normal file
View File

@@ -0,0 +1,783 @@
// Internal policy header for TR1 unordered_set and unordered_map -*- C++ -*-
// Copyright (C) 2010-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/hashtable_policy.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly.
* @headername{tr1/unordered_map, tr1/unordered_set}
*/
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Helper function: return distance(first, last) for forward
// iterators, or 0 for input iterators.
template<class _Iterator>
inline typename std::iterator_traits<_Iterator>::difference_type
__distance_fw(_Iterator __first, _Iterator __last,
std::input_iterator_tag)
{ return 0; }
template<class _Iterator>
inline typename std::iterator_traits<_Iterator>::difference_type
__distance_fw(_Iterator __first, _Iterator __last,
std::forward_iterator_tag)
{ return std::distance(__first, __last); }
template<class _Iterator>
inline typename std::iterator_traits<_Iterator>::difference_type
__distance_fw(_Iterator __first, _Iterator __last)
{
typedef typename std::iterator_traits<_Iterator>::iterator_category _Tag;
return __distance_fw(__first, __last, _Tag());
}
// Auxiliary types used for all instantiations of _Hashtable: nodes
// and iterators.
// Nodes, used to wrap elements stored in the hash table. A policy
// template parameter of class template _Hashtable controls whether
// nodes also store a hash code. In some cases (e.g. strings) this
// may be a performance win.
template<typename _Value, bool __cache_hash_code>
struct _Hash_node;
template<typename _Value>
struct _Hash_node<_Value, true>
{
_Value _M_v;
std::size_t _M_hash_code;
_Hash_node* _M_next;
};
template<typename _Value>
struct _Hash_node<_Value, false>
{
_Value _M_v;
_Hash_node* _M_next;
};
// Local iterators, used to iterate within a bucket but not between
// buckets.
template<typename _Value, bool __cache>
struct _Node_iterator_base
{
_Node_iterator_base(_Hash_node<_Value, __cache>* __p)
: _M_cur(__p) { }
void
_M_incr()
{ _M_cur = _M_cur->_M_next; }
_Hash_node<_Value, __cache>* _M_cur;
};
template<typename _Value, bool __cache>
inline bool
operator==(const _Node_iterator_base<_Value, __cache>& __x,
const _Node_iterator_base<_Value, __cache>& __y)
{ return __x._M_cur == __y._M_cur; }
template<typename _Value, bool __cache>
inline bool
operator!=(const _Node_iterator_base<_Value, __cache>& __x,
const _Node_iterator_base<_Value, __cache>& __y)
{ return __x._M_cur != __y._M_cur; }
template<typename _Value, bool __constant_iterators, bool __cache>
struct _Node_iterator
: public _Node_iterator_base<_Value, __cache>
{
typedef _Value value_type;
typedef typename
__gnu_cxx::__conditional_type<__constant_iterators,
const _Value*, _Value*>::__type
pointer;
typedef typename
__gnu_cxx::__conditional_type<__constant_iterators,
const _Value&, _Value&>::__type
reference;
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
_Node_iterator()
: _Node_iterator_base<_Value, __cache>(0) { }
explicit
_Node_iterator(_Hash_node<_Value, __cache>* __p)
: _Node_iterator_base<_Value, __cache>(__p) { }
reference
operator*() const
{ return this->_M_cur->_M_v; }
pointer
operator->() const
{ return std::__addressof(this->_M_cur->_M_v); }
_Node_iterator&
operator++()
{
this->_M_incr();
return *this;
}
_Node_iterator
operator++(int)
{
_Node_iterator __tmp(*this);
this->_M_incr();
return __tmp;
}
};
template<typename _Value, bool __constant_iterators, bool __cache>
struct _Node_const_iterator
: public _Node_iterator_base<_Value, __cache>
{
typedef _Value value_type;
typedef const _Value* pointer;
typedef const _Value& reference;
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
_Node_const_iterator()
: _Node_iterator_base<_Value, __cache>(0) { }
explicit
_Node_const_iterator(_Hash_node<_Value, __cache>* __p)
: _Node_iterator_base<_Value, __cache>(__p) { }
_Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
__cache>& __x)
: _Node_iterator_base<_Value, __cache>(__x._M_cur) { }
reference
operator*() const
{ return this->_M_cur->_M_v; }
pointer
operator->() const
{ return std::__addressof(this->_M_cur->_M_v); }
_Node_const_iterator&
operator++()
{
this->_M_incr();
return *this;
}
_Node_const_iterator
operator++(int)
{
_Node_const_iterator __tmp(*this);
this->_M_incr();
return __tmp;
}
};
template<typename _Value, bool __cache>
struct _Hashtable_iterator_base
{
_Hashtable_iterator_base(_Hash_node<_Value, __cache>* __node,
_Hash_node<_Value, __cache>** __bucket)
: _M_cur_node(__node), _M_cur_bucket(__bucket) { }
void
_M_incr()
{
_M_cur_node = _M_cur_node->_M_next;
if (!_M_cur_node)
_M_incr_bucket();
}
void
_M_incr_bucket();
_Hash_node<_Value, __cache>* _M_cur_node;
_Hash_node<_Value, __cache>** _M_cur_bucket;
};
// Global iterators, used for arbitrary iteration within a hash
// table. Larger and more expensive than local iterators.
template<typename _Value, bool __cache>
void
_Hashtable_iterator_base<_Value, __cache>::
_M_incr_bucket()
{
++_M_cur_bucket;
// This loop requires the bucket array to have a non-null sentinel.
while (!*_M_cur_bucket)
++_M_cur_bucket;
_M_cur_node = *_M_cur_bucket;
}
template<typename _Value, bool __cache>
inline bool
operator==(const _Hashtable_iterator_base<_Value, __cache>& __x,
const _Hashtable_iterator_base<_Value, __cache>& __y)
{ return __x._M_cur_node == __y._M_cur_node; }
template<typename _Value, bool __cache>
inline bool
operator!=(const _Hashtable_iterator_base<_Value, __cache>& __x,
const _Hashtable_iterator_base<_Value, __cache>& __y)
{ return __x._M_cur_node != __y._M_cur_node; }
template<typename _Value, bool __constant_iterators, bool __cache>
struct _Hashtable_iterator
: public _Hashtable_iterator_base<_Value, __cache>
{
typedef _Value value_type;
typedef typename
__gnu_cxx::__conditional_type<__constant_iterators,
const _Value*, _Value*>::__type
pointer;
typedef typename
__gnu_cxx::__conditional_type<__constant_iterators,
const _Value&, _Value&>::__type
reference;
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
_Hashtable_iterator()
: _Hashtable_iterator_base<_Value, __cache>(0, 0) { }
_Hashtable_iterator(_Hash_node<_Value, __cache>* __p,
_Hash_node<_Value, __cache>** __b)
: _Hashtable_iterator_base<_Value, __cache>(__p, __b) { }
explicit
_Hashtable_iterator(_Hash_node<_Value, __cache>** __b)
: _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { }
reference
operator*() const
{ return this->_M_cur_node->_M_v; }
pointer
operator->() const
{ return std::__addressof(this->_M_cur_node->_M_v); }
_Hashtable_iterator&
operator++()
{
this->_M_incr();
return *this;
}
_Hashtable_iterator
operator++(int)
{
_Hashtable_iterator __tmp(*this);
this->_M_incr();
return __tmp;
}
};
template<typename _Value, bool __constant_iterators, bool __cache>
struct _Hashtable_const_iterator
: public _Hashtable_iterator_base<_Value, __cache>
{
typedef _Value value_type;
typedef const _Value* pointer;
typedef const _Value& reference;
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
_Hashtable_const_iterator()
: _Hashtable_iterator_base<_Value, __cache>(0, 0) { }
_Hashtable_const_iterator(_Hash_node<_Value, __cache>* __p,
_Hash_node<_Value, __cache>** __b)
: _Hashtable_iterator_base<_Value, __cache>(__p, __b) { }
explicit
_Hashtable_const_iterator(_Hash_node<_Value, __cache>** __b)
: _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { }
_Hashtable_const_iterator(const _Hashtable_iterator<_Value,
__constant_iterators, __cache>& __x)
: _Hashtable_iterator_base<_Value, __cache>(__x._M_cur_node,
__x._M_cur_bucket) { }
reference
operator*() const
{ return this->_M_cur_node->_M_v; }
pointer
operator->() const
{ return std::__addressof(this->_M_cur_node->_M_v); }
_Hashtable_const_iterator&
operator++()
{
this->_M_incr();
return *this;
}
_Hashtable_const_iterator
operator++(int)
{
_Hashtable_const_iterator __tmp(*this);
this->_M_incr();
return __tmp;
}
};
// Many of class template _Hashtable's template parameters are policy
// classes. These are defaults for the policies.
// Default range hashing function: use division to fold a large number
// into the range [0, N).
struct _Mod_range_hashing
{
typedef std::size_t first_argument_type;
typedef std::size_t second_argument_type;
typedef std::size_t result_type;
result_type
operator()(first_argument_type __num, second_argument_type __den) const
{ return __num % __den; }
};
// Default ranged hash function H. In principle it should be a
// function object composed from objects of type H1 and H2 such that
// h(k, N) = h2(h1(k), N), but that would mean making extra copies of
// h1 and h2. So instead we'll just use a tag to tell class template
// hashtable to do that composition.
struct _Default_ranged_hash { };
// Default value for rehash policy. Bucket size is (usually) the
// smallest prime that keeps the load factor small enough.
struct _Prime_rehash_policy
{
_Prime_rehash_policy(float __z = 1.0)
: _M_max_load_factor(__z), _M_growth_factor(2.f), _M_next_resize(0) { }
float
max_load_factor() const
{ return _M_max_load_factor; }
// Return a bucket size no smaller than n.
std::size_t
_M_next_bkt(std::size_t __n) const;
// Return a bucket count appropriate for n elements
std::size_t
_M_bkt_for_elements(std::size_t __n) const;
// __n_bkt is current bucket count, __n_elt is current element count,
// and __n_ins is number of elements to be inserted. Do we need to
// increase bucket count? If so, return make_pair(true, n), where n
// is the new bucket count. If not, return make_pair(false, 0).
std::pair<bool, std::size_t>
_M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
std::size_t __n_ins) const;
enum { _S_n_primes = sizeof(unsigned long) != 8 ? 256 : 256 + 48 };
float _M_max_load_factor;
float _M_growth_factor;
mutable std::size_t _M_next_resize;
};
extern const unsigned long __prime_list[];
// XXX This is a hack. There's no good reason for any of
// _Prime_rehash_policy's member functions to be inline.
// Return a prime no smaller than n.
inline std::size_t
_Prime_rehash_policy::
_M_next_bkt(std::size_t __n) const
{
const unsigned long* __p = std::lower_bound(__prime_list, __prime_list
+ _S_n_primes, __n);
_M_next_resize =
static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
return *__p;
}
// Return the smallest prime p such that alpha p >= n, where alpha
// is the load factor.
inline std::size_t
_Prime_rehash_policy::
_M_bkt_for_elements(std::size_t __n) const
{
const float __min_bkts = __n / _M_max_load_factor;
const unsigned long* __p = std::lower_bound(__prime_list, __prime_list
+ _S_n_primes, __min_bkts);
_M_next_resize =
static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
return *__p;
}
// Finds the smallest prime p such that alpha p > __n_elt + __n_ins.
// If p > __n_bkt, return make_pair(true, p); otherwise return
// make_pair(false, 0). In principle this isn't very different from
// _M_bkt_for_elements.
// The only tricky part is that we're caching the element count at
// which we need to rehash, so we don't have to do a floating-point
// multiply for every insertion.
inline std::pair<bool, std::size_t>
_Prime_rehash_policy::
_M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
std::size_t __n_ins) const
{
if (__n_elt + __n_ins > _M_next_resize)
{
float __min_bkts = ((float(__n_ins) + float(__n_elt))
/ _M_max_load_factor);
if (__min_bkts > __n_bkt)
{
__min_bkts = std::max(__min_bkts, _M_growth_factor * __n_bkt);
const unsigned long* __p =
std::lower_bound(__prime_list, __prime_list + _S_n_primes,
__min_bkts);
_M_next_resize = static_cast<std::size_t>
(__builtin_ceil(*__p * _M_max_load_factor));
return std::make_pair(true, *__p);
}
else
{
_M_next_resize = static_cast<std::size_t>
(__builtin_ceil(__n_bkt * _M_max_load_factor));
return std::make_pair(false, 0);
}
}
else
return std::make_pair(false, 0);
}
// Base classes for std::tr1::_Hashtable. We define these base
// classes because in some cases we want to do different things
// depending on the value of a policy class. In some cases the
// policy class affects which member functions and nested typedefs
// are defined; we handle that by specializing base class templates.
// Several of the base class templates need to access other members
// of class template _Hashtable, so we use the "curiously recurring
// template pattern" for them.
// class template _Map_base. If the hashtable has a value type of the
// form pair<T1, T2> and a key extraction policy that returns the
// first part of the pair, the hashtable gets a mapped_type typedef.
// If it satisfies those criteria and also has unique keys, then it
// also gets an operator[].
template<typename _Key, typename _Value, typename _Ex, bool __unique,
typename _Hashtable>
struct _Map_base { };
template<typename _Key, typename _Pair, typename _Hashtable>
struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, false, _Hashtable>
{
typedef typename _Pair::second_type mapped_type;
};
template<typename _Key, typename _Pair, typename _Hashtable>
struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>
{
typedef typename _Pair::second_type mapped_type;
mapped_type&
operator[](const _Key& __k);
};
template<typename _Key, typename _Pair, typename _Hashtable>
typename _Map_base<_Key, _Pair, std::_Select1st<_Pair>,
true, _Hashtable>::mapped_type&
_Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>::
operator[](const _Key& __k)
{
_Hashtable* __h = static_cast<_Hashtable*>(this);
typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
std::size_t __n = __h->_M_bucket_index(__k, __code,
__h->_M_bucket_count);
typename _Hashtable::_Node* __p =
__h->_M_find_node(__h->_M_buckets[__n], __k, __code);
if (!__p)
return __h->_M_insert_bucket(std::make_pair(__k, mapped_type()),
__n, __code)->second;
return (__p->_M_v).second;
}
// class template _Rehash_base. Give hashtable the max_load_factor
// functions iff the rehash policy is _Prime_rehash_policy.
template<typename _RehashPolicy, typename _Hashtable>
struct _Rehash_base { };
template<typename _Hashtable>
struct _Rehash_base<_Prime_rehash_policy, _Hashtable>
{
float
max_load_factor() const
{
const _Hashtable* __this = static_cast<const _Hashtable*>(this);
return __this->__rehash_policy().max_load_factor();
}
void
max_load_factor(float __z)
{
_Hashtable* __this = static_cast<_Hashtable*>(this);
__this->__rehash_policy(_Prime_rehash_policy(__z));
}
};
// Class template _Hash_code_base. Encapsulates two policy issues that
// aren't quite orthogonal.
// (1) the difference between using a ranged hash function and using
// the combination of a hash function and a range-hashing function.
// In the former case we don't have such things as hash codes, so
// we have a dummy type as placeholder.
// (2) Whether or not we cache hash codes. Caching hash codes is
// meaningless if we have a ranged hash function.
// We also put the key extraction and equality comparison function
// objects here, for convenience.
// Primary template: unused except as a hook for specializations.
template<typename _Key, typename _Value,
typename _ExtractKey, typename _Equal,
typename _H1, typename _H2, typename _Hash,
bool __cache_hash_code>
struct _Hash_code_base;
// Specialization: ranged hash function, no caching hash codes. H1
// and H2 are provided but ignored. We define a dummy hash code type.
template<typename _Key, typename _Value,
typename _ExtractKey, typename _Equal,
typename _H1, typename _H2, typename _Hash>
struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
_Hash, false>
{
protected:
_Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
const _H1&, const _H2&, const _Hash& __h)
: _M_extract(__ex), _M_eq(__eq), _M_ranged_hash(__h) { }
typedef void* _Hash_code_type;
_Hash_code_type
_M_hash_code(const _Key& __key) const
{ return 0; }
std::size_t
_M_bucket_index(const _Key& __k, _Hash_code_type,
std::size_t __n) const
{ return _M_ranged_hash(__k, __n); }
std::size_t
_M_bucket_index(const _Hash_node<_Value, false>* __p,
std::size_t __n) const
{ return _M_ranged_hash(_M_extract(__p->_M_v), __n); }
bool
_M_compare(const _Key& __k, _Hash_code_type,
_Hash_node<_Value, false>* __n) const
{ return _M_eq(__k, _M_extract(__n->_M_v)); }
void
_M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const
{ }
void
_M_copy_code(_Hash_node<_Value, false>*,
const _Hash_node<_Value, false>*) const
{ }
void
_M_swap(_Hash_code_base& __x)
{
std::swap(_M_extract, __x._M_extract);
std::swap(_M_eq, __x._M_eq);
std::swap(_M_ranged_hash, __x._M_ranged_hash);
}
protected:
_ExtractKey _M_extract;
_Equal _M_eq;
_Hash _M_ranged_hash;
};
// No specialization for ranged hash function while caching hash codes.
// That combination is meaningless, and trying to do it is an error.
// Specialization: ranged hash function, cache hash codes. This
// combination is meaningless, so we provide only a declaration
// and no definition.
template<typename _Key, typename _Value,
typename _ExtractKey, typename _Equal,
typename _H1, typename _H2, typename _Hash>
struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
_Hash, true>;
// Specialization: hash function and range-hashing function, no
// caching of hash codes. H is provided but ignored. Provides
// typedef and accessor required by TR1.
template<typename _Key, typename _Value,
typename _ExtractKey, typename _Equal,
typename _H1, typename _H2>
struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
_Default_ranged_hash, false>
{
typedef _H1 hasher;
hasher
hash_function() const
{ return _M_h1; }
protected:
_Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
const _H1& __h1, const _H2& __h2,
const _Default_ranged_hash&)
: _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
typedef std::size_t _Hash_code_type;
_Hash_code_type
_M_hash_code(const _Key& __k) const
{ return _M_h1(__k); }
std::size_t
_M_bucket_index(const _Key&, _Hash_code_type __c,
std::size_t __n) const
{ return _M_h2(__c, __n); }
std::size_t
_M_bucket_index(const _Hash_node<_Value, false>* __p,
std::size_t __n) const
{ return _M_h2(_M_h1(_M_extract(__p->_M_v)), __n); }
bool
_M_compare(const _Key& __k, _Hash_code_type,
_Hash_node<_Value, false>* __n) const
{ return _M_eq(__k, _M_extract(__n->_M_v)); }
void
_M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const
{ }
void
_M_copy_code(_Hash_node<_Value, false>*,
const _Hash_node<_Value, false>*) const
{ }
void
_M_swap(_Hash_code_base& __x)
{
std::swap(_M_extract, __x._M_extract);
std::swap(_M_eq, __x._M_eq);
std::swap(_M_h1, __x._M_h1);
std::swap(_M_h2, __x._M_h2);
}
protected:
_ExtractKey _M_extract;
_Equal _M_eq;
_H1 _M_h1;
_H2 _M_h2;
};
// Specialization: hash function and range-hashing function,
// caching hash codes. H is provided but ignored. Provides
// typedef and accessor required by TR1.
template<typename _Key, typename _Value,
typename _ExtractKey, typename _Equal,
typename _H1, typename _H2>
struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
_Default_ranged_hash, true>
{
typedef _H1 hasher;
hasher
hash_function() const
{ return _M_h1; }
protected:
_Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
const _H1& __h1, const _H2& __h2,
const _Default_ranged_hash&)
: _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
typedef std::size_t _Hash_code_type;
_Hash_code_type
_M_hash_code(const _Key& __k) const
{ return _M_h1(__k); }
std::size_t
_M_bucket_index(const _Key&, _Hash_code_type __c,
std::size_t __n) const
{ return _M_h2(__c, __n); }
std::size_t
_M_bucket_index(const _Hash_node<_Value, true>* __p,
std::size_t __n) const
{ return _M_h2(__p->_M_hash_code, __n); }
bool
_M_compare(const _Key& __k, _Hash_code_type __c,
_Hash_node<_Value, true>* __n) const
{ return __c == __n->_M_hash_code && _M_eq(__k, _M_extract(__n->_M_v)); }
void
_M_store_code(_Hash_node<_Value, true>* __n, _Hash_code_type __c) const
{ __n->_M_hash_code = __c; }
void
_M_copy_code(_Hash_node<_Value, true>* __to,
const _Hash_node<_Value, true>* __from) const
{ __to->_M_hash_code = __from->_M_hash_code; }
void
_M_swap(_Hash_code_base& __x)
{
std::swap(_M_extract, __x._M_extract);
std::swap(_M_eq, __x._M_eq);
std::swap(_M_h1, __x._M_h1);
std::swap(_M_h2, __x._M_h2);
}
protected:
_ExtractKey _M_extract;
_Equal _M_eq;
_H1 _M_h1;
_H2 _M_h2;
};
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
}
}

775
contrib/sdk/sources/libstdc++-v3/include/tr1/hypergeometric.tcc Normal file
View File

@@ -0,0 +1,775 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/hypergeometric.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based:
// (1) Handbook of Mathematical Functions,
// ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications,
// Section 6, pp. 555-566
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
#ifndef _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
#define _GLIBCXX_TR1_HYPERGEOMETRIC_TCC 1
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief This routine returns the confluent hypergeometric function
* by series expansion.
*
* @f[
* _1F_1(a;c;x) = \frac{\Gamma(c)}{\Gamma(a)}
* \sum_{n=0}^{\infty}
* \frac{\Gamma(a+n)}{\Gamma(c+n)}
* \frac{x^n}{n!}
* @f]
*
* If a and b are integers and a < 0 and either b > 0 or b < a
* then the series is a polynomial with a finite number of
* terms. If b is an integer and b <= 0 the confluent
* hypergeometric function is undefined.
*
* @param __a The "numerator" parameter.
* @param __c The "denominator" parameter.
* @param __x The argument of the confluent hypergeometric function.
* @return The confluent hypergeometric function.
*/
template<typename _Tp>
_Tp
__conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x)
{
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
_Tp __term = _Tp(1);
_Tp __Fac = _Tp(1);
const unsigned int __max_iter = 100000;
unsigned int __i;
for (__i = 0; __i < __max_iter; ++__i)
{
__term *= (__a + _Tp(__i)) * __x
/ ((__c + _Tp(__i)) * _Tp(1 + __i));
if (std::abs(__term) < __eps)
{
break;
}
__Fac += __term;
}
if (__i == __max_iter)
std::__throw_runtime_error(__N("Series failed to converge "
"in __conf_hyperg_series."));
return __Fac;
}
/**
* @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$
* by an iterative procedure described in
* Luke, Algorithms for the Computation of Mathematical Functions.
*
* Like the case of the 2F1 rational approximations, these are
* probably guaranteed to converge for x < 0, barring gross
* numerical instability in the pre-asymptotic regime.
*/
template<typename _Tp>
_Tp
__conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin)
{
const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
const int __nmax = 20000;
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __x = -__xin;
const _Tp __x3 = __x * __x * __x;
const _Tp __t0 = __a / __c;
const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c);
const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1)));
_Tp __F = _Tp(1);
_Tp __prec;
_Tp __Bnm3 = _Tp(1);
_Tp __Bnm2 = _Tp(1) + __t1 * __x;
_Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
_Tp __Anm3 = _Tp(1);
_Tp __Anm2 = __Bnm2 - __t0 * __x;
_Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
+ __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
int __n = 3;
while(1)
{
_Tp __npam1 = _Tp(__n - 1) + __a;
_Tp __npcm1 = _Tp(__n - 1) + __c;
_Tp __npam2 = _Tp(__n - 2) + __a;
_Tp __npcm2 = _Tp(__n - 2) + __c;
_Tp __tnm1 = _Tp(2 * __n - 1);
_Tp __tnm3 = _Tp(2 * __n - 3);
_Tp __tnm5 = _Tp(2 * __n - 5);
_Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1);
_Tp __F2 = (_Tp(__n) + __a) * __npam1
/ (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
_Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a)
/ (_Tp(8) * __tnm3 * __tnm3 * __tnm5
* (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
_Tp __E = -__npam1 * (_Tp(__n - 1) - __c)
/ (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
_Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
+ (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
_Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
+ (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
_Tp __r = __An / __Bn;
__prec = std::abs((__F - __r) / __F);
__F = __r;
if (__prec < __eps || __n > __nmax)
break;
if (std::abs(__An) > __big || std::abs(__Bn) > __big)
{
__An /= __big;
__Bn /= __big;
__Anm1 /= __big;
__Bnm1 /= __big;
__Anm2 /= __big;
__Bnm2 /= __big;
__Anm3 /= __big;
__Bnm3 /= __big;
}
else if (std::abs(__An) < _Tp(1) / __big
|| std::abs(__Bn) < _Tp(1) / __big)
{
__An *= __big;
__Bn *= __big;
__Anm1 *= __big;
__Bnm1 *= __big;
__Anm2 *= __big;
__Bnm2 *= __big;
__Anm3 *= __big;
__Bnm3 *= __big;
}
++__n;
__Bnm3 = __Bnm2;
__Bnm2 = __Bnm1;
__Bnm1 = __Bn;
__Anm3 = __Anm2;
__Anm2 = __Anm1;
__Anm1 = __An;
}
if (__n >= __nmax)
std::__throw_runtime_error(__N("Iteration failed to converge "
"in __conf_hyperg_luke."));
return __F;
}
/**
* @brief Return the confluent hypogeometric function
* @f$ _1F_1(a;c;x) @f$.
*
* @todo Handle b == nonpositive integer blowup - return NaN.
*
* @param __a The @a numerator parameter.
* @param __c The @a denominator parameter.
* @param __x The argument of the confluent hypergeometric function.
* @return The confluent hypergeometric function.
*/
template<typename _Tp>
_Tp
__conf_hyperg(_Tp __a, _Tp __c, _Tp __x)
{
#if _GLIBCXX_USE_C99_MATH_TR1
const _Tp __c_nint = std::tr1::nearbyint(__c);
#else
const _Tp __c_nint = static_cast<int>(__c + _Tp(0.5L));
#endif
if (__isnan(__a) || __isnan(__c) || __isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__c_nint == __c && __c_nint <= 0)
return std::numeric_limits<_Tp>::infinity();
else if (__a == _Tp(0))
return _Tp(1);
else if (__c == __a)
return std::exp(__x);
else if (__x < _Tp(0))
return __conf_hyperg_luke(__a, __c, __x);
else
return __conf_hyperg_series(__a, __c, __x);
}
/**
* @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$
* by series expansion.
*
* The hypogeometric function is defined by
* @f[
* _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)}
* \sum_{n=0}^{\infty}
* \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)}
* \frac{x^n}{n!}
* @f]
*
* This works and it's pretty fast.
*
* @param __a The first @a numerator parameter.
* @param __a The second @a numerator parameter.
* @param __c The @a denominator parameter.
* @param __x The argument of the confluent hypergeometric function.
* @return The confluent hypergeometric function.
*/
template<typename _Tp>
_Tp
__hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
{
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
_Tp __term = _Tp(1);
_Tp __Fabc = _Tp(1);
const unsigned int __max_iter = 100000;
unsigned int __i;
for (__i = 0; __i < __max_iter; ++__i)
{
__term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x
/ ((__c + _Tp(__i)) * _Tp(1 + __i));
if (std::abs(__term) < __eps)
{
break;
}
__Fabc += __term;
}
if (__i == __max_iter)
std::__throw_runtime_error(__N("Series failed to converge "
"in __hyperg_series."));
return __Fabc;
}
/**
* @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$
* by an iterative procedure described in
* Luke, Algorithms for the Computation of Mathematical Functions.
*/
template<typename _Tp>
_Tp
__hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin)
{
const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
const int __nmax = 20000;
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __x = -__xin;
const _Tp __x3 = __x * __x * __x;
const _Tp __t0 = __a * __b / __c;
const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c);
const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2))
/ (_Tp(2) * (__c + _Tp(1)));
_Tp __F = _Tp(1);
_Tp __Bnm3 = _Tp(1);
_Tp __Bnm2 = _Tp(1) + __t1 * __x;
_Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
_Tp __Anm3 = _Tp(1);
_Tp __Anm2 = __Bnm2 - __t0 * __x;
_Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
+ __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
int __n = 3;
while (1)
{
const _Tp __npam1 = _Tp(__n - 1) + __a;
const _Tp __npbm1 = _Tp(__n - 1) + __b;
const _Tp __npcm1 = _Tp(__n - 1) + __c;
const _Tp __npam2 = _Tp(__n - 2) + __a;
const _Tp __npbm2 = _Tp(__n - 2) + __b;
const _Tp __npcm2 = _Tp(__n - 2) + __c;
const _Tp __tnm1 = _Tp(2 * __n - 1);
const _Tp __tnm3 = _Tp(2 * __n - 3);
const _Tp __tnm5 = _Tp(2 * __n - 5);
const _Tp __n2 = __n * __n;
const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n
+ _Tp(2) - __a * __b - _Tp(2) * (__a + __b))
/ (_Tp(2) * __tnm3 * __npcm1);
const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n
+ _Tp(2) - __a * __b) * __npam1 * __npbm1
/ (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1
* (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b))
/ (_Tp(8) * __tnm3 * __tnm3 * __tnm5
* (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c)
/ (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
_Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
+ (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
_Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
+ (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
const _Tp __r = __An / __Bn;
const _Tp __prec = std::abs((__F - __r) / __F);
__F = __r;
if (__prec < __eps || __n > __nmax)
break;
if (std::abs(__An) > __big || std::abs(__Bn) > __big)
{
__An /= __big;
__Bn /= __big;
__Anm1 /= __big;
__Bnm1 /= __big;
__Anm2 /= __big;
__Bnm2 /= __big;
__Anm3 /= __big;
__Bnm3 /= __big;
}
else if (std::abs(__An) < _Tp(1) / __big
|| std::abs(__Bn) < _Tp(1) / __big)
{
__An *= __big;
__Bn *= __big;
__Anm1 *= __big;
__Bnm1 *= __big;
__Anm2 *= __big;
__Bnm2 *= __big;
__Anm3 *= __big;
__Bnm3 *= __big;
}
++__n;
__Bnm3 = __Bnm2;
__Bnm2 = __Bnm1;
__Bnm1 = __Bn;
__Anm3 = __Anm2;
__Anm2 = __Anm1;
__Anm1 = __An;
}
if (__n >= __nmax)
std::__throw_runtime_error(__N("Iteration failed to converge "
"in __hyperg_luke."));
return __F;
}
/**
* @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$
* by the reflection formulae in Abramowitz & Stegun formula
* 15.3.6 for d = c - a - b not integral and formula 15.3.11 for
* d = c - a - b integral. This assumes a, b, c != negative
* integer.
*
* The hypogeometric function is defined by
* @f[
* _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)}
* \sum_{n=0}^{\infty}
* \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)}
* \frac{x^n}{n!}
* @f]
*
* The reflection formula for nonintegral @f$ d = c - a - b @f$ is:
* @f[
* _2F_1(a,b;c;x) = \frac{\Gamma(c)\Gamma(d)}{\Gamma(c-a)\Gamma(c-b)}
* _2F_1(a,b;1-d;1-x)
* + \frac{\Gamma(c)\Gamma(-d)}{\Gamma(a)\Gamma(b)}
* _2F_1(c-a,c-b;1+d;1-x)
* @f]
*
* The reflection formula for integral @f$ m = c - a - b @f$ is:
* @f[
* _2F_1(a,b;a+b+m;x) = \frac{\Gamma(m)\Gamma(a+b+m)}{\Gamma(a+m)\Gamma(b+m)}
* \sum_{k=0}^{m-1} \frac{(m+a)_k(m+b)_k}{k!(1-m)_k}
* -
* @f]
*/
template<typename _Tp>
_Tp
__hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
{
const _Tp __d = __c - __a - __b;
const int __intd = std::floor(__d + _Tp(0.5L));
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __toler = _Tp(1000) * __eps;
const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max());
const bool __d_integer = (std::abs(__d - __intd) < __toler);
if (__d_integer)
{
const _Tp __ln_omx = std::log(_Tp(1) - __x);
const _Tp __ad = std::abs(__d);
_Tp __F1, __F2;
_Tp __d1, __d2;
if (__d >= _Tp(0))
{
__d1 = __d;
__d2 = _Tp(0);
}
else
{
__d1 = _Tp(0);
__d2 = __d;
}
const _Tp __lng_c = __log_gamma(__c);
// Evaluate F1.
if (__ad < __eps)
{
// d = c - a - b = 0.
__F1 = _Tp(0);
}
else
{
bool __ok_d1 = true;
_Tp __lng_ad, __lng_ad1, __lng_bd1;
__try
{
__lng_ad = __log_gamma(__ad);
__lng_ad1 = __log_gamma(__a + __d1);
__lng_bd1 = __log_gamma(__b + __d1);
}
__catch(...)
{
__ok_d1 = false;
}
if (__ok_d1)
{
/* Gamma functions in the denominator are ok.
* Proceed with evaluation.
*/
_Tp __sum1 = _Tp(1);
_Tp __term = _Tp(1);
_Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx
- __lng_ad1 - __lng_bd1;
/* Do F1 sum.
*/
for (int __i = 1; __i < __ad; ++__i)
{
const int __j = __i - 1;
__term *= (__a + __d2 + __j) * (__b + __d2 + __j)
/ (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x);
__sum1 += __term;
}
if (__ln_pre1 > __log_max)
std::__throw_runtime_error(__N("Overflow of gamma functions"
" in __hyperg_luke."));
else
__F1 = std::exp(__ln_pre1) * __sum1;
}
else
{
// Gamma functions in the denominator were not ok.
// So the F1 term is zero.
__F1 = _Tp(0);
}
} // end F1 evaluation
// Evaluate F2.
bool __ok_d2 = true;
_Tp __lng_ad2, __lng_bd2;
__try
{
__lng_ad2 = __log_gamma(__a + __d2);
__lng_bd2 = __log_gamma(__b + __d2);
}
__catch(...)
{
__ok_d2 = false;
}
if (__ok_d2)
{
// Gamma functions in the denominator are ok.
// Proceed with evaluation.
const int __maxiter = 2000;
const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e();
const _Tp __psi_1pd = __psi(_Tp(1) + __ad);
const _Tp __psi_apd1 = __psi(__a + __d1);
const _Tp __psi_bpd1 = __psi(__b + __d1);
_Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1
- __psi_bpd1 - __ln_omx;
_Tp __fact = _Tp(1);
_Tp __sum2 = __psi_term;
_Tp __ln_pre2 = __lng_c + __d1 * __ln_omx
- __lng_ad2 - __lng_bd2;
// Do F2 sum.
int __j;
for (__j = 1; __j < __maxiter; ++__j)
{
// Values for psi functions use recurrence;
// Abramowitz & Stegun 6.3.5
const _Tp __term1 = _Tp(1) / _Tp(__j)
+ _Tp(1) / (__ad + __j);
const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1))
+ _Tp(1) / (__b + __d1 + _Tp(__j - 1));
__psi_term += __term1 - __term2;
__fact *= (__a + __d1 + _Tp(__j - 1))
* (__b + __d1 + _Tp(__j - 1))
/ ((__ad + __j) * __j) * (_Tp(1) - __x);
const _Tp __delta = __fact * __psi_term;
__sum2 += __delta;
if (std::abs(__delta) < __eps * std::abs(__sum2))
break;
}
if (__j == __maxiter)
std::__throw_runtime_error(__N("Sum F2 failed to converge "
"in __hyperg_reflect"));
if (__sum2 == _Tp(0))
__F2 = _Tp(0);
else
__F2 = std::exp(__ln_pre2) * __sum2;
}
else
{
// Gamma functions in the denominator not ok.
// So the F2 term is zero.
__F2 = _Tp(0);
} // end F2 evaluation
const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1));
const _Tp __F = __F1 + __sgn_2 * __F2;
return __F;
}
else
{
// d = c - a - b not an integer.
// These gamma functions appear in the denominator, so we
// catch their harmless domain errors and set the terms to zero.
bool __ok1 = true;
_Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0);
_Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0);
__try
{
__sgn_g1ca = __log_gamma_sign(__c - __a);
__ln_g1ca = __log_gamma(__c - __a);
__sgn_g1cb = __log_gamma_sign(__c - __b);
__ln_g1cb = __log_gamma(__c - __b);
}
__catch(...)
{
__ok1 = false;
}
bool __ok2 = true;
_Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0);
_Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0);
__try
{
__sgn_g2a = __log_gamma_sign(__a);
__ln_g2a = __log_gamma(__a);
__sgn_g2b = __log_gamma_sign(__b);
__ln_g2b = __log_gamma(__b);
}
__catch(...)
{
__ok2 = false;
}
const _Tp __sgn_gc = __log_gamma_sign(__c);
const _Tp __ln_gc = __log_gamma(__c);
const _Tp __sgn_gd = __log_gamma_sign(__d);
const _Tp __ln_gd = __log_gamma(__d);
const _Tp __sgn_gmd = __log_gamma_sign(-__d);
const _Tp __ln_gmd = __log_gamma(-__d);
const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb;
const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b;
_Tp __pre1, __pre2;
if (__ok1 && __ok2)
{
_Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
_Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
+ __d * std::log(_Tp(1) - __x);
if (__ln_pre1 < __log_max && __ln_pre2 < __log_max)
{
__pre1 = std::exp(__ln_pre1);
__pre2 = std::exp(__ln_pre2);
__pre1 *= __sgn1;
__pre2 *= __sgn2;
}
else
{
std::__throw_runtime_error(__N("Overflow of gamma functions "
"in __hyperg_reflect"));
}
}
else if (__ok1 && !__ok2)
{
_Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
if (__ln_pre1 < __log_max)
{
__pre1 = std::exp(__ln_pre1);
__pre1 *= __sgn1;
__pre2 = _Tp(0);
}
else
{
std::__throw_runtime_error(__N("Overflow of gamma functions "
"in __hyperg_reflect"));
}
}
else if (!__ok1 && __ok2)
{
_Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
+ __d * std::log(_Tp(1) - __x);
if (__ln_pre2 < __log_max)
{
__pre1 = _Tp(0);
__pre2 = std::exp(__ln_pre2);
__pre2 *= __sgn2;
}
else
{
std::__throw_runtime_error(__N("Overflow of gamma functions "
"in __hyperg_reflect"));
}
}
else
{
__pre1 = _Tp(0);
__pre2 = _Tp(0);
std::__throw_runtime_error(__N("Underflow of gamma functions "
"in __hyperg_reflect"));
}
const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d,
_Tp(1) - __x);
const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d,
_Tp(1) - __x);
const _Tp __F = __pre1 * __F1 + __pre2 * __F2;
return __F;
}
}
/**
* @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$.
*
* The hypogeometric function is defined by
* @f[
* _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)}
* \sum_{n=0}^{\infty}
* \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)}
* \frac{x^n}{n!}
* @f]
*
* @param __a The first @a numerator parameter.
* @param __a The second @a numerator parameter.
* @param __c The @a denominator parameter.
* @param __x The argument of the confluent hypergeometric function.
* @return The confluent hypergeometric function.
*/
template<typename _Tp>
_Tp
__hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
{
#if _GLIBCXX_USE_C99_MATH_TR1
const _Tp __a_nint = std::tr1::nearbyint(__a);
const _Tp __b_nint = std::tr1::nearbyint(__b);
const _Tp __c_nint = std::tr1::nearbyint(__c);
#else
const _Tp __a_nint = static_cast<int>(__a + _Tp(0.5L));
const _Tp __b_nint = static_cast<int>(__b + _Tp(0.5L));
const _Tp __c_nint = static_cast<int>(__c + _Tp(0.5L));
#endif
const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon();
if (std::abs(__x) >= _Tp(1))
std::__throw_domain_error(__N("Argument outside unit circle "
"in __hyperg."));
else if (__isnan(__a) || __isnan(__b)
|| __isnan(__c) || __isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__c_nint == __c && __c_nint <= _Tp(0))
return std::numeric_limits<_Tp>::infinity();
else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler)
return std::pow(_Tp(1) - __x, __c - __a - __b);
else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0)
&& __x >= _Tp(0) && __x < _Tp(0.995L))
return __hyperg_series(__a, __b, __c, __x);
else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10))
{
// For integer a and b the hypergeometric function is a
// finite polynomial.
if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler)
return __hyperg_series(__a_nint, __b, __c, __x);
else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler)
return __hyperg_series(__a, __b_nint, __c, __x);
else if (__x < -_Tp(0.25L))
return __hyperg_luke(__a, __b, __c, __x);
else if (__x < _Tp(0.5L))
return __hyperg_series(__a, __b, __c, __x);
else
if (std::abs(__c) > _Tp(10))
return __hyperg_series(__a, __b, __c, __x);
else
return __hyperg_reflect(__a, __b, __c, __x);
}
else
return __hyperg_luke(__a, __b, __c, __x);
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_HYPERGEOMETRIC_TCC

34
contrib/sdk/sources/libstdc++-v3/include/tr1/inttypes.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 inttypes.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/inttypes.h
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_INTTYPES_H
#define _GLIBCXX_TR1_INTTYPES_H 1
#include <tr1/cinttypes>
#endif // _GLIBCXX_TR1_INTTYPES_H

303
contrib/sdk/sources/libstdc++-v3/include/tr1/legendre_function.tcc Normal file
View File

@@ -0,0 +1,303 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/legendre_function.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on:
// (1) Handbook of Mathematical Functions,
// ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications,
// Section 8, pp. 331-341
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
// (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 252-254
#ifndef _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
#define _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC 1
#include "special_function_util.h"
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Return the Legendre polynomial by recursion on order
* @f$ l @f$.
*
* The Legendre function of @f$ l @f$ and @f$ x @f$,
* @f$ P_l(x) @f$, is defined by:
* @f[
* P_l(x) = \frac{1}{2^l l!}\frac{d^l}{dx^l}(x^2 - 1)^{l}
* @f]
*
* @param l The order of the Legendre polynomial. @f$l >= 0@f$.
* @param x The argument of the Legendre polynomial. @f$|x| <= 1@f$.
*/
template<typename _Tp>
_Tp
__poly_legendre_p(unsigned int __l, _Tp __x)
{
if ((__x < _Tp(-1)) || (__x > _Tp(+1)))
std::__throw_domain_error(__N("Argument out of range"
" in __poly_legendre_p."));
else if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__x == +_Tp(1))
return +_Tp(1);
else if (__x == -_Tp(1))
return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1));
else
{
_Tp __p_lm2 = _Tp(1);
if (__l == 0)
return __p_lm2;
_Tp __p_lm1 = __x;
if (__l == 1)
return __p_lm1;
_Tp __p_l = 0;
for (unsigned int __ll = 2; __ll <= __l; ++__ll)
{
// This arrangement is supposed to be better for roundoff
// protection, Arfken, 2nd Ed, Eq 12.17a.
__p_l = _Tp(2) * __x * __p_lm1 - __p_lm2
- (__x * __p_lm1 - __p_lm2) / _Tp(__ll);
__p_lm2 = __p_lm1;
__p_lm1 = __p_l;
}
return __p_l;
}
}
/**
* @brief Return the associated Legendre function by recursion
* on @f$ l @f$.
*
* The associated Legendre function is derived from the Legendre function
* @f$ P_l(x) @f$ by the Rodrigues formula:
* @f[
* P_l^m(x) = (1 - x^2)^{m/2}\frac{d^m}{dx^m}P_l(x)
* @f]
*
* @param l The order of the associated Legendre function.
* @f$ l >= 0 @f$.
* @param m The order of the associated Legendre function.
* @f$ m <= l @f$.
* @param x The argument of the associated Legendre function.
* @f$ |x| <= 1 @f$.
*/
template<typename _Tp>
_Tp
__assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x)
{
if (__x < _Tp(-1) || __x > _Tp(+1))
std::__throw_domain_error(__N("Argument out of range"
" in __assoc_legendre_p."));
else if (__m > __l)
std::__throw_domain_error(__N("Degree out of range"
" in __assoc_legendre_p."));
else if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__m == 0)
return __poly_legendre_p(__l, __x);
else
{
_Tp __p_mm = _Tp(1);
if (__m > 0)
{
// Two square roots seem more accurate more of the time
// than just one.
_Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x);
_Tp __fact = _Tp(1);
for (unsigned int __i = 1; __i <= __m; ++__i)
{
__p_mm *= -__fact * __root;
__fact += _Tp(2);
}
}
if (__l == __m)
return __p_mm;
_Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm;
if (__l == __m + 1)
return __p_mp1m;
_Tp __p_lm2m = __p_mm;
_Tp __P_lm1m = __p_mp1m;
_Tp __p_lm = _Tp(0);
for (unsigned int __j = __m + 2; __j <= __l; ++__j)
{
__p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m
- _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m);
__p_lm2m = __P_lm1m;
__P_lm1m = __p_lm;
}
return __p_lm;
}
}
/**
* @brief Return the spherical associated Legendre function.
*
* The spherical associated Legendre function of @f$ l @f$, @f$ m @f$,
* and @f$ \theta @f$ is defined as @f$ Y_l^m(\theta,0) @f$ where
* @f[
* Y_l^m(\theta,\phi) = (-1)^m[\frac{(2l+1)}{4\pi}
* \frac{(l-m)!}{(l+m)!}]
* P_l^m(\cos\theta) \exp^{im\phi}
* @f]
* is the spherical harmonic function and @f$ P_l^m(x) @f$ is the
* associated Legendre function.
*
* This function differs from the associated Legendre function by
* argument (@f$x = \cos(\theta)@f$) and by a normalization factor
* but this factor is rather large for large @f$ l @f$ and @f$ m @f$
* and so this function is stable for larger differences of @f$ l @f$
* and @f$ m @f$.
*
* @param l The order of the spherical associated Legendre function.
* @f$ l >= 0 @f$.
* @param m The order of the spherical associated Legendre function.
* @f$ m <= l @f$.
* @param theta The radian angle argument of the spherical associated
* Legendre function.
*/
template <typename _Tp>
_Tp
__sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
{
if (__isnan(__theta))
return std::numeric_limits<_Tp>::quiet_NaN();
const _Tp __x = std::cos(__theta);
if (__l < __m)
{
std::__throw_domain_error(__N("Bad argument "
"in __sph_legendre."));
}
else if (__m == 0)
{
_Tp __P = __poly_legendre_p(__l, __x);
_Tp __fact = std::sqrt(_Tp(2 * __l + 1)
/ (_Tp(4) * __numeric_constants<_Tp>::__pi()));
__P *= __fact;
return __P;
}
else if (__x == _Tp(1) || __x == -_Tp(1))
{
// m > 0 here
return _Tp(0);
}
else
{
// m > 0 and |x| < 1 here
// Starting value for recursion.
// Y_m^m(x) = sqrt( (2m+1)/(4pi m) gamma(m+1/2)/gamma(m) )
// (-1)^m (1-x^2)^(m/2) / pi^(1/4)
const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));
#if _GLIBCXX_USE_C99_MATH_TR1
const _Tp __lncirc = std::tr1::log1p(-__x * __x);
#else
const _Tp __lncirc = std::log(_Tp(1) - __x * __x);
#endif
// Gamma(m+1/2) / Gamma(m)
#if _GLIBCXX_USE_C99_MATH_TR1
const _Tp __lnpoch = std::tr1::lgamma(_Tp(__m + _Tp(0.5L)))
- std::tr1::lgamma(_Tp(__m));
#else
const _Tp __lnpoch = __log_gamma(_Tp(__m + _Tp(0.5L)))
- __log_gamma(_Tp(__m));
#endif
const _Tp __lnpre_val =
-_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi()
+ _Tp(0.5L) * (__lnpoch + __m * __lncirc);
_Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
/ (_Tp(4) * __numeric_constants<_Tp>::__pi()));
_Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
_Tp __y_mp1m = __y_mp1m_factor * __y_mm;
if (__l == __m)
{
return __y_mm;
}
else if (__l == __m + 1)
{
return __y_mp1m;
}
else
{
_Tp __y_lm = _Tp(0);
// Compute Y_l^m, l > m+1, upward recursion on l.
for ( int __ll = __m + 2; __ll <= __l; ++__ll)
{
const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m);
const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1);
const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1)
* _Tp(2 * __ll - 1));
const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1)
/ _Tp(2 * __ll - 3));
__y_lm = (__x * __y_mp1m * __fact1
- (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m);
__y_mm = __y_mp1m;
__y_mp1m = __y_lm;
}
return __y_lm;
}
}
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC

34
contrib/sdk/sources/libstdc++-v3/include/tr1/limits.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 limits.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/limits.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_LIMITS_H
#define _TR1_LIMITS_H 1
#include <tr1/climits>
#endif

186
contrib/sdk/sources/libstdc++-v3/include/tr1/math.h Normal file
View File

@@ -0,0 +1,186 @@
// TR1 math.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/math.h
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_MATH_H
#define _GLIBCXX_TR1_MATH_H 1
#include <tr1/cmath>
#if _GLIBCXX_USE_C99_MATH_TR1
using std::tr1::acos;
using std::tr1::acosh;
using std::tr1::asin;
using std::tr1::asinh;
using std::tr1::atan;
using std::tr1::atan2;
using std::tr1::atanh;
using std::tr1::cbrt;
using std::tr1::ceil;
using std::tr1::copysign;
using std::tr1::cos;
using std::tr1::cosh;
using std::tr1::erf;
using std::tr1::erfc;
using std::tr1::exp;
using std::tr1::exp2;
using std::tr1::expm1;
using std::tr1::fabs;
using std::tr1::fdim;
using std::tr1::floor;
using std::tr1::fma;
using std::tr1::fmax;
using std::tr1::fmin;
using std::tr1::fmod;
using std::tr1::frexp;
using std::tr1::hypot;
using std::tr1::ilogb;
using std::tr1::ldexp;
using std::tr1::lgamma;
using std::tr1::llrint;
using std::tr1::llround;
using std::tr1::log;
using std::tr1::log10;
using std::tr1::log1p;
using std::tr1::log2;
using std::tr1::logb;
using std::tr1::lrint;
using std::tr1::lround;
using std::tr1::nearbyint;
using std::tr1::nextafter;
using std::tr1::nexttoward;
using std::tr1::pow;
using std::tr1::remainder;
using std::tr1::remquo;
using std::tr1::rint;
using std::tr1::round;
using std::tr1::scalbln;
using std::tr1::scalbn;
using std::tr1::sin;
using std::tr1::sinh;
using std::tr1::sqrt;
using std::tr1::tan;
using std::tr1::tanh;
using std::tr1::tgamma;
using std::tr1::trunc;
#endif
using std::tr1::assoc_laguerref;
using std::tr1::assoc_laguerre;
using std::tr1::assoc_laguerrel;
using std::tr1::assoc_legendref;
using std::tr1::assoc_legendre;
using std::tr1::assoc_legendrel;
using std::tr1::betaf;
using std::tr1::beta;
using std::tr1::betal;
using std::tr1::comp_ellint_1f;
using std::tr1::comp_ellint_1;
using std::tr1::comp_ellint_1l;
using std::tr1::comp_ellint_2f;
using std::tr1::comp_ellint_2;
using std::tr1::comp_ellint_2l;
using std::tr1::comp_ellint_3f;
using std::tr1::comp_ellint_3;
using std::tr1::comp_ellint_3l;
using std::tr1::conf_hypergf;
using std::tr1::conf_hyperg;
using std::tr1::conf_hypergl;
using std::tr1::cyl_bessel_if;
using std::tr1::cyl_bessel_i;
using std::tr1::cyl_bessel_il;
using std::tr1::cyl_bessel_jf;
using std::tr1::cyl_bessel_j;
using std::tr1::cyl_bessel_jl;
using std::tr1::cyl_bessel_kf;
using std::tr1::cyl_bessel_k;
using std::tr1::cyl_bessel_kl;
using std::tr1::cyl_neumannf;
using std::tr1::cyl_neumann;
using std::tr1::cyl_neumannl;
using std::tr1::ellint_1f;
using std::tr1::ellint_1;
using std::tr1::ellint_1l;
using std::tr1::ellint_2f;
using std::tr1::ellint_2;
using std::tr1::ellint_2l;
using std::tr1::ellint_3f;
using std::tr1::ellint_3;
using std::tr1::ellint_3l;
using std::tr1::expintf;
using std::tr1::expint;
using std::tr1::expintl;
using std::tr1::hermitef;
using std::tr1::hermite;
using std::tr1::hermitel;
using std::tr1::hypergf;
using std::tr1::hyperg;
using std::tr1::hypergl;
using std::tr1::laguerref;
using std::tr1::laguerre;
using std::tr1::laguerrel;
using std::tr1::legendref;
using std::tr1::legendre;
using std::tr1::legendrel;
using std::tr1::riemann_zetaf;
using std::tr1::riemann_zeta;
using std::tr1::riemann_zetal;
using std::tr1::sph_besself;
using std::tr1::sph_bessel;
using std::tr1::sph_bessell;
using std::tr1::sph_legendref;
using std::tr1::sph_legendre;
using std::tr1::sph_legendrel;
using std::tr1::sph_neumannf;
using std::tr1::sph_neumann;
using std::tr1::sph_neumannl;
#endif // _GLIBCXX_TR1_MATH_H

52
contrib/sdk/sources/libstdc++-v3/include/tr1/memory Normal file
View File

@@ -0,0 +1,52 @@
// <tr1/memory> -*- C++ -*-
// Copyright (C) 2005-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/**
* @file tr1/memory
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_MEMORY
#define _GLIBCXX_TR1_MEMORY 1
#pragma GCC system_header
#if defined(_GLIBCXX_INCLUDE_AS_CXX11)
# error TR1 header cannot be included from C++11 header
#endif
#include <memory>
#include <exception> // std::exception
#include <typeinfo> // std::type_info in get_deleter
#include <bits/stl_algobase.h> // std::swap
#include <iosfwd> // std::basic_ostream
#include <ext/atomicity.h>
#include <ext/concurrence.h>
#include <bits/functexcept.h>
#include <bits/stl_function.h> // std::less
#include <debug/debug.h>
#include <tr1/type_traits>
#include <tr1/shared_ptr.h>
#endif // _GLIBCXX_TR1_MEMORY

435
contrib/sdk/sources/libstdc++-v3/include/tr1/modified_bessel_func.tcc Normal file
View File

@@ -0,0 +1,435 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/modified_bessel_func.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland.
//
// References:
// (1) Handbook of Mathematical Functions,
// Ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications,
// Section 9, pp. 355-434, Section 10 pp. 435-478
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
// (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
// W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
// 2nd ed, pp. 246-249.
#ifndef _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
#define _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC 1
#include "special_function_util.h"
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Compute the modified Bessel functions @f$ I_\nu(x) @f$ and
* @f$ K_\nu(x) @f$ and their first derivatives
* @f$ I'_\nu(x) @f$ and @f$ K'_\nu(x) @f$ respectively.
* These four functions are computed together for numerical
* stability.
*
* @param __nu The order of the Bessel functions.
* @param __x The argument of the Bessel functions.
* @param __Inu The output regular modified Bessel function.
* @param __Knu The output irregular modified Bessel function.
* @param __Ipnu The output derivative of the regular
* modified Bessel function.
* @param __Kpnu The output derivative of the irregular
* modified Bessel function.
*/
template <typename _Tp>
void
__bessel_ik(_Tp __nu, _Tp __x,
_Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu)
{
if (__x == _Tp(0))
{
if (__nu == _Tp(0))
{
__Inu = _Tp(1);
__Ipnu = _Tp(0);
}
else if (__nu == _Tp(1))
{
__Inu = _Tp(0);
__Ipnu = _Tp(0.5L);
}
else
{
__Inu = _Tp(0);
__Ipnu = _Tp(0);
}
__Knu = std::numeric_limits<_Tp>::infinity();
__Kpnu = -std::numeric_limits<_Tp>::infinity();
return;
}
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon();
const int __max_iter = 15000;
const _Tp __x_min = _Tp(2);
const int __nl = static_cast<int>(__nu + _Tp(0.5L));
const _Tp __mu = __nu - __nl;
const _Tp __mu2 = __mu * __mu;
const _Tp __xi = _Tp(1) / __x;
const _Tp __xi2 = _Tp(2) * __xi;
_Tp __h = __nu * __xi;
if ( __h < __fp_min )
__h = __fp_min;
_Tp __b = __xi2 * __nu;
_Tp __d = _Tp(0);
_Tp __c = __h;
int __i;
for ( __i = 1; __i <= __max_iter; ++__i )
{
__b += __xi2;
__d = _Tp(1) / (__b + __d);
__c = __b + _Tp(1) / __c;
const _Tp __del = __c * __d;
__h *= __del;
if (std::abs(__del - _Tp(1)) < __eps)
break;
}
if (__i > __max_iter)
std::__throw_runtime_error(__N("Argument x too large "
"in __bessel_ik; "
"try asymptotic expansion."));
_Tp __Inul = __fp_min;
_Tp __Ipnul = __h * __Inul;
_Tp __Inul1 = __Inul;
_Tp __Ipnu1 = __Ipnul;
_Tp __fact = __nu * __xi;
for (int __l = __nl; __l >= 1; --__l)
{
const _Tp __Inutemp = __fact * __Inul + __Ipnul;
__fact -= __xi;
__Ipnul = __fact * __Inutemp + __Inul;
__Inul = __Inutemp;
}
_Tp __f = __Ipnul / __Inul;
_Tp __Kmu, __Knu1;
if (__x < __x_min)
{
const _Tp __x2 = __x / _Tp(2);
const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
const _Tp __fact = (std::abs(__pimu) < __eps
? _Tp(1) : __pimu / std::sin(__pimu));
_Tp __d = -std::log(__x2);
_Tp __e = __mu * __d;
const _Tp __fact2 = (std::abs(__e) < __eps
? _Tp(1) : std::sinh(__e) / __e);
_Tp __gam1, __gam2, __gampl, __gammi;
__gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
_Tp __ff = __fact
* (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
_Tp __sum = __ff;
__e = std::exp(__e);
_Tp __p = __e / (_Tp(2) * __gampl);
_Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi);
_Tp __c = _Tp(1);
__d = __x2 * __x2;
_Tp __sum1 = __p;
int __i;
for (__i = 1; __i <= __max_iter; ++__i)
{
__ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
__c *= __d / __i;
__p /= __i - __mu;
__q /= __i + __mu;
const _Tp __del = __c * __ff;
__sum += __del;
const _Tp __del1 = __c * (__p - __i * __ff);
__sum1 += __del1;
if (std::abs(__del) < __eps * std::abs(__sum))
break;
}
if (__i > __max_iter)
std::__throw_runtime_error(__N("Bessel k series failed to converge "
"in __bessel_ik."));
__Kmu = __sum;
__Knu1 = __sum1 * __xi2;
}
else
{
_Tp __b = _Tp(2) * (_Tp(1) + __x);
_Tp __d = _Tp(1) / __b;
_Tp __delh = __d;
_Tp __h = __delh;
_Tp __q1 = _Tp(0);
_Tp __q2 = _Tp(1);
_Tp __a1 = _Tp(0.25L) - __mu2;
_Tp __q = __c = __a1;
_Tp __a = -__a1;
_Tp __s = _Tp(1) + __q * __delh;
int __i;
for (__i = 2; __i <= __max_iter; ++__i)
{
__a -= 2 * (__i - 1);
__c = -__a * __c / __i;
const _Tp __qnew = (__q1 - __b * __q2) / __a;
__q1 = __q2;
__q2 = __qnew;
__q += __c * __qnew;
__b += _Tp(2);
__d = _Tp(1) / (__b + __a * __d);
__delh = (__b * __d - _Tp(1)) * __delh;
__h += __delh;
const _Tp __dels = __q * __delh;
__s += __dels;
if ( std::abs(__dels / __s) < __eps )
break;
}
if (__i > __max_iter)
std::__throw_runtime_error(__N("Steed's method failed "
"in __bessel_ik."));
__h = __a1 * __h;
__Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x))
* std::exp(-__x) / __s;
__Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi;
}
_Tp __Kpmu = __mu * __xi * __Kmu - __Knu1;
_Tp __Inumu = __xi / (__f * __Kmu - __Kpmu);
__Inu = __Inumu * __Inul1 / __Inul;
__Ipnu = __Inumu * __Ipnu1 / __Inul;
for ( __i = 1; __i <= __nl; ++__i )
{
const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu;
__Kmu = __Knu1;
__Knu1 = __Knutemp;
}
__Knu = __Kmu;
__Kpnu = __nu * __xi * __Kmu - __Knu1;
return;
}
/**
* @brief Return the regular modified Bessel function of order
* \f$ \nu \f$: \f$ I_{\nu}(x) \f$.
*
* The regular modified cylindrical Bessel function is:
* @f[
* I_{\nu}(x) = \sum_{k=0}^{\infty}
* \frac{(x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
* @f]
*
* @param __nu The order of the regular modified Bessel function.
* @param __x The argument of the regular modified Bessel function.
* @return The output regular modified Bessel function.
*/
template<typename _Tp>
_Tp
__cyl_bessel_i(_Tp __nu, _Tp __x)
{
if (__nu < _Tp(0) || __x < _Tp(0))
std::__throw_domain_error(__N("Bad argument "
"in __cyl_bessel_i."));
else if (__isnan(__nu) || __isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200);
else
{
_Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
return __I_nu;
}
}
/**
* @brief Return the irregular modified Bessel function
* \f$ K_{\nu}(x) \f$ of order \f$ \nu \f$.
*
* The irregular modified Bessel function is defined by:
* @f[
* K_{\nu}(x) = \frac{\pi}{2}
* \frac{I_{-\nu}(x) - I_{\nu}(x)}{\sin \nu\pi}
* @f]
* where for integral \f$ \nu = n \f$ a limit is taken:
* \f$ lim_{\nu \to n} \f$.
*
* @param __nu The order of the irregular modified Bessel function.
* @param __x The argument of the irregular modified Bessel function.
* @return The output irregular modified Bessel function.
*/
template<typename _Tp>
_Tp
__cyl_bessel_k(_Tp __nu, _Tp __x)
{
if (__nu < _Tp(0) || __x < _Tp(0))
std::__throw_domain_error(__N("Bad argument "
"in __cyl_bessel_k."));
else if (__isnan(__nu) || __isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else
{
_Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
return __K_nu;
}
}
/**
* @brief Compute the spherical modified Bessel functions
* @f$ i_n(x) @f$ and @f$ k_n(x) @f$ and their first
* derivatives @f$ i'_n(x) @f$ and @f$ k'_n(x) @f$
* respectively.
*
* @param __n The order of the modified spherical Bessel function.
* @param __x The argument of the modified spherical Bessel function.
* @param __i_n The output regular modified spherical Bessel function.
* @param __k_n The output irregular modified spherical
* Bessel function.
* @param __ip_n The output derivative of the regular modified
* spherical Bessel function.
* @param __kp_n The output derivative of the irregular modified
* spherical Bessel function.
*/
template <typename _Tp>
void
__sph_bessel_ik(unsigned int __n, _Tp __x,
_Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n)
{
const _Tp __nu = _Tp(__n) + _Tp(0.5L);
_Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
__bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
/ std::sqrt(__x);
__i_n = __factor * __I_nu;
__k_n = __factor * __K_nu;
__ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x);
__kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x);
return;
}
/**
* @brief Compute the Airy functions
* @f$ Ai(x) @f$ and @f$ Bi(x) @f$ and their first
* derivatives @f$ Ai'(x) @f$ and @f$ Bi(x) @f$
* respectively.
*
* @param __n The order of the Airy functions.
* @param __x The argument of the Airy functions.
* @param __i_n The output Airy function.
* @param __k_n The output Airy function.
* @param __ip_n The output derivative of the Airy function.
* @param __kp_n The output derivative of the Airy function.
*/
template <typename _Tp>
void
__airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
{
const _Tp __absx = std::abs(__x);
const _Tp __rootx = std::sqrt(__absx);
const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__x > _Tp(0))
{
_Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
__bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
__Ai = __rootx * __K_nu
/ (__numeric_constants<_Tp>::__sqrt3()
* __numeric_constants<_Tp>::__pi());
__Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi()
+ _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3());
__bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
__Aip = -__x * __K_nu
/ (__numeric_constants<_Tp>::__sqrt3()
* __numeric_constants<_Tp>::__pi());
__Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi()
+ _Tp(2) * __I_nu
/ __numeric_constants<_Tp>::__sqrt3());
}
else if (__x < _Tp(0))
{
_Tp __J_nu, __Jp_nu, __N_nu, __Np_nu;
__bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
__Ai = __rootx * (__J_nu
- __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
__Bi = -__rootx * (__N_nu
+ __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
__bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
__Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3()
+ __J_nu) / _Tp(2);
__Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3()
- __N_nu) / _Tp(2);
}
else
{
// Reference:
// Abramowitz & Stegun, page 446 section 10.4.4 on Airy functions.
// The number is Ai(0) = 3^{-2/3}/\Gamma(2/3).
__Ai = _Tp(0.35502805388781723926L);
__Bi = __Ai * __numeric_constants<_Tp>::__sqrt3();
// Reference:
// Abramowitz & Stegun, page 446 section 10.4.5 on Airy functions.
// The number is Ai'(0) = -3^{-1/3}/\Gamma(1/3).
__Aip = -_Tp(0.25881940379280679840L);
__Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3();
}
return;
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC

124
contrib/sdk/sources/libstdc++-v3/include/tr1/poly_hermite.tcc Normal file
View File

@@ -0,0 +1,124 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/poly_hermite.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on:
// (1) Handbook of Mathematical Functions,
// Ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications, Section 22 pp. 773-802
#ifndef _GLIBCXX_TR1_POLY_HERMITE_TCC
#define _GLIBCXX_TR1_POLY_HERMITE_TCC 1
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief This routine returns the Hermite polynomial
* of order n: \f$ H_n(x) \f$ by recursion on n.
*
* The Hermite polynomial is defined by:
* @f[
* H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2}
* @f]
*
* @param __n The order of the Hermite polynomial.
* @param __x The argument of the Hermite polynomial.
* @return The value of the Hermite polynomial of order n
* and argument x.
*/
template<typename _Tp>
_Tp
__poly_hermite_recursion(unsigned int __n, _Tp __x)
{
// Compute H_0.
_Tp __H_0 = 1;
if (__n == 0)
return __H_0;
// Compute H_1.
_Tp __H_1 = 2 * __x;
if (__n == 1)
return __H_1;
// Compute H_n.
_Tp __H_n, __H_nm1, __H_nm2;
unsigned int __i;
for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i)
{
__H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2);
__H_nm2 = __H_nm1;
__H_nm1 = __H_n;
}
return __H_n;
}
/**
* @brief This routine returns the Hermite polynomial
* of order n: \f$ H_n(x) \f$.
*
* The Hermite polynomial is defined by:
* @f[
* H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2}
* @f]
*
* @param __n The order of the Hermite polynomial.
* @param __x The argument of the Hermite polynomial.
* @return The value of the Hermite polynomial of order n
* and argument x.
*/
template<typename _Tp>
inline _Tp
__poly_hermite(unsigned int __n, _Tp __x)
{
if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else
return __poly_hermite_recursion(__n, __x);
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_POLY_HERMITE_TCC

319
contrib/sdk/sources/libstdc++-v3/include/tr1/poly_laguerre.tcc Normal file
View File

@@ -0,0 +1,319 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/poly_laguerre.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on:
// (1) Handbook of Mathematical Functions,
// Ed. Milton Abramowitz and Irene A. Stegun,
// Dover Publications,
// Section 13, pp. 509-510, Section 22 pp. 773-802
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
#ifndef _GLIBCXX_TR1_POLY_LAGUERRE_TCC
#define _GLIBCXX_TR1_POLY_LAGUERRE_TCC 1
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief This routine returns the associated Laguerre polynomial
* of order @f$ n @f$, degree @f$ \alpha @f$ for large n.
* Abramowitz & Stegun, 13.5.21
*
* @param __n The order of the Laguerre function.
* @param __alpha The degree of the Laguerre function.
* @param __x The argument of the Laguerre function.
* @return The value of the Laguerre function of order n,
* degree @f$ \alpha @f$, and argument x.
*
* This is from the GNU Scientific Library.
*/
template<typename _Tpa, typename _Tp>
_Tp
__poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x)
{
const _Tp __a = -_Tp(__n);
const _Tp __b = _Tp(__alpha1) + _Tp(1);
const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
const _Tp __cos2th = __x / __eta;
const _Tp __sin2th = _Tp(1) - __cos2th;
const _Tp __th = std::acos(std::sqrt(__cos2th));
const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2()
* __numeric_constants<_Tp>::__pi_2()
* __eta * __eta * __cos2th * __sin2th;
#if _GLIBCXX_USE_C99_MATH_TR1
const _Tp __lg_b = std::tr1::lgamma(_Tp(__n) + __b);
const _Tp __lnfact = std::tr1::lgamma(_Tp(__n + 1));
#else
const _Tp __lg_b = __log_gamma(_Tp(__n) + __b);
const _Tp __lnfact = __log_gamma(_Tp(__n + 1));
#endif
_Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b)
* std::log(_Tp(0.25L) * __x * __eta);
_Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h);
_Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x
+ __pre_term1 - __pre_term2;
_Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi());
_Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta
* (_Tp(2) * __th
- std::sin(_Tp(2) * __th))
+ __numeric_constants<_Tp>::__pi_4());
_Tp __ser = __ser_term1 + __ser_term2;
return std::exp(__lnpre) * __ser;
}
/**
* @brief Evaluate the polynomial based on the confluent hypergeometric
* function in a safe way, with no restriction on the arguments.
*
* The associated Laguerre function is defined by
* @f[
* L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
* _1F_1(-n; \alpha + 1; x)
* @f]
* where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
* @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
*
* This function assumes x != 0.
*
* This is from the GNU Scientific Library.
*/
template<typename _Tpa, typename _Tp>
_Tp
__poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x)
{
const _Tp __b = _Tp(__alpha1) + _Tp(1);
const _Tp __mx = -__x;
const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
: ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));
// Get |x|^n/n!
_Tp __tc = _Tp(1);
const _Tp __ax = std::abs(__x);
for (unsigned int __k = 1; __k <= __n; ++__k)
__tc *= (__ax / __k);
_Tp __term = __tc * __tc_sgn;
_Tp __sum = __term;
for (int __k = int(__n) - 1; __k >= 0; --__k)
{
__term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k))
* _Tp(__k + 1) / __mx;
__sum += __term;
}
return __sum;
}
/**
* @brief This routine returns the associated Laguerre polynomial
* of order @f$ n @f$, degree @f$ \alpha @f$: @f$ L_n^\alpha(x) @f$
* by recursion.
*
* The associated Laguerre function is defined by
* @f[
* L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
* _1F_1(-n; \alpha + 1; x)
* @f]
* where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
* @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
*
* The associated Laguerre polynomial is defined for integral
* @f$ \alpha = m @f$ by:
* @f[
* L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
* @f]
* where the Laguerre polynomial is defined by:
* @f[
* L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
* @f]
*
* @param __n The order of the Laguerre function.
* @param __alpha The degree of the Laguerre function.
* @param __x The argument of the Laguerre function.
* @return The value of the Laguerre function of order n,
* degree @f$ \alpha @f$, and argument x.
*/
template<typename _Tpa, typename _Tp>
_Tp
__poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x)
{
// Compute l_0.
_Tp __l_0 = _Tp(1);
if (__n == 0)
return __l_0;
// Compute l_1^alpha.
_Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
if (__n == 1)
return __l_1;
// Compute l_n^alpha by recursion on n.
_Tp __l_n2 = __l_0;
_Tp __l_n1 = __l_1;
_Tp __l_n = _Tp(0);
for (unsigned int __nn = 2; __nn <= __n; ++__nn)
{
__l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
* __l_n1 / _Tp(__nn)
- (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
__l_n2 = __l_n1;
__l_n1 = __l_n;
}
return __l_n;
}
/**
* @brief This routine returns the associated Laguerre polynomial
* of order n, degree @f$ \alpha @f$: @f$ L_n^alpha(x) @f$.
*
* The associated Laguerre function is defined by
* @f[
* L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
* _1F_1(-n; \alpha + 1; x)
* @f]
* where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
* @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
*
* The associated Laguerre polynomial is defined for integral
* @f$ \alpha = m @f$ by:
* @f[
* L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
* @f]
* where the Laguerre polynomial is defined by:
* @f[
* L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
* @f]
*
* @param __n The order of the Laguerre function.
* @param __alpha The degree of the Laguerre function.
* @param __x The argument of the Laguerre function.
* @return The value of the Laguerre function of order n,
* degree @f$ \alpha @f$, and argument x.
*/
template<typename _Tpa, typename _Tp>
_Tp
__poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x)
{
if (__x < _Tp(0))
std::__throw_domain_error(__N("Negative argument "
"in __poly_laguerre."));
// Return NaN on NaN input.
else if (__isnan(__x))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__n == 0)
return _Tp(1);
else if (__n == 1)
return _Tp(1) + _Tp(__alpha1) - __x;
else if (__x == _Tp(0))
{
_Tp __prod = _Tp(__alpha1) + _Tp(1);
for (unsigned int __k = 2; __k <= __n; ++__k)
__prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
return __prod;
}
else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
&& __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
return __poly_laguerre_large_n(__n, __alpha1, __x);
else if (_Tp(__alpha1) >= _Tp(0)
|| (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
return __poly_laguerre_recursion(__n, __alpha1, __x);
else
return __poly_laguerre_hyperg(__n, __alpha1, __x);
}
/**
* @brief This routine returns the associated Laguerre polynomial
* of order n, degree m: @f$ L_n^m(x) @f$.
*
* The associated Laguerre polynomial is defined for integral
* @f$ \alpha = m @f$ by:
* @f[
* L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
* @f]
* where the Laguerre polynomial is defined by:
* @f[
* L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
* @f]
*
* @param __n The order of the Laguerre polynomial.
* @param __m The degree of the Laguerre polynomial.
* @param __x The argument of the Laguerre polynomial.
* @return The value of the associated Laguerre polynomial of order n,
* degree m, and argument x.
*/
template<typename _Tp>
inline _Tp
__assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
{ return __poly_laguerre<unsigned int, _Tp>(__n, __m, __x); }
/**
* @brief This routine returns the Laguerre polynomial
* of order n: @f$ L_n(x) @f$.
*
* The Laguerre polynomial is defined by:
* @f[
* L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
* @f]
*
* @param __n The order of the Laguerre polynomial.
* @param __x The argument of the Laguerre polynomial.
* @return The value of the Laguerre polynomial of order n
* and argument x.
*/
template<typename _Tp>
inline _Tp
__laguerre(unsigned int __n, _Tp __x)
{ return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x); }
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_POLY_LAGUERRE_TCC

50
contrib/sdk/sources/libstdc++-v3/include/tr1/random Normal file
View File

@@ -0,0 +1,50 @@
// random number generation -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/**
* @file tr1/random
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_RANDOM
#define _GLIBCXX_TR1_RANDOM 1
#pragma GCC system_header
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <iosfwd>
#include <limits>
#include <ext/type_traits.h>
#include <ext/numeric_traits.h>
#include <bits/concept_check.h>
#include <debug/debug.h>
#include <tr1/type_traits>
#include <tr1/cmath>
#include <tr1/random.h>
#include <tr1/random.tcc>
#endif // _GLIBCXX_TR1_RANDOM

2417
contrib/sdk/sources/libstdc++-v3/include/tr1/random.h Normal file
View File

File diff suppressed because it is too large Load Diff

1721
contrib/sdk/sources/libstdc++-v3/include/tr1/random.tcc Normal file
View File

File diff suppressed because it is too large Load Diff

2730
contrib/sdk/sources/libstdc++-v3/include/tr1/regex Normal file
View File

File diff suppressed because it is too large Load Diff

433
contrib/sdk/sources/libstdc++-v3/include/tr1/riemann_zeta.tcc Normal file
View File

@@ -0,0 +1,433 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/riemann_zeta.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on:
// (1) Handbook of Mathematical Functions,
// Ed. by Milton Abramowitz and Irene A. Stegun,
// Dover Publications, New-York, Section 5, pp. 807-808.
// (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
// (3) Gamma, Exploring Euler's Constant, Julian Havil,
// Princeton, 2003.
#ifndef _GLIBCXX_TR1_RIEMANN_ZETA_TCC
#define _GLIBCXX_TR1_RIEMANN_ZETA_TCC 1
#include "special_function_util.h"
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Compute the Riemann zeta function @f$ \zeta(s) @f$
* by summation for s > 1.
*
* The Riemann zeta function is defined by:
* \f[
* \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
* \f]
* For s < 1 use the reflection formula:
* \f[
* \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
* \f]
*/
template<typename _Tp>
_Tp
__riemann_zeta_sum(_Tp __s)
{
// A user shouldn't get to this.
if (__s < _Tp(1))
std::__throw_domain_error(__N("Bad argument in zeta sum."));
const unsigned int max_iter = 10000;
_Tp __zeta = _Tp(0);
for (unsigned int __k = 1; __k < max_iter; ++__k)
{
_Tp __term = std::pow(static_cast<_Tp>(__k), -__s);
if (__term < std::numeric_limits<_Tp>::epsilon())
{
break;
}
__zeta += __term;
}
return __zeta;
}
/**
* @brief Evaluate the Riemann zeta function @f$ \zeta(s) @f$
* by an alternate series for s > 0.
*
* The Riemann zeta function is defined by:
* \f[
* \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
* \f]
* For s < 1 use the reflection formula:
* \f[
* \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
* \f]
*/
template<typename _Tp>
_Tp
__riemann_zeta_alt(_Tp __s)
{
_Tp __sgn = _Tp(1);
_Tp __zeta = _Tp(0);
for (unsigned int __i = 1; __i < 10000000; ++__i)
{
_Tp __term = __sgn / std::pow(__i, __s);
if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
break;
__zeta += __term;
__sgn *= _Tp(-1);
}
__zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
return __zeta;
}
/**
* @brief Evaluate the Riemann zeta function by series for all s != 1.
* Convergence is great until largish negative numbers.
* Then the convergence of the > 0 sum gets better.
*
* The series is:
* \f[
* \zeta(s) = \frac{1}{1-2^{1-s}}
* \sum_{n=0}^{\infty} \frac{1}{2^{n+1}}
* \sum_{k=0}^{n} (-1)^k \frac{n!}{(n-k)!k!} (k+1)^{-s}
* \f]
* Havil 2003, p. 206.
*
* The Riemann zeta function is defined by:
* \f[
* \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
* \f]
* For s < 1 use the reflection formula:
* \f[
* \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
* \f]
*/
template<typename _Tp>
_Tp
__riemann_zeta_glob(_Tp __s)
{
_Tp __zeta = _Tp(0);
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
// Max e exponent before overflow.
const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
* std::log(_Tp(10)) - _Tp(1);
// This series works until the binomial coefficient blows up
// so use reflection.
if (__s < _Tp(0))
{
#if _GLIBCXX_USE_C99_MATH_TR1
if (std::tr1::fmod(__s,_Tp(2)) == _Tp(0))
return _Tp(0);
else
#endif
{
_Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s);
__zeta *= std::pow(_Tp(2)
* __numeric_constants<_Tp>::__pi(), __s)
* std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
#if _GLIBCXX_USE_C99_MATH_TR1
* std::exp(std::tr1::lgamma(_Tp(1) - __s))
#else
* std::exp(__log_gamma(_Tp(1) - __s))
#endif
/ __numeric_constants<_Tp>::__pi();
return __zeta;
}
}
_Tp __num = _Tp(0.5L);
const unsigned int __maxit = 10000;
for (unsigned int __i = 0; __i < __maxit; ++__i)
{
bool __punt = false;
_Tp __sgn = _Tp(1);
_Tp __term = _Tp(0);
for (unsigned int __j = 0; __j <= __i; ++__j)
{
#if _GLIBCXX_USE_C99_MATH_TR1
_Tp __bincoeff = std::tr1::lgamma(_Tp(1 + __i))
- std::tr1::lgamma(_Tp(1 + __j))
- std::tr1::lgamma(_Tp(1 + __i - __j));
#else
_Tp __bincoeff = __log_gamma(_Tp(1 + __i))
- __log_gamma(_Tp(1 + __j))
- __log_gamma(_Tp(1 + __i - __j));
#endif
if (__bincoeff > __max_bincoeff)
{
// This only gets hit for x << 0.
__punt = true;
break;
}
__bincoeff = std::exp(__bincoeff);
__term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s);
__sgn *= _Tp(-1);
}
if (__punt)
break;
__term *= __num;
__zeta += __term;
if (std::abs(__term/__zeta) < __eps)
break;
__num *= _Tp(0.5L);
}
__zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
return __zeta;
}
/**
* @brief Compute the Riemann zeta function @f$ \zeta(s) @f$
* using the product over prime factors.
* \f[
* \zeta(s) = \Pi_{i=1}^\infty \frac{1}{1 - p_i^{-s}}
* \f]
* where @f$ {p_i} @f$ are the prime numbers.
*
* The Riemann zeta function is defined by:
* \f[
* \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
* \f]
* For s < 1 use the reflection formula:
* \f[
* \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
* \f]
*/
template<typename _Tp>
_Tp
__riemann_zeta_product(_Tp __s)
{
static const _Tp __prime[] = {
_Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19),
_Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47),
_Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79),
_Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109)
};
static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp);
_Tp __zeta = _Tp(1);
for (unsigned int __i = 0; __i < __num_primes; ++__i)
{
const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s);
__zeta *= __fact;
if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon())
break;
}
__zeta = _Tp(1) / __zeta;
return __zeta;
}
/**
* @brief Return the Riemann zeta function @f$ \zeta(s) @f$.
*
* The Riemann zeta function is defined by:
* \f[
* \zeta(s) = \sum_{k=1}^{\infty} k^{-s} for s > 1
* \frac{(2\pi)^s}{pi} sin(\frac{\pi s}{2})
* \Gamma (1 - s) \zeta (1 - s) for s < 1
* \f]
* For s < 1 use the reflection formula:
* \f[
* \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
* \f]
*/
template<typename _Tp>
_Tp
__riemann_zeta(_Tp __s)
{
if (__isnan(__s))
return std::numeric_limits<_Tp>::quiet_NaN();
else if (__s == _Tp(1))
return std::numeric_limits<_Tp>::infinity();
else if (__s < -_Tp(19))
{
_Tp __zeta = __riemann_zeta_product(_Tp(1) - __s);
__zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
* std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
#if _GLIBCXX_USE_C99_MATH_TR1
* std::exp(std::tr1::lgamma(_Tp(1) - __s))
#else
* std::exp(__log_gamma(_Tp(1) - __s))
#endif
/ __numeric_constants<_Tp>::__pi();
return __zeta;
}
else if (__s < _Tp(20))
{
// Global double sum or McLaurin?
bool __glob = true;
if (__glob)
return __riemann_zeta_glob(__s);
else
{
if (__s > _Tp(1))
return __riemann_zeta_sum(__s);
else
{
_Tp __zeta = std::pow(_Tp(2)
* __numeric_constants<_Tp>::__pi(), __s)
* std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
#if _GLIBCXX_USE_C99_MATH_TR1
* std::tr1::tgamma(_Tp(1) - __s)
#else
* std::exp(__log_gamma(_Tp(1) - __s))
#endif
* __riemann_zeta_sum(_Tp(1) - __s);
return __zeta;
}
}
}
else
return __riemann_zeta_product(__s);
}
/**
* @brief Return the Hurwitz zeta function @f$ \zeta(x,s) @f$
* for all s != 1 and x > -1.
*
* The Hurwitz zeta function is defined by:
* @f[
* \zeta(x,s) = \sum_{n=0}^{\infty} \frac{1}{(n + x)^s}
* @f]
* The Riemann zeta function is a special case:
* @f[
* \zeta(s) = \zeta(1,s)
* @f]
*
* This functions uses the double sum that converges for s != 1
* and x > -1:
* @f[
* \zeta(x,s) = \frac{1}{s-1}
* \sum_{n=0}^{\infty} \frac{1}{n + 1}
* \sum_{k=0}^{n} (-1)^k \frac{n!}{(n-k)!k!} (x+k)^{-s}
* @f]
*/
template<typename _Tp>
_Tp
__hurwitz_zeta_glob(_Tp __a, _Tp __s)
{
_Tp __zeta = _Tp(0);
const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
// Max e exponent before overflow.
const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
* std::log(_Tp(10)) - _Tp(1);
const unsigned int __maxit = 10000;
for (unsigned int __i = 0; __i < __maxit; ++__i)
{
bool __punt = false;
_Tp __sgn = _Tp(1);
_Tp __term = _Tp(0);
for (unsigned int __j = 0; __j <= __i; ++__j)
{
#if _GLIBCXX_USE_C99_MATH_TR1
_Tp __bincoeff = std::tr1::lgamma(_Tp(1 + __i))
- std::tr1::lgamma(_Tp(1 + __j))
- std::tr1::lgamma(_Tp(1 + __i - __j));
#else
_Tp __bincoeff = __log_gamma(_Tp(1 + __i))
- __log_gamma(_Tp(1 + __j))
- __log_gamma(_Tp(1 + __i - __j));
#endif
if (__bincoeff > __max_bincoeff)
{
// This only gets hit for x << 0.
__punt = true;
break;
}
__bincoeff = std::exp(__bincoeff);
__term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s);
__sgn *= _Tp(-1);
}
if (__punt)
break;
__term /= _Tp(__i + 1);
if (std::abs(__term / __zeta) < __eps)
break;
__zeta += __term;
}
__zeta /= __s - _Tp(1);
return __zeta;
}
/**
* @brief Return the Hurwitz zeta function @f$ \zeta(x,s) @f$
* for all s != 1 and x > -1.
*
* The Hurwitz zeta function is defined by:
* @f[
* \zeta(x,s) = \sum_{n=0}^{\infty} \frac{1}{(n + x)^s}
* @f]
* The Riemann zeta function is a special case:
* @f[
* \zeta(s) = \zeta(1,s)
* @f]
*/
template<typename _Tp>
inline _Tp
__hurwitz_zeta(_Tp __a, _Tp __s)
{ return __hurwitz_zeta_glob(__a, __s); }
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#endif // _GLIBCXX_TR1_RIEMANN_ZETA_TCC

1172
contrib/sdk/sources/libstdc++-v3/include/tr1/shared_ptr.h Normal file
View File

File diff suppressed because it is too large Load Diff

135
contrib/sdk/sources/libstdc++-v3/include/tr1/special_function_util.h Normal file
View File

@@ -0,0 +1,135 @@
// Special functions -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/special_function_util.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/cmath}
*/
//
// ISO C++ 14882 TR1: 5.2 Special functions
//
// Written by Edward Smith-Rowland based on numerous mathematics books.
#ifndef _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
#define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
namespace __detail
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// A class to encapsulate type dependent floating point
/// constants. Not everything will be able to be expressed as
/// type logic.
template<typename _Tp>
struct __floating_point_constant
{
static const _Tp __value;
};
/// A structure for numeric constants.
template<typename _Tp>
struct __numeric_constants
{
/// Constant @f$ \pi @f$.
static _Tp __pi() throw()
{ return static_cast<_Tp>(3.1415926535897932384626433832795029L); }
/// Constant @f$ \pi / 2 @f$.
static _Tp __pi_2() throw()
{ return static_cast<_Tp>(1.5707963267948966192313216916397514L); }
/// Constant @f$ \pi / 3 @f$.
static _Tp __pi_3() throw()
{ return static_cast<_Tp>(1.0471975511965977461542144610931676L); }
/// Constant @f$ \pi / 4 @f$.
static _Tp __pi_4() throw()
{ return static_cast<_Tp>(0.7853981633974483096156608458198757L); }
/// Constant @f$ 1 / \pi @f$.
static _Tp __1_pi() throw()
{ return static_cast<_Tp>(0.3183098861837906715377675267450287L); }
/// Constant @f$ 2 / \sqrt(\pi) @f$.
static _Tp __2_sqrtpi() throw()
{ return static_cast<_Tp>(1.1283791670955125738961589031215452L); }
/// Constant @f$ \sqrt(2) @f$.
static _Tp __sqrt2() throw()
{ return static_cast<_Tp>(1.4142135623730950488016887242096981L); }
/// Constant @f$ \sqrt(3) @f$.
static _Tp __sqrt3() throw()
{ return static_cast<_Tp>(1.7320508075688772935274463415058723L); }
/// Constant @f$ \sqrt(\pi/2) @f$.
static _Tp __sqrtpio2() throw()
{ return static_cast<_Tp>(1.2533141373155002512078826424055226L); }
/// Constant @f$ 1 / sqrt(2) @f$.
static _Tp __sqrt1_2() throw()
{ return static_cast<_Tp>(0.7071067811865475244008443621048490L); }
/// Constant @f$ \log(\pi) @f$.
static _Tp __lnpi() throw()
{ return static_cast<_Tp>(1.1447298858494001741434273513530587L); }
/// Constant Euler's constant @f$ \gamma_E @f$.
static _Tp __gamma_e() throw()
{ return static_cast<_Tp>(0.5772156649015328606065120900824024L); }
/// Constant Euler-Mascheroni @f$ e @f$
static _Tp __euler() throw()
{ return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
};
#if _GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
/// This is a wrapper for the isnan function. Otherwise, for NaN,
/// all comparisons result in false. If/when we build a std::isnan
/// out of intrinsics, this will disappear completely in favor of
/// std::isnan.
template<typename _Tp>
inline bool __isnan(_Tp __x)
{ return std::isnan(__x); }
#else
template<typename _Tp>
inline bool __isnan(const _Tp __x)
{ return __builtin_isnan(__x); }
template<>
inline bool __isnan<float>(float __x)
{ return __builtin_isnanf(__x); }
template<>
inline bool __isnan<long double>(long double __x)
{ return __builtin_isnanl(__x); }
#endif
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
}
}
#endif // _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H

34
contrib/sdk/sources/libstdc++-v3/include/tr1/stdarg.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 stdarg.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/stdarg.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_STDARG_H
#define _TR1_STDARG_H 1
#include <tr1/cstdarg>
#endif

34
contrib/sdk/sources/libstdc++-v3/include/tr1/stdbool.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 stdbool.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/stdbool.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_STDBOOL_H
#define _TR1_STDBOOL_H 1
#include <tr1/cstdbool>
#endif

34
contrib/sdk/sources/libstdc++-v3/include/tr1/stdint.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 stdint.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/stdint.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_STDINT_H
#define _TR1_STDINT_H 1
#include <tr1/cstdint>
#endif

34
contrib/sdk/sources/libstdc++-v3/include/tr1/stdio.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 stdio.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/stdio.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_STDIO_H
#define _TR1_STDIO_H 1
#include <tr1/cstdio>
#endif

52
contrib/sdk/sources/libstdc++-v3/include/tr1/stdlib.h Normal file
View File

@@ -0,0 +1,52 @@
// TR1 stdlib.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/stdlib.h
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_STDLIB_H
#define _GLIBCXX_TR1_STDLIB_H 1
#include <tr1/cstdlib>
#if _GLIBCXX_HOSTED
#if _GLIBCXX_USE_C99
using std::tr1::atoll;
using std::tr1::strtoll;
using std::tr1::strtoull;
using std::tr1::abs;
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using std::tr1::div;
#endif
#endif
#endif
#endif // _GLIBCXX_TR1_STDLIB_H

34
contrib/sdk/sources/libstdc++-v3/include/tr1/tgmath.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 tgmath.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/tgmath.h
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_TGMATH_H
#define _GLIBCXX_TR1_TGMATH_H 1
#include <tr1/ctgmath>
#endif // _GLIBCXX_TR1_TGMATH_H

426
contrib/sdk/sources/libstdc++-v3/include/tr1/tuple Normal file
View File

@@ -0,0 +1,426 @@
// class template tuple -*- C++ -*-
// Copyright (C) 2004-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/tuple
* This is a TR1 C++ Library header.
*/
// Chris Jefferson <chris@bubblescope.net>
// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
#ifndef _GLIBCXX_TR1_TUPLE
#define _GLIBCXX_TR1_TUPLE 1
#pragma GCC system_header
#include <utility>
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Adds a const reference to a non-reference type.
template<typename _Tp>
struct __add_c_ref
{ typedef const _Tp& type; };
template<typename _Tp>
struct __add_c_ref<_Tp&>
{ typedef _Tp& type; };
// Adds a reference to a non-reference type.
template<typename _Tp>
struct __add_ref
{ typedef _Tp& type; };
template<typename _Tp>
struct __add_ref<_Tp&>
{ typedef _Tp& type; };
/**
* Contains the actual implementation of the @c tuple template, stored
* as a recursive inheritance hierarchy from the first element (most
* derived class) to the last (least derived class). The @c Idx
* parameter gives the 0-based index of the element stored at this
* point in the hierarchy; we use it to implement a constant-time
* get() operation.
*/
template<int _Idx, typename... _Elements>
struct _Tuple_impl;
/**
* Zero-element tuple implementation. This is the basis case for the
* inheritance recursion.
*/
template<int _Idx>
struct _Tuple_impl<_Idx> { };
/**
* Recursive tuple implementation. Here we store the @c Head element
* and derive from a @c Tuple_impl containing the remaining elements
* (which contains the @c Tail).
*/
template<int _Idx, typename _Head, typename... _Tail>
struct _Tuple_impl<_Idx, _Head, _Tail...>
: public _Tuple_impl<_Idx + 1, _Tail...>
{
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
_Head _M_head;
_Inherited& _M_tail() { return *this; }
const _Inherited& _M_tail() const { return *this; }
_Tuple_impl() : _Inherited(), _M_head() { }
explicit
_Tuple_impl(typename __add_c_ref<_Head>::type __head,
typename __add_c_ref<_Tail>::type... __tail)
: _Inherited(__tail...), _M_head(__head) { }
template<typename... _UElements>
_Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
: _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
_Tuple_impl(const _Tuple_impl& __in)
: _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
template<typename... _UElements>
_Tuple_impl&
operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
{
_M_head = __in._M_head;
_M_tail() = __in._M_tail();
return *this;
}
_Tuple_impl&
operator=(const _Tuple_impl& __in)
{
_M_head = __in._M_head;
_M_tail() = __in._M_tail();
return *this;
}
};
template<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...>
{
typedef _Tuple_impl<0, _Elements...> _Inherited;
public:
tuple() : _Inherited() { }
explicit
tuple(typename __add_c_ref<_Elements>::type... __elements)
: _Inherited(__elements...) { }
template<typename... _UElements>
tuple(const tuple<_UElements...>& __in)
: _Inherited(__in) { }
tuple(const tuple& __in)
: _Inherited(__in) { }
template<typename... _UElements>
tuple&
operator=(const tuple<_UElements...>& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
tuple&
operator=(const tuple& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
};
template<> class tuple<> { };
// 2-element tuple, with construction and assignment from a pair.
template<typename _T1, typename _T2>
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
{
typedef _Tuple_impl<0, _T1, _T2> _Inherited;
public:
tuple() : _Inherited() { }
explicit
tuple(typename __add_c_ref<_T1>::type __a1,
typename __add_c_ref<_T2>::type __a2)
: _Inherited(__a1, __a2) { }
template<typename _U1, typename _U2>
tuple(const tuple<_U1, _U2>& __in)
: _Inherited(__in) { }
tuple(const tuple& __in)
: _Inherited(__in) { }
template<typename _U1, typename _U2>
tuple(const pair<_U1, _U2>& __in)
: _Inherited(_Tuple_impl<0,
typename __add_c_ref<_U1>::type,
typename __add_c_ref<_U2>::type>(__in.first,
__in.second))
{ }
template<typename _U1, typename _U2>
tuple&
operator=(const tuple<_U1, _U2>& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
tuple&
operator=(const tuple& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
template<typename _U1, typename _U2>
tuple&
operator=(const pair<_U1, _U2>& __in)
{
this->_M_head = __in.first;
this->_M_tail()._M_head = __in.second;
return *this;
}
};
/// Gives the type of the ith element of a given tuple type.
template<int __i, typename _Tp>
struct tuple_element;
/**
* Recursive case for tuple_element: strip off the first element in
* the tuple and retrieve the (i-1)th element of the remaining tuple.
*/
template<int __i, typename _Head, typename... _Tail>
struct tuple_element<__i, tuple<_Head, _Tail...> >
: tuple_element<__i - 1, tuple<_Tail...> > { };
/**
* Basis case for tuple_element: The first element is the one we're seeking.
*/
template<typename _Head, typename... _Tail>
struct tuple_element<0, tuple<_Head, _Tail...> >
{
typedef _Head type;
};
/// Finds the size of a given tuple type.
template<typename _Tp>
struct tuple_size;
/// class tuple_size
template<typename... _Elements>
struct tuple_size<tuple<_Elements...> >
{
static const int value = sizeof...(_Elements);
};
template<typename... _Elements>
const int tuple_size<tuple<_Elements...> >::value;
template<int __i, typename _Head, typename... _Tail>
inline typename __add_ref<_Head>::type
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
{
return __t._M_head;
}
template<int __i, typename _Head, typename... _Tail>
inline typename __add_c_ref<_Head>::type
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
{
return __t._M_head;
}
// Return a reference (const reference) to the ith element of a tuple.
// Any const or non-const ref elements are returned with their original type.
template<int __i, typename... _Elements>
inline typename __add_ref<
typename tuple_element<__i, tuple<_Elements...> >::type
>::type
get(tuple<_Elements...>& __t)
{
return __get_helper<__i>(__t);
}
template<int __i, typename... _Elements>
inline typename __add_c_ref<
typename tuple_element<__i, tuple<_Elements...> >::type
>::type
get(const tuple<_Elements...>& __t)
{
return __get_helper<__i>(__t);
}
// This class helps construct the various comparison operations on tuples
template<int __check_equal_size, int __i, int __j,
typename _Tp, typename _Up>
struct __tuple_compare;
template<int __i, int __j, typename _Tp, typename _Up>
struct __tuple_compare<0, __i, __j, _Tp, _Up>
{
static bool __eq(const _Tp& __t, const _Up& __u)
{
return (get<__i>(__t) == get<__i>(__u) &&
__tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
}
static bool __less(const _Tp& __t, const _Up& __u)
{
return ((get<__i>(__t) < get<__i>(__u))
|| !(get<__i>(__u) < get<__i>(__t)) &&
__tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
}
};
template<int __i, typename _Tp, typename _Up>
struct __tuple_compare<0, __i, __i, _Tp, _Up>
{
static bool __eq(const _Tp&, const _Up&)
{ return true; }
static bool __less(const _Tp&, const _Up&)
{ return false; }
};
template<typename... _TElements, typename... _UElements>
bool
operator==(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{
typedef tuple<_TElements...> _Tp;
typedef tuple<_UElements...> _Up;
return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
}
template<typename... _TElements, typename... _UElements>
bool
operator<(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{
typedef tuple<_TElements...> _Tp;
typedef tuple<_UElements...> _Up;
return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
}
template<typename... _TElements, typename... _UElements>
inline bool
operator!=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__t == __u); }
template<typename... _TElements, typename... _UElements>
inline bool
operator>(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return __u < __t; }
template<typename... _TElements, typename... _UElements>
inline bool
operator<=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__u < __t); }
template<typename... _TElements, typename... _UElements>
inline bool
operator>=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__t < __u); }
template<typename _Tp>
class reference_wrapper;
// Helper which adds a reference to a type when given a reference_wrapper
template<typename _Tp>
struct __strip_reference_wrapper
{
typedef _Tp __type;
};
template<typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> >
{
typedef _Tp& __type;
};
template<typename _Tp>
struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
{
typedef _Tp& __type;
};
template<typename... _Elements>
inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
make_tuple(_Elements... __args)
{
typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
__result_type;
return __result_type(__args...);
}
template<typename... _Elements>
inline tuple<_Elements&...>
tie(_Elements&... __args)
{
return tuple<_Elements&...>(__args...);
}
// A class (and instance) which can be used in 'tie' when an element
// of a tuple is not required
struct _Swallow_assign
{
template<class _Tp>
_Swallow_assign&
operator=(const _Tp&)
{ return *this; }
};
// TODO: Put this in some kind of shared file.
namespace
{
_Swallow_assign ignore;
}; // anonymous namespace
_GLIBCXX_END_NAMESPACE_VERSION
}
}
#endif // _GLIBCXX_TR1_TUPLE

687
contrib/sdk/sources/libstdc++-v3/include/tr1/type_traits Normal file
View File

@@ -0,0 +1,687 @@
// TR1 type_traits -*- C++ -*-
// Copyright (C) 2004-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/type_traits
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_TYPE_TRAITS
#define _GLIBCXX_TR1_TYPE_TRAITS 1
#pragma GCC system_header
#include <bits/c++config.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup metaprogramming
* @{
*/
struct __sfinae_types
{
typedef char __one;
typedef struct { char __arr[2]; } __two;
};
#define _DEFINE_SPEC_0_HELPER \
template<>
#define _DEFINE_SPEC_1_HELPER \
template<typename _Tp>
#define _DEFINE_SPEC_2_HELPER \
template<typename _Tp, typename _Cp>
#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value) \
_DEFINE_SPEC_##_Order##_HELPER \
struct _Trait<_Type> \
: public integral_constant<bool, _Value> { };
// helper classes [4.3].
/// integral_constant
template<typename _Tp, _Tp __v>
struct integral_constant
{
static const _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant<_Tp, __v> type;
};
/// typedef for true_type
typedef integral_constant<bool, true> true_type;
/// typedef for false_type
typedef integral_constant<bool, false> false_type;
template<typename _Tp, _Tp __v>
const _Tp integral_constant<_Tp, __v>::value;
/// remove_cv
template<typename>
struct remove_cv;
template<typename>
struct __is_void_helper
: public false_type { };
_DEFINE_SPEC(0, __is_void_helper, void, true)
// primary type categories [4.5.1].
/// is_void
template<typename _Tp>
struct is_void
: public integral_constant<bool, (__is_void_helper<typename
remove_cv<_Tp>::type>::value)>
{ };
template<typename>
struct __is_integral_helper
: public false_type { };
_DEFINE_SPEC(0, __is_integral_helper, bool, true)
_DEFINE_SPEC(0, __is_integral_helper, char, true)
_DEFINE_SPEC(0, __is_integral_helper, signed char, true)
_DEFINE_SPEC(0, __is_integral_helper, unsigned char, true)
#ifdef _GLIBCXX_USE_WCHAR_T
_DEFINE_SPEC(0, __is_integral_helper, wchar_t, true)
#endif
_DEFINE_SPEC(0, __is_integral_helper, short, true)
_DEFINE_SPEC(0, __is_integral_helper, unsigned short, true)
_DEFINE_SPEC(0, __is_integral_helper, int, true)
_DEFINE_SPEC(0, __is_integral_helper, unsigned int, true)
_DEFINE_SPEC(0, __is_integral_helper, long, true)
_DEFINE_SPEC(0, __is_integral_helper, unsigned long, true)
_DEFINE_SPEC(0, __is_integral_helper, long long, true)
_DEFINE_SPEC(0, __is_integral_helper, unsigned long long, true)
/// is_integral
template<typename _Tp>
struct is_integral
: public integral_constant<bool, (__is_integral_helper<typename
remove_cv<_Tp>::type>::value)>
{ };
template<typename>
struct __is_floating_point_helper
: public false_type { };
_DEFINE_SPEC(0, __is_floating_point_helper, float, true)
_DEFINE_SPEC(0, __is_floating_point_helper, double, true)
_DEFINE_SPEC(0, __is_floating_point_helper, long double, true)
/// is_floating_point
template<typename _Tp>
struct is_floating_point
: public integral_constant<bool, (__is_floating_point_helper<typename
remove_cv<_Tp>::type>::value)>
{ };
/// is_array
template<typename>
struct is_array
: public false_type { };
template<typename _Tp, std::size_t _Size>
struct is_array<_Tp[_Size]>
: public true_type { };
template<typename _Tp>
struct is_array<_Tp[]>
: public true_type { };
template<typename>
struct __is_pointer_helper
: public false_type { };
_DEFINE_SPEC(1, __is_pointer_helper, _Tp*, true)
/// is_pointer
template<typename _Tp>
struct is_pointer
: public integral_constant<bool, (__is_pointer_helper<typename
remove_cv<_Tp>::type>::value)>
{ };
/// is_reference
template<typename _Tp>
struct is_reference;
/// is_function
template<typename _Tp>
struct is_function;
template<typename>
struct __is_member_object_pointer_helper
: public false_type { };
_DEFINE_SPEC(2, __is_member_object_pointer_helper, _Tp _Cp::*,
!is_function<_Tp>::value)
/// is_member_object_pointer
template<typename _Tp>
struct is_member_object_pointer
: public integral_constant<bool, (__is_member_object_pointer_helper<
typename remove_cv<_Tp>::type>::value)>
{ };
template<typename>
struct __is_member_function_pointer_helper
: public false_type { };
_DEFINE_SPEC(2, __is_member_function_pointer_helper, _Tp _Cp::*,
is_function<_Tp>::value)
/// is_member_function_pointer
template<typename _Tp>
struct is_member_function_pointer
: public integral_constant<bool, (__is_member_function_pointer_helper<
typename remove_cv<_Tp>::type>::value)>
{ };
/// is_enum
template<typename _Tp>
struct is_enum
: public integral_constant<bool, __is_enum(_Tp)>
{ };
/// is_union
template<typename _Tp>
struct is_union
: public integral_constant<bool, __is_union(_Tp)>
{ };
/// is_class
template<typename _Tp>
struct is_class
: public integral_constant<bool, __is_class(_Tp)>
{ };
/// is_function
template<typename>
struct is_function
: public false_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...)>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......)>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile>
: public true_type { };
// composite type traits [4.5.2].
/// is_arithmetic
template<typename _Tp>
struct is_arithmetic
: public integral_constant<bool, (is_integral<_Tp>::value
|| is_floating_point<_Tp>::value)>
{ };
/// is_fundamental
template<typename _Tp>
struct is_fundamental
: public integral_constant<bool, (is_arithmetic<_Tp>::value
|| is_void<_Tp>::value)>
{ };
/// is_object
template<typename _Tp>
struct is_object
: public integral_constant<bool, !(is_function<_Tp>::value
|| is_reference<_Tp>::value
|| is_void<_Tp>::value)>
{ };
/// is_member_pointer
template<typename _Tp>
struct is_member_pointer;
/// is_scalar
template<typename _Tp>
struct is_scalar
: public integral_constant<bool, (is_arithmetic<_Tp>::value
|| is_enum<_Tp>::value
|| is_pointer<_Tp>::value
|| is_member_pointer<_Tp>::value)>
{ };
/// is_compound
template<typename _Tp>
struct is_compound
: public integral_constant<bool, !is_fundamental<_Tp>::value> { };
/// is_member_pointer
template<typename _Tp>
struct __is_member_pointer_helper
: public false_type { };
_DEFINE_SPEC(2, __is_member_pointer_helper, _Tp _Cp::*, true)
template<typename _Tp>
struct is_member_pointer
: public integral_constant<bool, (__is_member_pointer_helper<
typename remove_cv<_Tp>::type>::value)>
{ };
// type properties [4.5.3].
/// is_const
template<typename>
struct is_const
: public false_type { };
template<typename _Tp>
struct is_const<_Tp const>
: public true_type { };
/// is_volatile
template<typename>
struct is_volatile
: public false_type { };
template<typename _Tp>
struct is_volatile<_Tp volatile>
: public true_type { };
/// is_empty
template<typename _Tp>
struct is_empty
: public integral_constant<bool, __is_empty(_Tp)>
{ };
/// is_polymorphic
template<typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
/// is_abstract
template<typename _Tp>
struct is_abstract
: public integral_constant<bool, __is_abstract(_Tp)>
{ };
/// has_virtual_destructor
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ };
/// alignment_of
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { };
/// rank
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
/// extent
template<typename, unsigned _Uint = 0>
struct extent
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? _Size : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
// relationships between types [4.6].
/// is_same
template<typename, typename>
struct is_same
: public false_type { };
template<typename _Tp>
struct is_same<_Tp, _Tp>
: public true_type { };
// const-volatile modifications [4.7.1].
/// remove_const
template<typename _Tp>
struct remove_const
{ typedef _Tp type; };
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
/// remove_volatile
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
/// remove_cv
template<typename _Tp>
struct remove_cv
{
typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type;
};
/// add_const
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
/// add_volatile
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
/// add_cv
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
// array modifications [4.7.3].
/// remove_extent
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
/// remove_all_extents
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
// pointer modifications [4.7.4].
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
/// remove_pointer
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
{ };
template<typename>
struct remove_reference;
/// add_pointer
template<typename _Tp>
struct add_pointer
{ typedef typename remove_reference<_Tp>::type* type; };
template<typename>
struct is_reference
: public false_type { };
template<typename _Tp>
struct is_reference<_Tp&>
: public true_type { };
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp) || is_void<_Tp>::value>
{ };
template<typename _Tp>
struct has_trivial_constructor
: public integral_constant<bool, is_pod<_Tp>::value>
{ };
template<typename _Tp>
struct has_trivial_copy
: public integral_constant<bool, is_pod<_Tp>::value>
{ };
template<typename _Tp>
struct has_trivial_assign
: public integral_constant<bool, is_pod<_Tp>::value>
{ };
template<typename _Tp>
struct has_trivial_destructor
: public integral_constant<bool, is_pod<_Tp>::value>
{ };
template<typename _Tp>
struct has_nothrow_constructor
: public integral_constant<bool, is_pod<_Tp>::value>
{ };
template<typename _Tp>
struct has_nothrow_copy
: public integral_constant<bool, is_pod<_Tp>::value>
{ };
template<typename _Tp>
struct has_nothrow_assign
: public integral_constant<bool, is_pod<_Tp>::value>
{ };
template<typename>
struct __is_signed_helper
: public false_type { };
_DEFINE_SPEC(0, __is_signed_helper, signed char, true)
_DEFINE_SPEC(0, __is_signed_helper, short, true)
_DEFINE_SPEC(0, __is_signed_helper, int, true)
_DEFINE_SPEC(0, __is_signed_helper, long, true)
_DEFINE_SPEC(0, __is_signed_helper, long long, true)
template<typename _Tp>
struct is_signed
: public integral_constant<bool, (__is_signed_helper<typename
remove_cv<_Tp>::type>::value)>
{ };
template<typename>
struct __is_unsigned_helper
: public false_type { };
_DEFINE_SPEC(0, __is_unsigned_helper, unsigned char, true)
_DEFINE_SPEC(0, __is_unsigned_helper, unsigned short, true)
_DEFINE_SPEC(0, __is_unsigned_helper, unsigned int, true)
_DEFINE_SPEC(0, __is_unsigned_helper, unsigned long, true)
_DEFINE_SPEC(0, __is_unsigned_helper, unsigned long long, true)
template<typename _Tp>
struct is_unsigned
: public integral_constant<bool, (__is_unsigned_helper<typename
remove_cv<_Tp>::type>::value)>
{ };
template<typename _Base, typename _Derived>
struct __is_base_of_helper
{
typedef typename remove_cv<_Base>::type _NoCv_Base;
typedef typename remove_cv<_Derived>::type _NoCv_Derived;
static const bool __value = (is_same<_Base, _Derived>::value
|| (__is_base_of(_Base, _Derived)
&& !is_same<_NoCv_Base,
_NoCv_Derived>::value));
};
template<typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool,
__is_base_of_helper<_Base, _Derived>::__value>
{ };
template<typename _From, typename _To>
struct __is_convertible_simple
: public __sfinae_types
{
private:
static __one __test(_To);
static __two __test(...);
static _From __makeFrom();
public:
static const bool __value = sizeof(__test(__makeFrom())) == 1;
};
template<typename _Tp>
struct add_reference;
template<typename _Tp>
struct __is_int_or_cref
{
typedef typename remove_reference<_Tp>::type __rr_Tp;
static const bool __value = (is_integral<_Tp>::value
|| (is_integral<__rr_Tp>::value
&& is_const<__rr_Tp>::value
&& !is_volatile<__rr_Tp>::value));
};
template<typename _From, typename _To,
bool = (is_void<_From>::value || is_void<_To>::value
|| is_function<_To>::value || is_array<_To>::value
// This special case is here only to avoid warnings.
|| (is_floating_point<typename
remove_reference<_From>::type>::value
&& __is_int_or_cref<_To>::__value))>
struct __is_convertible_helper
{
// "An imaginary lvalue of type From...".
static const bool __value = (__is_convertible_simple<typename
add_reference<_From>::type, _To>::__value);
};
template<typename _From, typename _To>
struct __is_convertible_helper<_From, _To, true>
{ static const bool __value = (is_void<_To>::value
|| (__is_int_or_cref<_To>::__value
&& !is_void<_From>::value)); };
template<typename _From, typename _To>
struct is_convertible
: public integral_constant<bool,
__is_convertible_helper<_From, _To>::__value>
{ };
// reference modifications [4.7.2].
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
// NB: Careful with reference to void.
template<typename _Tp, bool = (is_void<_Tp>::value
|| is_reference<_Tp>::value)>
struct __add_reference_helper
{ typedef _Tp& type; };
template<typename _Tp>
struct __add_reference_helper<_Tp, true>
{ typedef _Tp type; };
template<typename _Tp>
struct add_reference
: public __add_reference_helper<_Tp>
{ };
// other transformations [4.8].
template<std::size_t _Len, std::size_t _Align>
struct aligned_storage
{
union type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) { } __align;
};
};
#undef _DEFINE_SPEC_0_HELPER
#undef _DEFINE_SPEC_1_HELPER
#undef _DEFINE_SPEC_2_HELPER
#undef _DEFINE_SPEC
/// @} group metaprogramming
_GLIBCXX_END_NAMESPACE_VERSION
}
}
#endif // _GLIBCXX_TR1_TYPE_TRAITS

44
contrib/sdk/sources/libstdc++-v3/include/tr1/unordered_map Normal file
View File

@@ -0,0 +1,44 @@
// TR1 unordered_map -*- C++ -*-
// Copyright (C) 2005-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/unordered_map
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_UNORDERED_MAP
#define _GLIBCXX_TR1_UNORDERED_MAP 1
#pragma GCC system_header
#include <utility>
#include <bits/stl_algobase.h>
#include <bits/allocator.h>
#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
#include <bits/stringfwd.h>
#include <tr1/type_traits>
#include <tr1/functional_hash.h>
#include <tr1/hashtable.h>
#include <tr1/unordered_map.h>
#endif // _GLIBCXX_TR1_UNORDERED_MAP

278
contrib/sdk/sources/libstdc++-v3/include/tr1/unordered_map.h Normal file
View File

@@ -0,0 +1,278 @@
// TR1 unordered_map implementation -*- C++ -*-
// Copyright (C) 2010-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/unordered_map.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/unordered_map}
*/
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
// NB: When we get typedef templates these class definitions
// will be unnecessary.
template<class _Key, class _Tp,
class _Hash = hash<_Key>,
class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
bool __cache_hash_code = false>
class __unordered_map
: public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, false, true>
{
typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, false, true>
_Base;
public:
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
__unordered_map(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(),
__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ }
template<typename _InputIterator>
__unordered_map(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(),
__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ }
};
template<class _Key, class _Tp,
class _Hash = hash<_Key>,
class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
bool __cache_hash_code = false>
class __unordered_multimap
: public _Hashtable<_Key, std::pair<const _Key, _Tp>,
_Alloc,
std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, false, false>
{
typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
_Alloc,
std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, false, false>
_Base;
public:
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
__unordered_multimap(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(),
__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ }
template<typename _InputIterator>
__unordered_multimap(_InputIterator __f, _InputIterator __l,
typename _Base::size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(),
__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ }
};
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void
swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __x,
__unordered_map<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void
swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __x,
__unordered_multimap<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
/**
* @brief A standard container composed of unique keys (containing
* at most one of each key value) that associates values of another type
* with the keys.
*
* @ingroup unordered_associative_containers
*
* Meets the requirements of a <a href="tables.html#65">container</a>, and
* <a href="tables.html#xx">unordered associative container</a>
*
* @param Key Type of key objects.
* @param Tp Type of mapped objects.
* @param Hash Hashing function object type, defaults to hash<Value>.
* @param Pred Predicate function object type, defaults to equal_to<Value>.
* @param Alloc Allocator type, defaults to allocator<Key>.
*
* The resulting value type of the container is std::pair<const Key, Tp>.
*/
template<class _Key, class _Tp,
class _Hash = hash<_Key>,
class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class unordered_map
: public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
{
typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
public:
typedef typename _Base::value_type value_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
unordered_map(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
unordered_map(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __eql, __a)
{ }
};
/**
* @brief A standard container composed of equivalent keys
* (possibly containing multiple of each key value) that associates
* values of another type with the keys.
*
* @ingroup unordered_associative_containers
*
* Meets the requirements of a <a href="tables.html#65">container</a>, and
* <a href="tables.html#xx">unordered associative container</a>
*
* @param Key Type of key objects.
* @param Tp Type of mapped objects.
* @param Hash Hashing function object type, defaults to hash<Value>.
* @param Pred Predicate function object type, defaults to equal_to<Value>.
* @param Alloc Allocator type, defaults to allocator<Key>.
*
* The resulting value type of the container is std::pair<const Key, Tp>.
*/
template<class _Key, class _Tp,
class _Hash = hash<_Key>,
class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class unordered_multimap
: public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
{
typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
public:
typedef typename _Base::value_type value_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
unordered_multimap(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
unordered_multimap(_InputIterator __f, _InputIterator __l,
typename _Base::size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __eql, __a)
{ }
};
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_VERSION
}
}

44
contrib/sdk/sources/libstdc++-v3/include/tr1/unordered_set Normal file
View File

@@ -0,0 +1,44 @@
// TR1 unordered_set -*- C++ -*-
// Copyright (C) 2005-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/unordered_set
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_UNORDERED_SET
#define _GLIBCXX_TR1_UNORDERED_SET 1
#pragma GCC system_header
#include <utility>
#include <bits/stl_algobase.h>
#include <bits/allocator.h>
#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
#include <bits/stringfwd.h>
#include <tr1/type_traits>
#include <tr1/functional_hash.h>
#include <tr1/hashtable.h>
#include <tr1/unordered_set.h>
#endif // _GLIBCXX_TR1_UNORDERED_SET

267
contrib/sdk/sources/libstdc++-v3/include/tr1/unordered_set.h Normal file
View File

@@ -0,0 +1,267 @@
// TR1 unordered_set implementation -*- C++ -*-
// Copyright (C) 2010-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/unordered_set.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{tr1/unordered_set}
*/
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
// NB: When we get typedef templates these class definitions
// will be unnecessary.
template<class _Value,
class _Hash = hash<_Value>,
class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value>,
bool __cache_hash_code = false>
class __unordered_set
: public _Hashtable<_Value, _Value, _Alloc,
std::_Identity<_Value>, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, true, true>
{
typedef _Hashtable<_Value, _Value, _Alloc,
std::_Identity<_Value>, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, true, true>
_Base;
public:
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
__unordered_set(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ }
template<typename _InputIterator>
__unordered_set(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ }
};
template<class _Value,
class _Hash = hash<_Value>,
class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value>,
bool __cache_hash_code = false>
class __unordered_multiset
: public _Hashtable<_Value, _Value, _Alloc,
std::_Identity<_Value>, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, true, false>
{
typedef _Hashtable<_Value, _Value, _Alloc,
std::_Identity<_Value>, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, true, false>
_Base;
public:
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
__unordered_multiset(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ }
template<typename _InputIterator>
__unordered_multiset(_InputIterator __f, _InputIterator __l,
typename _Base::size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ }
};
template<class _Value, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void
swap(__unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __x,
__unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
template<class _Value, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void
swap(__unordered_multiset<_Value, _Hash, _Pred,
_Alloc, __cache_hash_code>& __x,
__unordered_multiset<_Value, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
/**
* @brief A standard container composed of unique keys (containing
* at most one of each key value) in which the elements' keys are
* the elements themselves.
*
* @ingroup unordered_associative_containers
*
* Meets the requirements of a <a href="tables.html#65">container</a>, and
* <a href="tables.html#xx">unordered associative container</a>
*
* @param Value Type of key objects.
* @param Hash Hashing function object type, defaults to hash<Value>.
* @param Pred Predicate function object type, defaults to equal_to<Value>.
* @param Alloc Allocator type, defaults to allocator<Key>.
*/
template<class _Value,
class _Hash = hash<_Value>,
class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value> >
class unordered_set
: public __unordered_set<_Value, _Hash, _Pred, _Alloc>
{
typedef __unordered_set<_Value, _Hash, _Pred, _Alloc> _Base;
public:
typedef typename _Base::value_type value_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
unordered_set(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
unordered_set(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __eql, __a)
{ }
};
/**
* @brief A standard container composed of equivalent keys
* (possibly containing multiple of each key value) in which the
* elements' keys are the elements themselves.
*
* @ingroup unordered_associative_containers
*
* Meets the requirements of a <a href="tables.html#65">container</a>, and
* <a href="tables.html#xx">unordered associative container</a>
*
* @param Value Type of key objects.
* @param Hash Hashing function object type, defaults to hash<Value>.
* @param Pred Predicate function object type, defaults to equal_to<Value>.
* @param Alloc Allocator type, defaults to allocator<Key>.
*/
template<class _Value,
class _Hash = hash<_Value>,
class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value> >
class unordered_multiset
: public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
{
typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc> _Base;
public:
typedef typename _Base::value_type value_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
unordered_multiset(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
unordered_multiset(_InputIterator __f, _InputIterator __l,
typename _Base::size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __eql, __a)
{ }
};
template<class _Value, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
template<class _Value, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_VERSION
}
}

108
contrib/sdk/sources/libstdc++-v3/include/tr1/utility Normal file
View File

@@ -0,0 +1,108 @@
// TR1 utility -*- C++ -*-
// Copyright (C) 2004-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/utility
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_UTILITY
#define _GLIBCXX_TR1_UTILITY 1
#pragma GCC system_header
#include <bits/c++config.h>
#include <bits/stl_relops.h>
#include <bits/stl_pair.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _Tp>
class tuple_size;
template<int _Int, class _Tp>
class tuple_element;
// Various functions which give std::pair a tuple-like interface.
template<class _Tp1, class _Tp2>
struct tuple_size<std::pair<_Tp1, _Tp2> >
{ static const int value = 2; };
template<class _Tp1, class _Tp2>
const int
tuple_size<std::pair<_Tp1, _Tp2> >::value;
template<class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2> >
{ typedef _Tp1 type; };
template<class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2> >
{ typedef _Tp2 type; };
template<int _Int>
struct __pair_get;
template<>
struct __pair_get<0>
{
template<typename _Tp1, typename _Tp2>
static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair)
{ return __pair.first; }
template<typename _Tp1, typename _Tp2>
static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
{ return __pair.first; }
};
template<>
struct __pair_get<1>
{
template<typename _Tp1, typename _Tp2>
static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair)
{ return __pair.second; }
template<typename _Tp1, typename _Tp2>
static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair)
{ return __pair.second; }
};
template<int _Int, class _Tp1, class _Tp2>
inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
get(std::pair<_Tp1, _Tp2>& __in)
{ return __pair_get<_Int>::__get(__in); }
template<int _Int, class _Tp1, class _Tp2>
inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
get(const std::pair<_Tp1, _Tp2>& __in)
{ return __pair_get<_Int>::__const_get(__in); }
_GLIBCXX_END_NAMESPACE_VERSION
}
}
#endif // _GLIBCXX_TR1_UTILITY

34
contrib/sdk/sources/libstdc++-v3/include/tr1/wchar.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 wchar.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/wchar.h
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_WCHAR_H
#define _GLIBCXX_TR1_WCHAR_H 1
#include <tr1/cwchar>
#endif // _GLIBCXX_TR1_WCHAR_H

34
contrib/sdk/sources/libstdc++-v3/include/tr1/wctype.h Normal file
View File

@@ -0,0 +1,34 @@
// TR1 wctype.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/wctype.h
* This is a TR1 C++ Library header.
*/
#ifndef _GLIBCXX_TR1_WCTYPE_H
#define _GLIBCXX_TR1_WCTYPE_H 1
#include <tr1/cwctype>
#endif // _GLIBCXX_TR1_WCTYPE_H