| Home | Libraries | People | FAQ | More

## TR By Subject: Unsupported Features

### Mathematical Special Functions.

The TR adds 23 special functions (plus float and long double overloads) to header <cmath>. However, at present there is no Boost License compatible implementation of these functions, so these are unsupported by this implementation unless your standard library supports them itself.

    namespace std {
    namespace tr1 {

    // [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.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.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.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);

    // [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);

    } // namespace tr1
    } // namespace std

Standard Conformity: Not Supported.

### Unordered Associative Set (Hash Table).

    #include <boost/tr1/unordered_set.hpp>

or

    #include <unordered_set>

This is not currently supported by Boost, although that situation is hoped to change soon.

    namespace std {
    namespace tr1 {

    template <class Value,
             class Hash = hash<Value>,
             class Pred = std::equal_to<Value>,
             class Alloc = std::allocator<Value> >
    class unordered_set;

    // [6.3.4.5] Class template unordered_multiset
    template <class Value,
             class Hash = hash<Value>,
             class Pred = std::equal_to<Value>,
             class Alloc = std::allocator<Value> >
    class unordered_multiset;

    template <class Value, class Hash, class Pred, class Alloc>
    void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
             unordered_set<Value, Hash, Pred, Alloc>& y);

    template <class Value, class Hash, class Pred, class Alloc>
    void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
             unordered_multiset<Value, Hash, Pred, Alloc>& y);

    } // namespace tr1
    } // namespace std

Configuration: Boost.Config should (automatically) define the macro BOOST_HAS_TR1_UNORDERED_SET if your standard library implements this part of TR1.

Standard Conformity: Not supported.

### Unordered Associative Map (Hash Table).

    #include <boost/tr1/unordered_map.hpp>

or

    #include <unordered_map>

This is not currently supported by Boost, although that situation is hoped to change soon.

    namespace std {
    namespace tr1 {

    // [6.3.4.4] Class template unordered_map
    template <class Key,
             class T,
             class Hash = hash<Key>,
             class Pred = std::equal_to<Key>,
             class Alloc = std::allocator<std::pair<const Key, T> > >
    class unordered_map;

    // [6.3.4.6] Class template unordered_multimap
    template <class Key,
             class T,
             class Hash = hash<Key>,
             class Pred = std::equal_to<Key>,
             class Alloc = std::allocator<std::pair<const Key, T> > >
    class unordered_multimap;

    template <class Key, class T, class Hash, class Pred, class Alloc>
    void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
             unordered_map<Key, T, Hash, Pred, Alloc>& y);

    template <class Key, class T, class Hash, class Pred, class Alloc>
    void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
             unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

    } // namespace tr1
    } // namespace std

Configuration: Boost.Config should (automatically) define the macro BOOST_HAS_TR1_UNORDERED_MAP if your standard library implements this part of TR1.

Standard Conformity: Not supported.