+++ /dev/null
-///////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
-// Digital Ltd. LLC
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Industrial Light & Magic nor the names of
-// its contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-///////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef INCLUDED_IMATHMATH_H
-#define INCLUDED_IMATHMATH_H
-
-//----------------------------------------------------------------------------
-//
-// ImathMath.h
-//
-// This file contains template functions which call the double-
-// precision math functions defined in math.h (sin(), sqrt(),
-// exp() etc.), with specializations that call the faster
-// single-precision versions (sinf(), sqrtf(), expf() etc.)
-// when appropriate.
-//
-// Example:
-//
-// double x = Math<double>::sqrt (3); // calls ::sqrt(double);
-// float y = Math<float>::sqrt (3); // calls ::sqrtf(float);
-//
-// When would I want to use this?
-//
-// You may be writing a template which needs to call some function
-// defined in math.h, for example to extract a square root, but you
-// don't know whether to call the single- or the double-precision
-// version of this function (sqrt() or sqrtf()):
-//
-// template <class T>
-// T
-// glorp (T x)
-// {
-// return sqrt (x + 1); // should call ::sqrtf(float)
-// } // if x is a float, but we
-// // don't know if it is
-//
-// Using the templates in this file, you can make sure that
-// the appropriate version of the math function is called:
-//
-// template <class T>
-// T
-// glorp (T x, T y)
-// {
-// return Math<T>::sqrt (x + 1); // calls ::sqrtf(float) if x
-// } // is a float, ::sqrt(double)
-// // otherwise
-//
-//----------------------------------------------------------------------------
-
-#include "ImathPlatform.h"
-#include <math.h>
-
-namespace Imath {
-
-
-template <class T>
-struct Math
-{
- static T acos (T x) {return ::acos (double(x));}
- static T asin (T x) {return ::asin (double(x));}
- static T atan (T x) {return ::atan (double(x));}
- static T atan2 (T x, T y) {return ::atan2 (double(x), double(y));}
- static T cos (T x) {return ::cos (double(x));}
- static T sin (T x) {return ::sin (double(x));}
- static T tan (T x) {return ::tan (double(x));}
- static T cosh (T x) {return ::cosh (double(x));}
- static T sinh (T x) {return ::sinh (double(x));}
- static T tanh (T x) {return ::tanh (double(x));}
- static T exp (T x) {return ::exp (double(x));}
- static T log (T x) {return ::log (double(x));}
- static T log10 (T x) {return ::log10 (double(x));}
- static T modf (T x, T *iptr)
- {
- double ival;
- T rval( ::modf (double(x),&ival));
- *iptr = ival;
- return rval;
- }
- static T pow (T x, T y) {return ::pow (double(x), double(y));}
- static T sqrt (T x) {return ::sqrt (double(x));}
- static T ceil (T x) {return ::ceil (double(x));}
- static T fabs (T x) {return ::fabs (double(x));}
- static T floor (T x) {return ::floor (double(x));}
- static T fmod (T x, T y) {return ::fmod (double(x), double(y));}
- static T hypot (T x, T y) {return ::hypot (double(x), double(y));}
-};
-
-
-template <>
-struct Math<float>
-{
- static float acos (float x) {return ::acosf (x);}
- static float asin (float x) {return ::asinf (x);}
- static float atan (float x) {return ::atanf (x);}
- static float atan2 (float x, float y) {return ::atan2f (x, y);}
- static float cos (float x) {return ::cosf (x);}
- static float sin (float x) {return ::sinf (x);}
- static float tan (float x) {return ::tanf (x);}
- static float cosh (float x) {return ::coshf (x);}
- static float sinh (float x) {return ::sinhf (x);}
- static float tanh (float x) {return ::tanhf (x);}
- static float exp (float x) {return ::expf (x);}
- static float log (float x) {return ::logf (x);}
- static float log10 (float x) {return ::log10f (x);}
- static float modf (float x, float *y) {return ::modff (x, y);}
- static float pow (float x, float y) {return ::powf (x, y);}
- static float sqrt (float x) {return ::sqrtf (x);}
- static float ceil (float x) {return ::ceilf (x);}
- static float fabs (float x) {return ::fabsf (x);}
- static float floor (float x) {return ::floorf (x);}
- static float fmod (float x, float y) {return ::fmodf (x, y);}
-#if !defined(_MSC_VER)
- static float hypot (float x, float y) {return ::hypotf (x, y);}
-#else
- static float hypot (float x, float y) {return ::sqrtf(x*x + y*y);}
-#endif
-};
-
-
-//--------------------------------------------------------------------------
-// Compare two numbers and test if they are "approximately equal":
-//
-// equalWithAbsError (x1, x2, e)
-//
-// Returns true if x1 is the same as x2 with an absolute error of
-// no more than e,
-//
-// abs (x1 - x2) <= e
-//
-// equalWithRelError (x1, x2, e)
-//
-// Returns true if x1 is the same as x2 with an relative error of
-// no more than e,
-//
-// abs (x1 - x2) <= e * x1
-//
-//--------------------------------------------------------------------------
-
-template <class T>
-inline bool
-equalWithAbsError (T x1, T x2, T e)
-{
- return ((x1 > x2)? x1 - x2: x2 - x1) <= e;
-}
-
-
-template <class T>
-inline bool
-equalWithRelError (T x1, T x2, T e)
-{
- return ((x1 > x2)? x1 - x2: x2 - x1) <= e * ((x1 > 0)? x1: -x1);
-}
-
-
-
-} // namespace Imath
-
-#endif
projects / opencv / blobdiff