epoc32/include/stdapis/boost/math/complex/atanh.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:27:01 +0100
branchSymbian2
changeset 3 e1b950c65cb4
parent 2 epoc32/include/stdapis/boost/math/special_functions/atanh.hpp@2fe1408b6811
child 4 837f303aceeb
permissions -rw-r--r--
Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
williamr@2
     1
//    boost atanh.hpp header file
williamr@2
     2
williamr@2
     3
//  (C) Copyright Hubert Holin 2001.
williamr@2
     4
//  Distributed under the Boost Software License, Version 1.0. (See
williamr@2
     5
//  accompanying file LICENSE_1_0.txt or copy at
williamr@2
     6
//  http://www.boost.org/LICENSE_1_0.txt)
williamr@2
     7
williamr@2
     8
// See http://www.boost.org for updates, documentation, and revision history.
williamr@2
     9
williamr@2
    10
#ifndef BOOST_ATANH_HPP
williamr@2
    11
#define BOOST_ATANH_HPP
williamr@2
    12
williamr@2
    13
williamr@2
    14
#include <cmath>
williamr@2
    15
#include <limits>
williamr@2
    16
#include <string>
williamr@2
    17
#include <stdexcept>
williamr@2
    18
williamr@2
    19
williamr@2
    20
#include <boost/config.hpp>
williamr@2
    21
williamr@2
    22
williamr@2
    23
// This is the inverse of the hyperbolic tangent function.
williamr@2
    24
williamr@2
    25
