Disabled external gits
This commit is contained in:
208
cs440-acg/ext/openexr/IlmBase/Imath/ImathMath.h
Normal file
208
cs440-acg/ext/openexr/IlmBase/Imath/ImathMath.h
Normal file
@@ -0,0 +1,208 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002-2012, 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 "ImathLimits.h"
|
||||
#include "ImathNamespace.h"
|
||||
#include <math.h>
|
||||
|
||||
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
|
||||
|
||||
|
||||
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
|
||||
};
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Don Hatch's version of sin(x)/x, which is accurate for very small x.
|
||||
// Returns 1 for x == 0.
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
template <class T>
|
||||
inline T
|
||||
sinx_over_x (T x)
|
||||
{
|
||||
if (x * x < limits<T>::epsilon())
|
||||
return T (1);
|
||||
else
|
||||
return Math<T>::sin (x) / x;
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// 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);
|
||||
}
|
||||
|
||||
|
||||
IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
|
||||
|
||||
#endif // INCLUDED_IMATHMATH_H
|
||||
Reference in New Issue
Block a user