# Visualization Library

A lightweight C++ OpenGL middleware for 2D/3D graphics

[Home] [Tutorials] [All Classes] [Grouped Classes]

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

# D:/VL/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlCore/half.hpp

Go to the documentation of this file.

    00001 /**************************************************************************************/
    00002 /*                                                                                    */
    00003 /*  Visualization Library                                                             */
    00004 /*  http://www.visualizationlibrary.org                                               */
    00005 /*                                                                                    */
    00006 /*  Copyright (c) 2005-2010, Michele Bosi                                             */
    00007 /*  All rights reserved.                                                              */
    00008 /*                                                                                    */
    00009 /*  Redistribution and use in source and binary forms, with or without modification,  */
    00010 /*  are permitted provided that the following conditions are met:                     */
    00011 /*                                                                                    */
    00012 /*  - Redistributions of source code must retain the above copyright notice, this     */
    00013 /*  list of conditions and the following disclaimer.                                  */
    00014 /*                                                                                    */
    00015 /*  - Redistributions in binary form must reproduce the above copyright notice, this  */
    00016 /*  list of conditions and the following disclaimer in the documentation and/or       */
    00017 /*  other materials provided with the distribution.                                   */
    00018 /*                                                                                    */
    00019 /*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
    00020 /*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
    00021 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
    00022 /*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
    00023 /*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
    00024 /*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
    00025 /*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
    00026 /*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
    00027 /*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
    00028 /*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
    00029 /*                                                                                    */
    00030 /**************************************************************************************/
    00031
    00032 #ifndef HalfFloat_INCLUDE_ONCE
    00033 #define HalfFloat_INCLUDE_ONCE
    00034
    00035 #include <vlCore/Matrix4.hpp>
    00036
    00037 namespace vl
    00038 {
    00040   class half
    00041   {
    00042   public:
    00043     half(): bits(0) {}
    00044
    00045     half(const half& hf): bits(hf.bits) {}
    00046
    00047     half(int i): bits(convertFloatToHalf((float)i).bits) {}
    00048
    00049     half(long long i): bits(convertFloatToHalf((float)i).bits) {}
    00050
    00051     half(float f): bits(convertFloatToHalf(f).bits) {}
    00052
    00053     half(double d): bits(convertFloatToHalf((float)d).bits) {}
    00054
    00055     operator float() const
    00056     {
    00057       return convertHalfToFloat(*this);
    00058     }
    00059
    00060     operator double() const
    00061     {
    00062       return (double)convertHalfToFloat(*this);
    00063     }
    00064
    00065     operator int() const
    00066     {
    00067       return (int)convertHalfToFloat(*this);
    00068     }
    00069
    00070     operator long long() const
    00071     {
    00072       return (long long)convertHalfToFloat(*this);
    00073     }
    00074
    00075     half& operator=(const half& other)
    00076     {
    00077       bits = other.bits;
    00078       return *this;
    00079     }
    00080
    00081     half operator+(const half& other) const
    00082     {
    00083       return convertFloatToHalf( convertHalfToFloat(*this) + convertHalfToFloat(other) );
    00084     }
    00085
    00086     half& operator+=(const half& other)
    00087     {
    00088       return *this = convertFloatToHalf( convertHalfToFloat(*this) + convertHalfToFloat(other) );
    00089     }
    00090
    00091     half operator-(const half& other) const
    00092     {
    00093       return convertFloatToHalf( convertHalfToFloat(*this) - convertHalfToFloat(other) );
    00094     }
    00095
    00096     half& operator-=(const half& other)
    00097     {
    00098       return *this = convertFloatToHalf( convertHalfToFloat(*this) - convertHalfToFloat(other) );
    00099     }
    00100
    00101     half operator*(const half& other) const
    00102     {
    00103       return convertFloatToHalf( convertHalfToFloat(*this) * convertHalfToFloat(other) );
    00104     }
    00105
    00106     half& operator*=(const half& other)
    00107     {
    00108       return *this = convertFloatToHalf( convertHalfToFloat(*this) * convertHalfToFloat(other) );
    00109     }
    00110
    00111     half operator/(const half& other) const
    00112     {
    00113       return convertFloatToHalf( convertHalfToFloat(*this) / convertHalfToFloat(other) );
    00114     }
    00115
    00116     half& operator/=(const half& other)
    00117     {
    00118       return *this = convertFloatToHalf( convertHalfToFloat(*this) / convertHalfToFloat(other) );
    00119     }
    00120
    00121     bool isZero() const
    00122     {
    00123       return (bits & ((1 << 15)-1)) == 0;
    00124     }
    00125
    00126     operator bool() const
    00127     {
    00128       return !isZero();
    00129     }
    00130
    00131     bool operator==(const half& other) const
    00132     {
    00133       if (isNaN() && other.isNaN())
    00134         return false;
    00135       else
    00136       if (isZero() && other.isZero())
    00137         return true;
    00138       else
    00139         return bits == other.bits;
    00140     }
    00141
    00142     bool operator==(const float& other) const
    00143     {
    00144       return operator==( convertFloatToHalf(other) );
    00145     }
    00146
    00147     bool operator==(const double& other) const
    00148     {
    00149       return operator==( convertFloatToHalf((float)other) );
    00150     }
    00151
    00152     bool operator==(const int& other) const
    00153     {
    00154       return operator==( convertFloatToHalf((float)other) );
    00155     }
    00156
    00157     bool operator==(const long long& other) const
    00158     {
    00159       return operator==( convertFloatToHalf((float)other) );
    00160     }
    00161
    00162     bool operator!=(const half& other) const
    00163     {
    00164       if (isNaN() && other.isNaN())
    00165         return false;
    00166       else
    00167       if (isZero() && other.isZero())
    00168         return false;
    00169       else
    00170         return bits != other.bits;
    00171     }
    00172
    00173     bool operator!=(const float& other) const
    00174     {
    00175       return operator!=( convertFloatToHalf(other) );
    00176     }
    00177
    00178     bool operator!=(const double& other) const
    00179     {
    00180       return operator!=( convertFloatToHalf((float)other) );
    00181     }
    00182
    00183     bool operator!=(const int& other) const
    00184     {
    00185       return operator!=( convertFloatToHalf((float)other) );
    00186     }
    00187
    00188     bool operator!=(const long long& other) const
    00189     {
    00190       return operator!=( convertFloatToHalf((float)other) );
    00191     }
    00192
    00193     bool operator<(const half& other) const
    00194     {
    00195       return convertHalfToFloat(*this) < convertHalfToFloat(other);
    00196     }
    00197
    00198     bool operator>(const half& other) const
    00199     {
    00200       return convertHalfToFloat(*this) < convertHalfToFloat(other);
    00201     }
    00202
    00203     bool isNaN() const
    00204     {
    00205       unsigned int mantissa = (unsigned int) (bits & (( 1 << 10) - 1) );
    00206       unsigned int exp = (unsigned int) (bits & HALF_FLOAT_MAX_BIASED_EXP);
    00207       return exp == HALF_FLOAT_MAX_BIASED_EXP && mantissa != 0;
    00208     }
    00209
    00210     bool isinf() const
    00211     {
    00212       unsigned int mantissa = (unsigned int) (bits & (( 1 << 10) - 1) );
    00213       unsigned int exp = (unsigned int) (bits & HALF_FLOAT_MAX_BIASED_EXP);
    00214       return exp == HALF_FLOAT_MAX_BIASED_EXP && mantissa == 0;
    00215     }
    00216
    00217     bool isinf_pos() const
    00218     {
    00219       unsigned int sign = (unsigned int) ( bits >> 15);
    00220       unsigned int mantissa = (unsigned int) (bits & (( 1 << 10) - 1) );
    00221       unsigned int exp = (unsigned int) (bits & HALF_FLOAT_MAX_BIASED_EXP);
    00222       return exp == HALF_FLOAT_MAX_BIASED_EXP && mantissa == 0 && sign == 0;
    00223     }
    00224
    00225     bool isinf_neg() const
    00226     {
    00227       unsigned int sign = (unsigned int) ( bits >> 15);
    00228       unsigned int mantissa = (unsigned int) (bits & (( 1 << 10) - 1) );
    00229       unsigned int exp = (unsigned int) (bits & HALF_FLOAT_MAX_BIASED_EXP);
    00230       return exp == HALF_FLOAT_MAX_BIASED_EXP && mantissa == 0 && sign == 1;
    00231     }
    00232
    00233     bool isdenorm() const
    00234     {
    00235       unsigned int mantissa = (unsigned int) (bits & (( 1 << 10) - 1) );
    00236       unsigned int exp = (unsigned int) (bits & HALF_FLOAT_MAX_BIASED_EXP);
    00237       return exp == 0 && mantissa != 0;
    00238     }
    00239
    00240     half operator-() const
    00241     {
    00242       half h = *this;
    00243       h.bits ^= 1 << 15;
    00244       return h;
    00245     }
    00246
    00247     //---------------------------------------------------------------------------
    00248     static half infinity()
    00249     {
    00250       half h;
    00251       h.bits = HALF_FLOAT_MAX_BIASED_EXP;
    00252       return h;
    00253     }
    00254     //---------------------------------------------------------------------------
    00255     static half NaN()
    00256     {
    00257       half h;
    00258       h.bits = HALF_FLOAT_MAX_BIASED_EXP | (( 1 << 10) - 1);
    00259       return h;
    00260     }
    00261     //---------------------------------------------------------------------------
    00262     static void convertDoubleToHalf(const double* d, half* h, int count)
    00263     {
    00264       for(int i=0; i<count; ++i)
    00265         h[i] = convertFloatToHalf((float)d[i]);
    00266     }
    00267     //---------------------------------------------------------------------------
    00268     static void convertHalfToDouble(const half* h, double* d, int count)
    00269     {
    00270       for(int i=0; i<count; ++i)
    00271         d[i] = (double)convertHalfToFloat(h[i]);
    00272     }
    00273     //---------------------------------------------------------------------------
    00274     static half convertFloatToHalf(float f)
    00275     {
    00276       union { float f; unsigned int x; } val;
    00277       val.f = f;
    00278       unsigned int sign = (unsigned short)(val.x>>31);
    00279       unsigned int mantissa = val.x & ((1 << 23)-1);
    00280       unsigned int exp = val.x & FLOAT_MAX_BIASED_EXP;
    00281       typedef unsigned short hfloat;
    00282       half hf;
    00283
    00284       if (exp >= HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP)
    00285       {
    00286         // check if the original single precision float number is a NaN
    00287         if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
    00288         {
    00289           // we have a single precision NaN
    00290           mantissa = (1<<23) - 1;
    00291         }
    00292         else
    00293         {
    00294           // 16-bit half-float representation stores number as Inf
    00295           mantissa = 0;
    00296         }
    00297         hf.bits = (((hfloat)sign) << 15) | (hfloat)(HALF_FLOAT_MAX_BIASED_EXP) | (hfloat)(mantissa >> 13);
    00298       }
    00299       // check if exponent is <= -15
    00300       else
    00301       if (exp <= HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP)
    00302       {
    00303         // store a denorm half-float value or zero
    00304         exp = (HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23;
    00305         mantissa >>= (14 + exp);
    00306         hf.bits = (((hfloat)sign) << 15) | (hfloat)(mantissa);
    00307       }
    00308       else
    00309       {
    00310         hf.bits = (((hfloat)sign)<<15) |
    00311                   (hfloat)((exp - HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 13) |
    00312                   (hfloat)(mantissa >> 13);
    00313       }
    00314       return hf;
    00315     }
    00316     //---------------------------------------------------------------------------
    00317     static float convertHalfToFloat(const half& h)
    00318     {
    00319       unsigned short hf = h.bits;
    00320       unsigned int sign = (unsigned int) ( hf >> 15);
    00321       unsigned int mantissa = (unsigned int) (hf & (( 1 << 10) - 1) );
    00322       unsigned int exp = (unsigned int) (hf & HALF_FLOAT_MAX_BIASED_EXP);
    00323
    00324       if (exp == HALF_FLOAT_MAX_BIASED_EXP)
    00325       {
    00326         // we have a half-float NaN or Inf
    00327         // half-float NaNs will be converted to a single precision NaN
    00328         // half-float Infs will be converted to a single precision Inf
    00329         exp = FLOAT_MAX_BIASED_EXP;
    00330         if ( mantissa)
    00331           mantissa = (1 << 23 ) - 1;   // set all bits to indicate a NaN
    00332       }
    00333       else if (exp == 0x0)
    00334       {
    00335         // convert half-float zero/denorm to single precision value
    00336         if ( mantissa)
    00337         {
    00338           mantissa <<= 1;
    00339           exp = HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
    00340           // check for leading 1 in denorm mantissa
    00341           while ((mantissa & (1 << 10) ) == 0)
    00342           {
    00343             // for every leading 0, decrement single precision exponent by 1
    00344             // and shift half-float mantissa value to the left
    00345             mantissa <<= 1;
    00346             exp -= (1 << 23 );
    00347           }
    00348           // clamp the mantissa to 10-bits
    00349           mantissa &= (( 1 << 10) - 1);
    00350           // shift left to generate single-precision mantissa of 23-bits
    00351           mantissa <<= 13;
    00352         }
    00353       }
    00354       else
    00355       {
    00356         // shift left to generate single-precision mantissa of 23-bits
    00357         mantissa <<= 13;
    00358         // generate single precision biased exponent value
    00359         exp = ( exp << 13) + HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
    00360       }
    00361       union { float f; unsigned int x; } val;
    00362       val.x = ( sign << 31) | exp | mantissa;
    00363       return val.f;
    00364     }
    00365     //---------------------------------------------------------------------------
    00366     static void convertFloatToHalf(const float* f, half* h, int count)
    00367     {
    00368       for(int i=0; i<count; ++i)
    00369       {
    00370         union { float f; unsigned int x; } val;
    00371         val.f = f[i];
    00372         unsigned int sign = (unsigned short)(val.x>>31);
    00373         unsigned int mantissa = val.x & ((1 << 23)-1);
    00374         unsigned int exp = val.x & FLOAT_MAX_BIASED_EXP;
    00375         typedef unsigned short hfloat;
    00376         hfloat& hf = h[i].bits;
    00377
    00378         if (exp >= HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP)
    00379         {
    00380           // check if the original single precision float number is a NaN
    00381           if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
    00382           {
    00383             // we have a single precision NaN
    00384             mantissa = (1<<23) - 1;
    00385           }
    00386           else
    00387           {
    00388             // 16-bit half-float representation stores number as Inf
    00389             mantissa = 0;
    00390           }
    00391           hf = (((hfloat)sign) << 15) | (hfloat)(HALF_FLOAT_MAX_BIASED_EXP) | (hfloat)(mantissa >> 13);
    00392         }
    00393         // check if exponent is <= -15
    00394         else
    00395         if (exp <= HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP)
    00396         {
    00397           // store a denorm half-float value or zero
    00398           exp = (HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23;
    00399           mantissa >>= (14 + exp);
    00400           hf = (((hfloat)sign) << 15) | (hfloat)(mantissa);
    00401         }
    00402         else
    00403         {
    00404           hf = (((hfloat)sign)<<15) |
    00405                (hfloat)((exp - HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 13) |
    00406                (hfloat)(mantissa >> 13);
    00407         }
    00408       }
    00409     }
    00410     //---------------------------------------------------------------------------
    00411     static void convertHalfToFloat(const half* h, float *f, int count)
    00412     {
    00413       for(int i=0; i<count; ++i)
    00414       {
    00415         const unsigned short& hf = h[i].bits;
    00416         unsigned int sign = (unsigned int) ( hf >> 15);
    00417         unsigned int mantissa = (unsigned int) (hf & (( 1 << 10) - 1) );
    00418         unsigned int exp = (unsigned int) (hf & HALF_FLOAT_MAX_BIASED_EXP);
    00419
    00420         if (exp == HALF_FLOAT_MAX_BIASED_EXP)
    00421         {
    00422           // we have a half-float NaN or Inf
    00423           // half-float NaNs will be converted to a single precision NaN
    00424           // half-float Infs will be converted to a single precision Inf
    00425           exp = FLOAT_MAX_BIASED_EXP;
    00426           if ( mantissa)
    00427             mantissa = (1 << 23 ) - 1;   // set all bits to indicate a NaN
    00428         }
    00429         else if (exp == 0x0)
    00430         {
    00431           // convert half-float zero/denorm to single precision value
    00432           if ( mantissa)
    00433           {
    00434             mantissa <<= 1;
    00435             exp = HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
    00436             // check for leading 1 in denorm mantissa
    00437             while ((mantissa & (1 << 10) ) == 0)
    00438             {
    00439               // for every leading 0, decrement single precision exponent by 1
    00440               // and shift half-float mantissa value to the left
    00441               mantissa <<= 1;
    00442               exp -= (1 << 23 );
    00443             }
    00444             // clamp the mantissa to 10-bits
    00445             mantissa &= (( 1 << 10) - 1);
    00446             // shift left to generate single-precision mantissa of 23-bits
    00447             mantissa <<= 13;
    00448           }
    00449         }
    00450         else
    00451         {
    00452           // shift left to generate single-precision mantissa of 23-bits
    00453           mantissa <<= 13;
    00454           // generate single precision biased exponent value
    00455           exp = ( exp << 13) + HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
    00456         }
    00457         union { float f; unsigned int x; } val;
    00458         val.x = ( sign << 31) | exp | mantissa;
    00459         f[i] = val.f;
    00460       }
    00461     }
    00462     //---------------------------------------------------------------------------
    00463   public:
    00464     unsigned short bits;
    00465
    00466   private:
    00467     // -15 stored using a single precision bias of 127
    00468     static const unsigned int  HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP = 0x38000000;
    00469
    00470     // max exponent value in single precision that will be converted
    00471     // to Inf or Nan when stored as a half-float
    00472     static const unsigned int  HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP = 0x47800000;
    00473
    00474     // 255 is the max exponent biased value
    00475     static const unsigned int  FLOAT_MAX_BIASED_EXP = (0xFF << 23);
    00476     static const unsigned int  HALF_FLOAT_MAX_BIASED_EXP = (0x1F << 10);
    00477
    00478   };
    00479   //-----------------------------------------------------------------------------
    00480   inline float operator/(float a, const half& b)
    00481   {
    00482     return (float)a / half::convertHalfToFloat(b);
    00483   }
    00484   //-----------------------------------------------------------------------------
    00485   inline float operator/(double a, const half& b)
    00486   {
    00487     return (float)a / half::convertHalfToFloat(b);
    00488   }
    00489   //-----------------------------------------------------------------------------
    00490   inline float operator/(int a, const half& b)
    00491   {
    00492     return (float)a / half::convertHalfToFloat(b);
    00493   }
    00494   //-----------------------------------------------------------------------------
    00495   inline float operator*(float a, const half& b)
    00496   {
    00497     return (float)a * half::convertHalfToFloat(b);
    00498   }
    00499   //-----------------------------------------------------------------------------
    00500   inline float operator*(double a, const half& b)
    00501   {
    00502     return (float)a * half::convertHalfToFloat(b);
    00503   }
    00504   //-----------------------------------------------------------------------------
    00505   inline float operator*(int a, const half& b)
    00506   {
    00507     return (float)a * half::convertHalfToFloat(b);
    00508   }
    00509   //-----------------------------------------------------------------------------
    00510   inline float operator+(float a, const half& b)
    00511   {
    00512     return (float)a + half::convertHalfToFloat(b);
    00513   }
    00514   //-----------------------------------------------------------------------------
    00515   inline float operator+(double a, const half& b)
    00516   {
    00517     return (float)a + half::convertHalfToFloat(b);
    00518   }
    00519   //-----------------------------------------------------------------------------
    00520   inline float operator+(int a, const half& b)
    00521   {
    00522     return (float)a + half::convertHalfToFloat(b);
    00523   }
    00524   //-----------------------------------------------------------------------------
    00525   inline float operator-(float a, const half& b)
    00526   {
    00527     return (float)a - half::convertHalfToFloat(b);
    00528   }
    00529   //-----------------------------------------------------------------------------
    00530   inline float operator-(double a, const half& b)
    00531   {
    00532     return (float)a - half::convertHalfToFloat(b);
    00533   }
    00534   //-----------------------------------------------------------------------------
    00535   inline float operator-(int a, const half& b)
    00536   {
    00537     return (float)a - half::convertHalfToFloat(b);
    00538   }
    00539   //-----------------------------------------------------------------------------
    00540   // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    00541   //-----------------------------------------------------------------------------
    00542   inline float operator/(const half& a, float b)
    00543   {
    00544     return half::convertHalfToFloat(a) / (float)b ;
    00545   }
    00546   //-----------------------------------------------------------------------------
    00547   inline float operator/(const half& a, double b)
    00548   {
    00549     return half::convertHalfToFloat(a) / (float)b ;
    00550   }
    00551   //-----------------------------------------------------------------------------
    00552   inline float operator/(const half& a, int b)
    00553   {
    00554     return half::convertHalfToFloat(a) / (float)b ;
    00555   }
    00556   //-----------------------------------------------------------------------------
    00557   inline float operator*(const half& a, float b)
    00558   {
    00559     return half::convertHalfToFloat(a) * (float)b ;
    00560   }
    00561   //-----------------------------------------------------------------------------
    00562   inline float operator*(const half& a, double b)
    00563   {
    00564     return half::convertHalfToFloat(a) * (float)b ;
    00565   }
    00566   //-----------------------------------------------------------------------------
    00567   inline float operator*(const half& a, int b)
    00568   {
    00569     return half::convertHalfToFloat(a) * (float)b ;
    00570   }
    00571   //-----------------------------------------------------------------------------
    00572   inline float operator+(const half& a, float b)
    00573   {
    00574     return half::convertHalfToFloat(a) + (float)b ;
    00575   }
    00576   //-----------------------------------------------------------------------------
    00577   inline float operator+(const half& a, double b)
    00578   {
    00579     return half::convertHalfToFloat(a) + (float)b ;
    00580   }
    00581   //-----------------------------------------------------------------------------
    00582   inline float operator+(const half& a, int b)
    00583   {
    00584     return half::convertHalfToFloat(a) + (float)b ;
    00585   }
    00586   //-----------------------------------------------------------------------------
    00587   inline float operator-(const half& a, float b)
    00588   {
    00589     return half::convertHalfToFloat(a) - (float)b ;
    00590   }
    00591   //-----------------------------------------------------------------------------
    00592   inline float operator-(const half& a, double b)
    00593   {
    00594     return half::convertHalfToFloat(a) - (float)b ;
    00595   }
    00596   //-----------------------------------------------------------------------------
    00597   inline float operator-(const half& a, int b)
    00598   {
    00599     return half::convertHalfToFloat(a) - (float)b ;
    00600   }
    00601   //-----------------------------------------------------------------------------
    00602   template<> inline half Vector4<half>::length() const { return (half)::sqrt( (float)x()*(float)x()+(float)y()*(float)y()+(float)z()*(float)z()+(float)w()*(float)w()); }
    00603   template<> inline half Vector4<half>::lengthSquared() const { return (half)((float)x()*(float)x()+(float)y()*(float)y()+(float)z()*(float)z()+(float)w()*(float)w()); }
    00604
    00605   template<> inline half Vector3<half>::length() const { return (half)::sqrt( (float)x()*(float)x()+(float)y()*(float)y()+(float)z()*(float)z()); }
    00606   template<> inline half Vector3<half>::lengthSquared() const { return (half)((float)x()*(float)x()+(float)y()*(float)y()+(float)z()*(float)z()); }
    00607
    00608   template<> inline half Vector2<half>::length() const { return (half)::sqrt( (float)x()*(float)x()+(float)y()*(float)y()); }
    00609   template<> inline half Vector2<half>::lengthSquared() const { return (half)((float)x()*(float)x()+(float)y()*(float)y()); }
    00610   //-----------------------------------------------------------------------------
    00611   typedef Vector4<half> hvec4;
    00612   typedef Vector3<half> hvec3;
    00613   typedef Vector2<half> hvec2;
    00614   //-----------------------------------------------------------------------------
    00615   typedef Matrix4<half> hmat4;
    00616   typedef Matrix3<half> hmat3;
    00617   typedef Matrix2<half> hmat2;
    00618   //-----------------------------------------------------------------------------
    00619 }
    00620
    00621 #endif

Visualization Library v2011.09.1162 Reference Documentation
Copyright 2005-2011 Michele Bosi. All rights reserved.
Updated on Thu Jan 26 2012 00:43:27.
Permission is granted to use this page to write and publish articles regarding Visualization Library.