[template tr1_overview[]
Many of the special functions included in this library are also a part
of the either the [C99] or the [tr1].  Therefore this library
includes a thin wrapper header `boost/math/tr1.hpp` that provides
compatibility with these two standards.

There are various pros and cons to using the library in this way:

Pros:

* The header to include is lightweight (i.e. fast to compile).
* The functions have extern "C" linkage,
  and so are usable from other languages (not just C and C++).
* C99 and C++ TR1 Standard compatibility.

Cons:

* You will need to compile and link to the external Boost.Math libraries.
* Limited to support for the types, `float`, `double` and `long double`.
* Error handling is handled via setting ::errno and returning NaN's and 
infinities: this may be less flexible than an C++ exception based approach.

[note The separate libraries are required *only* if you choose to use
boost/math/tr1.hpp rather than some other Boost.Math header, the rest
of Boost.Math remains header-only.]

The separate libraries required in order to use tr1.hpp can be compiled 
using bjam from within the libs/math/build directory, or from the Boost 
root directory using the usual Boost-wide install procedure.  
Alternatively the source files are located in libs/math/src and each have
the same name as the function they implement.  The various libraries are 
named as follows:

[table
[[Name][Type][Functions]]
[[boost_math_c99f-<suffix>][float][C99 Functions]]
[[boost_math_c99-<suffix>][double][C99 Functions]]
[[boost_math_c99l-<suffix>][long double][C99 Functions]]
[[boost_math_tr1f-<suffix>][float][TR1 Functions]]
[[boost_math_tr1-<suffix>][double][TR1 Functions]]
[[boost_math_tr1l-<suffix>][long double][TR1 Functions]]
]

Where `<suffix>` encodes the compiler and build options used to 
build the libraries: for example "libboost_math_tr1-vc80-mt-gd.lib"
would be the statically linked TR1 library to use with Visual C++ 8.0, 
in multithreading debug mode, with the DLL VC++ runtime, where as
"boost_math_tr1-vc80-mt.lib" would be import library for the TR1 DLL
to be used with Visual C++ 8.0 with the release multithreaded DLL
VC++ runtime.
Refer to the getting started guide for a 
[@http://www.boost.org/doc/libs/1_35_0/more/getting_started/windows.html#library-naming 
full explanation of the `<suffix>` meanings].

[note
Visual C++ users will typically have the correct library variant to link 
against selected for them by boost/math/tr1.hpp based on your compiler
settings.

Users will need to define BOOST_MATH_TR1_DYN_LINK when building
their code if they want to link against the DLL versions of these libraries
rather than the static versions.

Users can disable auto-linking by defining BOOST_MATH_TR1_NO_LIB when 
building: this is typically only used when linking against a customised 
build of the libraries.]

[note Linux and Unix users will generally only have one variant of 
these libraries installed, and can generally just link against
-lboost_math_tr1 etc.]

[h4 Usage Recomendations]

This library now presents the user with a choice:

* To include the header only versions of the functions and have
an easier time linking, but a longer compile time.
* To include the TR1 headers and link against an external library.

Which option you choose depends largely on how you prefer to work
and how your system is set up.

For example a casual user who just needs the acosh function, would 
probably be better off including `<boost/math/special_functions/acosh.hpp>`
and using `boost::math::acosh(x)` in their code.  

However, for large scale
software development where compile times are significant, and where the
Boost libraries are already built and installed on the system, then
including `<boost/math/tr1.hpp>` and using `boost::math::tr1::acosh(x)`
will speed up compile times, reduce object files sizes (since there are 
no templates being instantiated any more), and also speed up debugging 
runtimes - since the externally compiled libraries can be 
compiler optimised, rather than built using full settings - the difference
in performance between 
[link math_toolkit.perf.getting_best 
release and debug builds can be as much as 20 times],
so for complex applications this can be a big win.

[h4 Supported C99 Functions]

See also the [link math_toolkit.extern_c.c99 
quick reference guide for these functions].

   namespace boost{ namespace math{ namespace tr1{ extern "C"{

   typedef unspecified float_t;
   typedef unspecified double_t;

   double acosh(double x);
   float acoshf(float x);
   long double acoshl(long double x);

   double asinh(double x);
   float asinhf(float x);
   long double asinhl(long double x);

   double atanh(double x);
   float atanhf(float x);
   long double atanhl(long double x);

   double cbrt(double x);
   float cbrtf(float x);
   long double cbrtl(long double x);

   double copysign(double x, double y);
   float copysignf(float x, float y);
   long double copysignl(long double x, long double y);

   double erf(double x);
   float erff(float x);
   long double erfl(long double x);

   double erfc(double x);
   float erfcf(float x);
   long double erfcl(long double x);

   double expm1(double x);
   float expm1f(float x);
   long double expm1l(long double x);

   double fmax(double x, double y);
   float fmaxf(float x, float y);
   long double fmaxl(long double x, long double y);

   double fmin(double x, double y);
   float fminf(float x, float y);
   long double fminl(long double x, long double y);

   double hypot(double x, double y);
   float hypotf(float x, float y);
   long double hypotl(long double x, long double y);

   double lgamma(double x);
   float lgammaf(float x);
   long double lgammal(long double x);

   long long llround(double x);
   long long llroundf(float x);
   long long llroundl(long double x);

   double log1p(double x);
   float log1pf(float x);
   long double log1pl(long double x);

   long lround(double x);
   long lroundf(float x);
   long lroundl(long double x);

   double nextafter(double x, double y);
   float nextafterf(float x, float y);
   long double nextafterl(long double x, long double y);

   double nexttoward(double x, long double y);
   float nexttowardf(float x, long double y);
   long double nexttowardl(long double x, long double y);

   double round(double x);
   float roundf(float x);
   long double roundl(long double x);

   double tgamma(double x);
   float tgammaf(float x);
   long double tgammal(long double x);

   double trunc(double x);
   float truncf(float x);
   long double truncl(long double x);

   }}}} // namespaces
   
[h4 Supported TR1 Functions]

See also the [link math_toolkit.extern_c.tr1 
quick reference guide for these functions].

   namespace boost{ namespace math{ namespace tr1{ extern "C"{
      
   // [5.2.1.1] associated Laguerre polynomials:
   double assoc_laguerre(unsigned n, unsigned m, double x);
   float assoc_laguerref(unsigned n, unsigned m, float x);
   long double assoc_laguerrel(unsigned n, unsigned m, long double x);

   // [5.2.1.2] associated Legendre functions:
   double assoc_legendre(unsigned l, unsigned m, double x);
   float assoc_legendref(unsigned l, unsigned m, float x);
   long double assoc_legendrel(unsigned l, unsigned m, long double x);

   // [5.2.1.3] beta function:
   double beta(double x, double y);
   float betaf(float x, float y);
   long double betal(long double x, long double y);

   // [5.2.1.4] (complete) elliptic integral of the first kind:
   double comp_ellint_1(double k);
   float comp_ellint_1f(float k);
   long double comp_ellint_1l(long double k);

   // [5.2.1.5] (complete) elliptic integral of the second kind:
   double comp_ellint_2(double k);
   float comp_ellint_2f(float k);
   long double comp_ellint_2l(long double k);

   // [5.2.1.6] (complete) elliptic integral of the third kind:
   double comp_ellint_3(double k, double nu);
   float comp_ellint_3f(float k, float nu);
   long double comp_ellint_3l(long double k, long double nu);

   // [5.2.1.8] regular modified cylindrical Bessel functions:
   double cyl_bessel_i(double nu, double x);
   float cyl_bessel_if(float nu, float x);
   long double cyl_bessel_il(long double nu, long double x);

   // [5.2.1.9] cylindrical Bessel functions (of the first kind):
   double cyl_bessel_j(double nu, double x);
   float cyl_bessel_jf(float nu, float x);
   long double cyl_bessel_jl(long double nu, long double x);

   // [5.2.1.10] irregular modified cylindrical Bessel functions:
   double cyl_bessel_k(double nu, double x);
   float cyl_bessel_kf(float nu, float x);
   long double cyl_bessel_kl(long double nu, long double x);

   // [5.2.1.11] cylindrical Neumann functions;
   // cylindrical Bessel functions (of the second kind):
   double cyl_neumann(double nu, double x);
   float cyl_neumannf(float nu, float x);
   long double cyl_neumannl(long double nu, long double x);

   // [5.2.1.12] (incomplete) elliptic integral of the first kind:
   double ellint_1(double k, double phi);
   float ellint_1f(float k, float phi);
   long double ellint_1l(long double k, long double phi);

   // [5.2.1.13] (incomplete) elliptic integral of the second kind:
   double ellint_2(double k, double phi);
   float ellint_2f(float k, float phi);
   long double ellint_2l(long double k, long double phi);

   // [5.2.1.14] (incomplete) elliptic integral of the third kind:
   double ellint_3(double k, double nu, double phi);
   float ellint_3f(float k, float nu, float phi);
   long double ellint_3l(long double k, long double nu, long double phi);

   // [5.2.1.15] exponential integral:
   double expint(double x);
   float expintf(float x);
   long double expintl(long double x);

   // [5.2.1.16] Hermite polynomials:
   double hermite(unsigned n, double x);
   float hermitef(unsigned n, float x);
   long double hermitel(unsigned n, long double x);

   // [5.2.1.18] Laguerre polynomials:
   double laguerre(unsigned n, double x);
   float laguerref(unsigned n, float x);
   long double laguerrel(unsigned n, long double x);

   // [5.2.1.19] Legendre polynomials:
   double legendre(unsigned l, double x);
   float legendref(unsigned l, float x);
   long double legendrel(unsigned l, long double x);

   // [5.2.1.20] Riemann zeta function:
   double riemann_zeta(double);
   float riemann_zetaf(float);
   long double riemann_zetal(long double);

   // [5.2.1.21] spherical Bessel functions (of the first kind):
   double sph_bessel(unsigned n, double x);
   float sph_besself(unsigned n, float x);
   long double sph_bessell(unsigned n, long double x);

   // [5.2.1.22] spherical associated Legendre functions:
   double sph_legendre(unsigned l, unsigned m, double theta);
   float sph_legendref(unsigned l, unsigned m, float theta);
   long double sph_legendrel(unsigned l, unsigned m, long double theta);

   // [5.2.1.23] spherical Neumann functions;
   // spherical Bessel functions (of the second kind):
   double sph_neumann(unsigned n, double x);
   float sph_neumannf(unsigned n, float x);
   long double sph_neumannl(unsigned n, long double x);
   
   }}}} // namespaces
   
In addition sufficient additional overloads of the `double` versions of the
above functions are provided, so that calling the function with any mixture
of `float`, `double`, `long double`, or /integer/ arguments is supported, with the
return type determined by the __arg_pomotion_rules.
   
[h4 Currently Unsupported C99 Functions]

   double exp2(double x);
   float exp2f(float x);
   long double exp2l(long double x);

   double fdim(double x, double y);
   float fdimf(float x, float y);
   long double fdiml(long double x, long double y);

   double fma(double x, double y, double z);
   float fmaf(float x, float y, float z);
   long double fmal(long double x, long double y, long double z);

   int ilogb(double x);
   int ilogbf(float x);
   int ilogbl(long double x);

   long long llrint(double x);
   long long llrintf(float x);
   long long llrintl(long double x);

   double log2(double x);
   float log2f(float x);
   long double log2l(long double x);

   double logb(double x);
   float logbf(float x);
   long double logbl(long double x);

   long lrint(double x);
   long lrintf(float x);
   long lrintl(long double x);

   double nan(const char *str);
   float nanf(const char *str);
   long double nanl(const char *str);

   double nearbyint(double x);
   float nearbyintf(float x);
   long double nearbyintl(long double x);

   double remainder(double x, double y);
   float remainderf(float x, float y);
   long double remainderl(long double x, long double y);

   double remquo(double x, double y, int *pquo);
   float remquof(float x, float y, int *pquo);
   long double remquol(long double x, long double y, int *pquo);

   double rint(double x);
   float rintf(float x);
   long double rintl(long double x);

   double scalbln(double x, long ex);
   float scalblnf(float x, long ex);
   long double scalblnl(long double x, long ex);

   double scalbn(double x, int ex);
   float scalbnf(float x, int ex);
   long double scalbnl(long double x, int ex);
   
[h4 Currently Unsupported TR1 Functions]

   // [5.2.1.7] confluent hypergeometric functions:
   double conf_hyperg(double a, double c, double x);
   float conf_hypergf(float a, float c, float x);
   long double conf_hypergl(long double a, long double c, long double x);

   // [5.2.1.17] hypergeometric functions:
   double hyperg(double a, double b, double c, double x);
   float hypergf(float a, float b, float c, float x);
   long double hypergl(long double a, long double b, long double c,
   long double x);


]

[/ 
  Copyright 2008 John Maddock and Paul A. Bristow.
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]