PageRenderTime 38ms CodeModel.GetById 28ms app.highlight 6ms RepoModel.GetById 1ms app.codeStats 1ms

/src/FreeImage/Source/OpenEXR/Half/halfFunction.h

https://bitbucket.org/cabalistic/ogredeps/
C++ Header | 159 lines | 51 code | 21 blank | 87 comment | 7 complexity | ca1486917528b45dbc7c3fa0c2d1ace0 MD5 | raw file
  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// Primary authors:
 36//     Florian Kainz <kainz@ilm.com>
 37//     Rod Bogart <rgb@ilm.com>
 38
 39
 40//---------------------------------------------------------------------------
 41//
 42//	halfFunction<T> -- a class for fast evaluation
 43//			   of half --> T functions
 44//
 45//	The constructor for a halfFunction object,
 46//
 47//	    halfFunction (function,
 48//			  domainMin, domainMax,
 49//			  defaultValue,
 50//			  posInfValue, negInfValue,
 51//			  nanValue);
 52//
 53//	evaluates the function for all finite half values in the interval
 54//	[domainMin, domainMax], and stores the results in a lookup table.
 55//	For finite half values that are not in [domainMin, domainMax], the
 56//	constructor stores defaultValue in the table.  For positive infinity,
 57//	negative infinity and NANs, posInfValue, negInfValue and nanValue
 58//	are stored in the table.
 59//
 60//	The tabulated function can then be evaluated quickly for arbitrary
 61//	half values by calling the the halfFunction object's operator()
 62//	method.
 63//
 64//	Example:
 65//
 66//	    #include <math.h>
 67//	    #include <halfFunction.h>
 68//
 69//	    halfFunction<half> hsin (sin);
 70//
 71//	    halfFunction<half> hsqrt (sqrt,		// function
 72//				      0, HALF_MAX,	// domain
 73//				      half::qNan(),	// sqrt(x) for x < 0
 74//				      half::posInf(),	// sqrt(+inf)
 75//				      half::qNan(),	// sqrt(-inf)
 76//				      half::qNan());	// sqrt(nan)
 77//
 78//	    half x = hsin (1);
 79//	    half y = hsqrt (3.5);
 80//
 81//---------------------------------------------------------------------------
 82
 83#ifndef _HALF_FUNCTION_H_
 84#define _HALF_FUNCTION_H_
 85
 86#include <float.h>
 87#include "half.h"
 88
 89
 90template <class T>
 91class halfFunction
 92{
 93  public:
 94
 95    //------------
 96    // Constructor
 97    //------------
 98
 99    template <class Function>
100    halfFunction (Function f,
101		  half domainMin = -HALF_MAX,
102		  half domainMax =  HALF_MAX,
103		  T defaultValue = 0,
104		  T posInfValue  = 0,
105		  T negInfValue  = 0,
106		  T nanValue     = 0);
107
108    //-----------
109    // Evaluation
110    //-----------
111
112    T		operator () (half x) const;
113
114  private:
115
116    T		_lut[1 << 16];
117};
118
119
120//---------------
121// Implementation
122//---------------
123
124template <class T>
125template <class Function>
126halfFunction<T>::halfFunction (Function f,
127			       half domainMin,
128			       half domainMax,
129			       T defaultValue,
130			       T posInfValue,
131			       T negInfValue,
132			       T nanValue)
133{
134    for (int i = 0; i < (1 << 16); i++)
135    {
136	half x;
137	x.setBits (i);
138
139	if (x.isNan())
140	    _lut[i] = nanValue;
141	else if (x.isInfinity())
142	    _lut[i] = x.isNegative()? negInfValue: posInfValue;
143	else if (x < domainMin || x > domainMax)
144	    _lut[i] = defaultValue;
145	else
146	    _lut[i] = f (x);
147    }
148}
149
150
151template <class T>
152inline T
153halfFunction<T>::operator () (half x) const
154{
155    return _lut[x.bits()];
156}
157
158
159#endif