git.maemo.org Git - opencv/blob - 3rdparty/include/OpenEXR/ImathMath.h

   1 ///////////////////////////////////////////////////////////////////////////
   2 //
   3 // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
   4 // Digital Ltd. LLC
   5 //
   6 // All rights reserved.
   7 //
   8 // Redistribution and use in source and binary forms, with or without
   9 // modification, are permitted provided that the following conditions are
  10 // met:
  11 // *       Redistributions of source code must retain the above copyright
  12 // notice, this list of conditions and the following disclaimer.
  13 // *       Redistributions in binary form must reproduce the above
  14 // copyright notice, this list of conditions and the following disclaimer
  15 // in the documentation and/or other materials provided with the
  16 // distribution.
  17 // *       Neither the name of Industrial Light & Magic nor the names of
  18 // its contributors may be used to endorse or promote products derived
  19 // from this software without specific prior written permission.
  20 //
  21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 //
  33 ///////////////////////////////////////////////////////////////////////////
  34
  35
  36
  37 #ifndef INCLUDED_IMATHMATH_H
  38 #define INCLUDED_IMATHMATH_H
  39
  40 //----------------------------------------------------------------------------
  41 //
  42 //      ImathMath.h
  43 //
  44 //      This file contains template functions which call the double-
  45 //      precision math functions defined in math.h (sin(), sqrt(),
  46 //      exp() etc.), with specializations that call the faster
  47 //      single-precision versions (sinf(), sqrtf(), expf() etc.)
  48 //      when appropriate.
  49 //
  50 //      Example:
  51 //
  52 //          double x = Math<double>::sqrt (3);  // calls ::sqrt(double);
  53 //          float  y = Math<float>::sqrt (3);   // calls ::sqrtf(float);
  54 //
  55 //      When would I want to use this?
  56 //
  57 //      You may be writing a template which needs to call some function
  58 //      defined in math.h, for example to extract a square root, but you
  59 //      don't know whether to call the single- or the double-precision
  60 //      version of this function (sqrt() or sqrtf()):
  61 //
  62 //          template <class T>
  63 //          T
  64 //          glorp (T x)
  65 //          {
  66 //              return sqrt (x + 1);            // should call ::sqrtf(float)
  67 //          }                                   // if x is a float, but we
  68 //                                              // don't know if it is
  69 //
  70 //      Using the templates in this file, you can make sure that
  71 //      the appropriate version of the math function is called:
  72 //
  73 //          template <class T>
  74 //          T
  75 //          glorp (T x, T y)
  76 //          {
  77 //              return Math<T>::sqrt (x + 1);   // calls ::sqrtf(float) if x
  78 //          }                                   // is a float, ::sqrt(double)
  79 //                                              // otherwise
  80 //
  81 //----------------------------------------------------------------------------
  82
  83 #include "ImathPlatform.h"
  84 #include <math.h>
  85
  86 namespace Imath {
  87
  88
  89 template <class T>
  90 struct Math
  91 {
  92    static T     acos  (T x)             {return ::acos (double(x));}
  93    static T     asin  (T x)             {return ::asin (double(x));}
  94    static T     atan  (T x)             {return ::atan (double(x));}
  95    static T     atan2 (T x, T y)        {return ::atan2 (double(x), double(y));}
  96    static T     cos   (T x)             {return ::cos (double(x));}
  97    static T     sin   (T x)             {return ::sin (double(x));}
  98    static T     tan   (T x)             {return ::tan (double(x));}
  99    static T     cosh  (T x)             {return ::cosh (double(x));}
 100    static T     sinh  (T x)             {return ::sinh (double(x));}
 101    static T     tanh  (T x)             {return ::tanh (double(x));}
 102    static T     exp   (T x)             {return ::exp (double(x));}
 103    static T     log   (T x)             {return ::log (double(x));}
 104    static T     log10 (T x)             {return ::log10 (double(x));}
 105    static T     modf  (T x, T *iptr)
 106    {
 107         double ival;
 108         T rval( ::modf (double(x),&ival));
 109         *iptr = ival;
 110         return rval;
 111    }
 112    static T     pow   (T x, T y)        {return ::pow (double(x), double(y));}
 113    static T     sqrt  (T x)             {return ::sqrt (double(x));}
 114    static T     ceil  (T x)             {return ::ceil (double(x));}
 115    static T     fabs  (T x)             {return ::fabs (double(x));}
 116    static T     floor (T x)             {return ::floor (double(x));}
 117    static T     fmod  (T x, T y)        {return ::fmod (double(x), double(y));}
 118    static T     hypot (T x, T y)        {return ::hypot (double(x), double(y));}
 119 };
 120
 121
 122 template <>
 123 struct Math<float>
 124 {
 125    static float acos  (float x)                 {return ::acosf (x);}
 126    static float asin  (float x)                 {return ::asinf (x);}
 127    static float atan  (float x)                 {return ::atanf (x);}
 128    static float atan2 (float x, float y)        {return ::atan2f (x, y);}
 129    static float cos   (float x)                 {return ::cosf (x);}
 130    static float sin   (float x)                 {return ::sinf (x);}
 131    static float tan   (float x)                 {return ::tanf (x);}
 132    static float cosh  (float x)                 {return ::coshf (x);}
 133    static float sinh  (float x)                 {return ::sinhf (x);}
 134    static float tanh  (float x)                 {return ::tanhf (x);}
 135    static float exp   (float x)                 {return ::expf (x);}
 136    static float log   (float x)                 {return ::logf (x);}
 137    static float log10 (float x)                 {return ::log10f (x);}
 138    static float modf  (float x, float *y)       {return ::modff (x, y);}
 139    static float pow   (float x, float y)        {return ::powf (x, y);}
 140    static float sqrt  (float x)                 {return ::sqrtf (x);}
 141    static float ceil  (float x)                 {return ::ceilf (x);}
 142    static float fabs  (float x)                 {return ::fabsf (x);}
 143    static float floor (float x)                 {return ::floorf (x);}
 144    static float fmod  (float x, float y)        {return ::fmodf (x, y);}
 145 #if !defined(_MSC_VER)
 146    static float hypot (float x, float y)        {return ::hypotf (x, y);}
 147 #else
 148    static float hypot (float x, float y)        {return ::sqrtf(x*x + y*y);}
 149 #endif
 150 };
 151
 152
 153 //--------------------------------------------------------------------------
 154 // Compare two numbers and test if they are "approximately equal":
 155 //
 156 // equalWithAbsError (x1, x2, e)
 157 //
 158 //      Returns true if x1 is the same as x2 with an absolute error of
 159 //      no more than e,
 160 //
 161 //      abs (x1 - x2) <= e
 162 //
 163 // equalWithRelError (x1, x2, e)
 164 //
 165 //      Returns true if x1 is the same as x2 with an relative error of
 166 //      no more than e,
 167 //
 168 //      abs (x1 - x2) <= e * x1
 169 //
 170 //--------------------------------------------------------------------------
 171
 172 template <class T>
 173 inline bool
 174 equalWithAbsError (T x1, T x2, T e)
 175 {
 176     return ((x1 > x2)? x1 - x2: x2 - x1) <= e;
 177 }
 178
 179
 180 template <class T>
 181 inline bool
 182 equalWithRelError (T x1, T x2, T e)
 183 {
 184     return ((x1 > x2)? x1 - x2: x2 - x1) <= e * ((x1 > 0)? x1: -x1);
 185 }
 186
 187
 188
 189 } // namespace Imath
 190
 191 #endif