source: NonGTP/OpenEXR/include/halfFunction.h @ 855

Revision 855, 4.4 KB checked in by igarcia, 19 years ago (diff)
Line 
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
Note: See TracBrowser for help on using the repository browser.