1///////////////////////////////////////////////////////////////////////////
2//
3// Copyright (c) 2002-2012, 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 "ImathLimits.h"
85#include "ImathNamespace.h"
86#include <math.h>
87
88IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
89
90
91template <class T>
92struct Math
93{
94 static T acos (T x) {return ::acos (x: double(x));}
95 static T asin (T x) {return ::asin (x: double(x));}
96 static T atan (T x) {return ::atan (x: double(x));}
97 static T atan2 (T x, T y) {return ::atan2 (y: double(x), x: double(y));}
98 static T cos (T x) {return ::cos (x: double(x));}
99 static T sin (T x) {return ::sin (x: double(x));}
100 static T tan (T x) {return ::tan (x: double(x));}
101 static T cosh (T x) {return ::cosh (x: double(x));}
102 static T sinh (T x) {return ::sinh (x: double(x));}
103 static T tanh (T x) {return ::tanh (x: double(x));}
104 static T exp (T x) {return ::exp (x: double(x));}
105 static T log (T x) {return ::log (x: double(x));}
106 static T log10 (T x) {return ::log10 (x: double(x));}
107 static T modf (T x, T *iptr)
108 {
109 double ival;
110 T rval( ::modf (x: double(x),iptr: &ival));
111 *iptr = ival;
112 return rval;
113 }
114 static T pow (T x, T y) {return ::pow (x: double(x), y: double(y));}
115 static T sqrt (T x) {return ::sqrt (x: double(x));}
116 static T ceil (T x) {return ::ceil (x: double(x));}
117 static T fabs (T x) {return ::fabs (x: double(x));}
118 static T floor (T x) {return ::floor (x: double(x));}
119 static T fmod (T x, T y) {return ::fmod (x: double(x), y: double(y));}
120 static T hypot (T x, T y) {return ::hypot (x: double(x), y: double(y));}
121};
122
123
124template <>
125struct Math<float>
126{
127 static float acos (float x) {return ::acosf (x: x);}
128 static float asin (float x) {return ::asinf (x: x);}
129 static float atan (float x) {return ::atanf (x: x);}
130 static float atan2 (float x, float y) {return ::atan2f (y: x, x: y);}
131 static float cos (float x) {return ::cosf (x: x);}
132 static float sin (float x) {return ::sinf (x: x);}
133 static float tan (float x) {return ::tanf (x: x);}
134 static float cosh (float x) {return ::coshf (x: x);}
135 static float sinh (float x) {return ::sinhf (x: x);}
136 static float tanh (float x) {return ::tanhf (x: x);}
137 static float exp (float x) {return ::expf (x: x);}
138 static float log (float x) {return ::logf (x: x);}
139 static float log10 (float x) {return ::log10f (x: x);}
140 static float modf (float x, float *y) {return ::modff (x: x, iptr: y);}
141 static float pow (float x, float y) {return ::powf (x: x, y: y);}
142 static float sqrt (float x) {return ::sqrtf (x: x);}
143 static float ceil (float x) {return ::ceilf (x: x);}
144 static float fabs (float x) {return ::fabsf (x: x);}
145 static float floor (float x) {return ::floorf (x: x);}
146 static float fmod (float x, float y) {return ::fmodf (x: x, y: y);}
147#if !defined(_MSC_VER)
148 static float hypot (float x, float y) {return ::hypotf (x: x, y: y);}
149#else
150 static float hypot (float x, float y) {return ::sqrtf(x*x + y*y);}
151#endif
152};
153
154
155//--------------------------------------------------------------------------
156// Don Hatch's version of sin(x)/x, which is accurate for very small x.
157// Returns 1 for x == 0.
158//--------------------------------------------------------------------------
159
160template <class T>
161inline T
162sinx_over_x (T x)
163{
164 if (x * x < limits<T>::epsilon())
165 return T (1);
166 else
167 return Math<T>::sin (x) / x;
168}
169
170
171//--------------------------------------------------------------------------
172// Compare two numbers and test if they are "approximately equal":
173//
174// equalWithAbsError (x1, x2, e)
175//
176// Returns true if x1 is the same as x2 with an absolute error of
177// no more than e,
178//
179// abs (x1 - x2) <= e
180//
181// equalWithRelError (x1, x2, e)
182//
183// Returns true if x1 is the same as x2 with an relative error of
184// no more than e,
185//
186// abs (x1 - x2) <= e * x1
187//
188//--------------------------------------------------------------------------
189
190template <class T>
191inline bool
192equalWithAbsError (T x1, T x2, T e)
193{
194 return ((x1 > x2)? x1 - x2: x2 - x1) <= e;
195}
196
197
198template <class T>
199inline bool
200equalWithRelError (T x1, T x2, T e)
201{
202 return ((x1 > x2)? x1 - x2: x2 - x1) <= e * ((x1 > 0)? x1: -x1);
203}
204
205
206IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
207
208#endif // INCLUDED_IMATHMATH_H
209

source code of include/OpenEXR/ImathMath.h