git.maemo.org Git - opencv/blob - 3rdparty/include/OpenEXR/halfFunction.h

   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
  90 template <class T>
  91 class 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
 124 template <class T>
 125 template <class Function>
 126 halfFunction<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
 151 template <class T>
 152 inline T
 153 halfFunction<T>::operator () (half x) const
 154 {
 155     return _lut[x.bits()];
 156 }
 157
 158
 159 #endif