namespace boost
williamr@2
    26
{
williamr@2
    27
    namespace math
williamr@2
    28
    {
williamr@2
    29
#if defined(__GNUC__) && (__GNUC__ < 3)
williamr@2
    30
        // gcc 2.x ignores function scope using declarations,
williamr@2
    31
        // put them in the scope of the enclosing namespace instead:
williamr@2
    32
        
williamr@2
    33
        using    ::std::abs;
williamr@2
    34
        using    ::std::sqrt;
williamr@2
    35
        using    ::std::log;
williamr@2
    36
        
williamr@2
    37
        using    ::std::numeric_limits;
williamr@2
    38
#endif
williamr@2
    39
        
williamr@2
    40
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
williamr@2
    41
        // This is the main fare
williamr@2
    42
        
williamr@2
    43
        template<typename T>
williamr@2
    44
        inline T    atanh(const T x)
williamr@2
    45
        {
williamr@2
    46
            using    ::std::abs;
williamr@2
    47
            using    ::std::sqrt;
williamr@2
    48
            using    ::std::log;
williamr@2
    49
            
williamr@2
    50
            using    ::std::numeric_limits;
williamr@2
    51
            
williamr@2
    52
            T const            one = static_cast<T>(1);
williamr@2
    53
            T const            two = static_cast<T>(2);
williamr@2
    54
            
williamr@2
    55
            static T const    taylor_2_bound = sqrt(numeric_limits<T>::epsilon());
williamr@2
    56
            static T const    taylor_n_bound = sqrt(taylor_2_bound);
williamr@2
    57
            
williamr@2
    58
            if        (x < -one)
williamr@2
    59
            {
williamr@2
    60
                if    (numeric_limits<T>::has_quiet_NaN)
williamr@2
    61
                {
williamr@2
    62
                    return(numeric_limits<T>::quiet_NaN());
williamr@2
    63
                }
williamr@2
    64
                else
williamr@2
    65
                {
williamr@2
    66
                    ::std::string        error_reporting("Argument to atanh is strictly greater than +1 or strictly smaller than -1!");
williamr@2
    67
                    ::std::domain_error  bad_argument(error_reporting);
williamr@2
    68
                    
williamr@2
    69
                    throw(bad_argument);
williamr@2
    70
                }
williamr@2
    71
            }
williamr@2
    72
            else if    (x < -one+numeric_limits<T>::epsilon())
williamr@2
    73
            {
williamr@2
    74
                if    (numeric_limits<T>::has_infinity)
williamr@2
    75
                {
williamr@2
    76
                    return(-numeric_limits<T>::infinity());
williamr@2
    77
                }
williamr@2
    78
                else
williamr@2
    79
                {
williamr@2
    80
                    ::std::string        error_reporting("Argument to atanh is -1 (result: -Infinity)!");
williamr@2
    81
                    ::std::out_of_range  bad_argument(error_reporting);
williamr@2
    82
                    
williamr@2
    83
                    throw(bad_argument);
williamr@2
    84
                }
williamr@2
    85
            }
williamr@2
    86
            else if    (x > +one-numeric_limits<T>::epsilon())
williamr@2
    87
            {
williamr@2
    88
                if    (numeric_limits<T>::has_infinity)
williamr@2
    89
                {
williamr@2
    90
                    return(+numeric_limits<T>::infinity());
williamr@2
    91
                }
williamr@2
    92
                else
williamr@2
    93
                {
williamr@2
    94
                    ::std::string        error_reporting("Argument to atanh is +1 (result: +Infinity)!");
williamr@2
    95
                    ::std::out_of_range  bad_argument(error_reporting);
williamr@2
    96
                    
williamr@2
    97
                    throw(bad_argument);
williamr@2
    98
                }
williamr@2
    99
            }
williamr@2
   100
            else if    (x > +one)
williamr@2
   101
            {
williamr@2
   102
                if    (numeric_limits<T>::has_quiet_NaN)
williamr@2
   103
                {
williamr@2
   104
                    return(numeric_limits<T>::quiet_NaN());
williamr@2
   105
                }
williamr@2
   106
                else
williamr@2
   107
                {
williamr@2
   108
                    ::std::string        error_reporting("Argument to atanh is strictly greater than +1 or strictly smaller than -1!");
williamr@2
   109
                    ::std::domain_error  bad_argument(error_reporting);
williamr@2
   110
                    
williamr@2
   111
                    throw(bad_argument);
williamr@2
   112
                }
williamr@2
   113
            }
williamr@2
   114
            else if    (abs(x) >= taylor_n_bound)
williamr@2
   115
            {
williamr@2
   116
                return(log( (one + x) / (one - x) ) / two);
williamr@2
   117
            }
williamr@2
   118
            else
williamr@2
   119
            {
williamr@2
   120
                // approximation by taylor series in x at 0 up to order 2
williamr@2
   121
                T    result = x;
williamr@2
   122
                
williamr@2
   123
                if    (abs(x) >= taylor_2_bound)
williamr@2
   124
                {
williamr@2
   125
                    T    x3 = x*x*x;
williamr@2
   126
                    
williamr@2
   127
                    // approximation by taylor series in x at 0 up to order 4
williamr@2
   128
                    result += x3/static_cast<T>(3);
williamr@2
   129
                }
williamr@2
   130
                
williamr@2
   131
                return(result);
williamr@2
   132
            }
williamr@2
   133
        }
williamr@2
   134
#else
williamr@2
   135
        // These are implementation details (for main fare see below)
williamr@2
   136
        
williamr@2
   137
        namespace detail
williamr@2
   138
        {
williamr@2
   139
            template    <
williamr@2
   140
                            typename T,
williamr@2
   141
                            bool InfinitySupported
williamr@2
   142
                        >
williamr@2
   143
            struct    atanh_helper1_t
williamr@2
   144
            {
williamr@2
   145
                static T    get_pos_infinity()
williamr@2
   146
                {
williamr@2
   147
                    return(+::std::numeric_limits<T>::infinity());
williamr@2
   148
                }
williamr@2
   149
                
williamr@2
   150
                static T    get_neg_infinity()
williamr@2
   151
                {
williamr@2
   152
                    return(-::std::numeric_limits<T>::infinity());
williamr@2
   153
                }
williamr@2
   154
            };    // boost::math::detail::atanh_helper1_t
williamr@2
   155
            
williamr@2
   156
            
williamr@2
   157
            template<typename T>
williamr@2
   158
            struct    atanh_helper1_t<T, false>
williamr@2
   159
            {
williamr@2
   160
                static T    get_pos_infinity()
williamr@2
   161
                {
williamr@2
   162
                    ::std::string        error_reporting("Argument to atanh is +1 (result: +Infinity)!");
williamr@2
   163
                    ::std::out_of_range  bad_argument(error_reporting);
williamr@2
   164
                    
williamr@2
   165
                    throw(bad_argument);
williamr@2
   166
                }
williamr@2
   167
                
williamr@2
   168
                static T    get_neg_infinity()
williamr@2
   169
                {
williamr@2
   170
                    ::std::string        error_reporting("Argument to atanh is -1 (result: -Infinity)!");
williamr@2
   171
                    ::std::out_of_range  bad_argument(error_reporting);
williamr@2
   172
                    
williamr@2
   173
                    throw(bad_argument);
williamr@2
   174
                }
williamr@2
   175
            };    // boost::math::detail::atanh_helper1_t
williamr@2
   176
            
williamr@2
   177
            
williamr@2
   178
            template    <
williamr@2
   179
                            typename T,
williamr@2
   180
                            bool QuietNanSupported
williamr@2
   181
                        >
williamr@2
   182
            struct    atanh_helper2_t
williamr@2
   183
            {
williamr@2
   184
                static T    get_NaN()
williamr@2
   185
                {
williamr@2
   186
                    return(::std::numeric_limits<T>::quiet_NaN());
williamr@2
   187
                }
williamr@2
   188
            };    // boost::detail::atanh_helper2_t
williamr@2
   189
            
williamr@2
   190
            
williamr@2
   191
            template<typename T>
williamr@2
   192
            struct    atanh_helper2_t<T, false>
williamr@2
   193
            {
williamr@2
   194
                static T    get_NaN()
williamr@2
   195
                {
williamr@2
   196
                    ::std::string        error_reporting("Argument to atanh is strictly greater than +1 or strictly smaller than -1!");
williamr@2
   197
                    ::std::domain_error  bad_argument(error_reporting);
williamr@2
   198
                    
williamr@2
   199
                    throw(bad_argument);
williamr@2
   200
                }
williamr@2
   201
            };    // boost::detail::atanh_helper2_t
williamr@2
   202
        }    // boost::detail
williamr@2
   203
        
williamr@2
   204
        
williamr@2
   205
        // This is the main fare
williamr@2
   206
        
williamr@2
   207
        template<typename T>
williamr@2
   208
        inline T    atanh(const T x)
williamr@2
   209
        {
williamr@2
   210
            using    ::std::abs;
williamr@2
   211
            using    ::std::sqrt;
williamr@2
   212
            using    ::std::log;
williamr@2
   213
            
williamr@2
   214
            using    ::std::numeric_limits;
williamr@2
   215
            
williamr@2
   216
            typedef  detail::atanh_helper1_t<T, ::std::numeric_limits<T>::has_infinity>    helper1_type;
williamr@2
   217
            typedef  detail::atanh_helper2_t<T, ::std::numeric_limits<T>::has_quiet_NaN>    helper2_type;
williamr@2
   218
            
williamr@2
   219
            
williamr@2
   220
            T const           one = static_cast<T>(1);
williamr@2
   221
            T const           two = static_cast<T>(2);
williamr@2
   222
            
williamr@2
   223
            static T const    taylor_2_bound = sqrt(numeric_limits<T>::epsilon());
williamr@2
   224
            static T const    taylor_n_bound = sqrt(taylor_2_bound);
williamr@2
   225
            
williamr@2
   226
            if        (x < -one)
williamr@2
   227
            {
williamr@2
   228
                return(helper2_type::get_NaN());
williamr@2
   229
            }
williamr@2
   230
            else if    (x < -one+numeric_limits<T>::epsilon())
williamr@2
   231
            {
williamr@2
   232
                return(helper1_type::get_neg_infinity());
williamr@2
   233
            }
williamr@2
   234
            else if    (x > +one-numeric_limits<T>::epsilon())
williamr@2
   235
            {
williamr@2
   236
                return(helper1_type::get_pos_infinity());
williamr@2
   237
            }
williamr@2
   238
            else if    (x > +one)
williamr@2
   239
            {
williamr@2
   240
                return(helper2_type::get_NaN());
williamr@2
   241
            }
williamr@2
   242
            else if    (abs(x) >= taylor_n_bound)
williamr@2
   243
            {
williamr@2
   244
                return(log( (one + x) / (one - x) ) / two);
williamr@2
   245
            }
williamr@2
   246
            else
williamr@2
   247
            {
williamr@2
   248
                // approximation by taylor series in x at 0 up to order 2
williamr@2
   249
                T    result = x;
williamr@2
   250
                
williamr@2
   251
                if    (abs(x) >= taylor_2_bound)
williamr@2
   252
                {
williamr@2
   253
                    T    x3 = x*x*x;
williamr@2
   254
                    
williamr@2
   255
                    // approximation by taylor series in x at 0 up to order 4
williamr@2
   256
                    result += x3/static_cast<T>(3);
williamr@2
   257
                }
williamr@2
   258
                
williamr@2
   259
                return(result);
williamr@2
   260
            }
williamr@2
   261
        }
williamr@2
   262
#endif /* defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) */
williamr@2
   263
    }
williamr@2
   264
}
williamr@2
   265
williamr@2
   266
#endif /* BOOST_ATANH_HPP */
williamr@2
   267