rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/Imath/ImathRandom.cpp

@@ -0,0 +1,194 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+//-----------------------------------------------------------------------------
+//
+//	Routines that generate pseudo-random numbers compatible
+//	with the standard erand48(), nrand48(), etc. functions.
+//
+//-----------------------------------------------------------------------------
+
+#include "ImathRandom.h"
+#include "ImathInt64.h"
+
+IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER
+namespace {
+
+//
+// Static state used by Imath::drand48(), Imath::lrand48() and Imath::srand48()
+//
+
+unsigned short staticState[3] = {0, 0, 0};
+
+
+void
+rand48Next (unsigned short state[3])
+{
+    //
+    // drand48() and friends are all based on a linear congruential
+    // sequence,
+    //
+    //   x[n+1] = (a * x[n] + c) % m,
+    // 
+    // where a and c are as specified below, and m == (1 << 48)
+    //
+
+    static const Int64 a = Int64 (0x5deece66dLL);
+    static const Int64 c = Int64 (0xbLL);
+
+    //
+    // Assemble the 48-bit value x[n] from the
+    // three 16-bit values stored in state.
+    //
+
+    Int64 x = (Int64 (state[2]) << 32) |
+	      (Int64 (state[1]) << 16) |
+	       Int64 (state[0]);
+
+    //
+    // Compute x[n+1], except for the "modulo m" part.
+    //
+
+    x = a * x + c;
+
+    //
+    // Disassemble the 48 least significant bits of x[n+1] into
+    // three 16-bit values.  Discard the 16 most significant bits;
+    // this takes care of the "modulo m" operation.
+    //
+    // We assume that sizeof (unsigned short) == 2.
+    //
+
+    state[2] = (unsigned short)(x >> 32);
+    state[1] = (unsigned short)(x >> 16);
+    state[0] = (unsigned short)(x);
+}
+
+} // namespace
+
+
+double
+erand48 (unsigned short state[3])
+{
+    //
+    // Generate double-precision floating-point values between 0.0 and 1.0:
+    // 
+    // The exponent is set to 0x3ff, which indicates a value greater
+    // than or equal to 1.0, and less than 2.0.  The 48 most significant
+    // bits of the significand (mantissa) are filled with pseudo-random
+    // bits generated by rand48Next().  The remaining 4 bits are a copy
+    // of the 4 most significant bits of the significand.  This results
+    // in bit patterns between 0x3ff0000000000000 and 0x3fffffffffffffff,
+    // which correspond to uniformly distributed floating-point values
+    // between 1.0 and 1.99999999999999978.  Subtracting 1.0 from those
+    // values produces numbers between 0.0 and 0.99999999999999978, that
+    // is, between 0.0 and 1.0-DBL_EPSILON.
+    // 
+
+    rand48Next (state);
+
+    union {double d; Int64 i;} u;
+
+    u.i = (Int64 (0x3ff)    << 52) |	// sign and exponent
+	  (Int64 (state[2]) << 36) |	// significand
+	  (Int64 (state[1]) << 20) |
+	  (Int64 (state[0]) <<  4) |
+	  (Int64 (state[2]) >> 12);
+
+    return u.d - 1;
+}
+
+
+double
+drand48 ()
+{
+    return IMATH_INTERNAL_NAMESPACE::erand48 (staticState);
+}
+
+
+long int
+nrand48 (unsigned short state[3])
+{
+    //
+    // Generate uniformly distributed integers between 0 and 0x7fffffff.
+    // 
+
+    rand48Next (state);
+
+    return ((long int) (state[2]) << 15) |
+	   ((long int) (state[1]) >>  1);
+}
+
+
+long int
+lrand48 ()
+{
+    return IMATH_INTERNAL_NAMESPACE::nrand48 (staticState);
+}
+
+
+void
+srand48 (long int seed)
+{
+    staticState[2] = (unsigned short)(seed >> 16);
+    staticState[1] = (unsigned short)(seed);
+    staticState[0] = 0x330e;
+}
+
+
+float
+Rand32::nextf ()
+{
+    //
+    // Generate single-precision floating-point values between 0.0 and 1.0:
+    // 
+    // The exponent is set to 0x7f, which indicates a value greater than
+    // or equal to 1.0, and less than 2.0.  The 23 bits of the significand
+    // (mantissa) are filled with pseudo-random bits generated by
+    // Rand32::next().  This results in in bit patterns between 0x3f800000
+    // and 0x3fffffff, which correspond to uniformly distributed floating-
+    // point values between 1.0 and 1.99999988.  Subtracting 1.0 from
+    // those values produces numbers between 0.0 and 0.99999988, that is,
+    // between 0.0 and 1.0-FLT_EPSILON.
+    // 
+
+    next ();
+
+    union {float f; unsigned int i;} u;
+
+    u.i = 0x3f800000 | (_state & 0x7fffff);
+    return u.f - 1;
+}
+
+IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT

data/vendor/FreeImage/Source/OpenEXR/Imath/ImathRandom.h

@@ -0,0 +1,401 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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_IMATHRANDOM_H
+#define INCLUDED_IMATHRANDOM_H
+
+//-----------------------------------------------------------------------------
+//
+//	Generators for uniformly distributed pseudo-random numbers and
+//	functions that use those generators to generate numbers with
+//	non-uniform distributions:
+//
+//		class Rand32
+//		class Rand48
+//		solidSphereRand()
+//		hollowSphereRand()
+//		gaussRand()
+//		gaussSphereRand()
+//
+//	Note: class Rand48() calls erand48() and nrand48(), which are not
+//	available on all operating systems.  For compatibility we include
+//	our own versions of erand48() and nrand48().  Our functions have
+//	been reverse-engineered from the corresponding Unix/Linux man page.
+//
+//-----------------------------------------------------------------------------
+
+#include "ImathNamespace.h"
+#include "ImathExport.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
+
+//-----------------------------------------------
+// Fast random-number generator that generates
+// a uniformly distributed sequence with a period
+// length of 2^32.
+//-----------------------------------------------
+
+class IMATH_EXPORT Rand32
+{
+  public:
+
+    //------------
+    // Constructor
+    //------------
+
+    Rand32 (unsigned long int seed = 0);
+    
+
+    //--------------------------------
+    // Re-initialize with a given seed
+    //--------------------------------
+
+    void		init (unsigned long int seed);
+
+
+    //----------------------------------------------------------
+    // Get the next value in the sequence (range: [false, true])
+    //----------------------------------------------------------
+
+    bool		nextb ();
+
+
+    //---------------------------------------------------------------
+    // Get the next value in the sequence (range: [0 ... 0xffffffff])
+    //---------------------------------------------------------------
+
+    unsigned long int	nexti ();
+
+
+    //------------------------------------------------------
+    // Get the next value in the sequence (range: [0 ... 1[)
+    //------------------------------------------------------
+
+    float		nextf ();
+
+
+    //-------------------------------------------------------------------
+    // Get the next value in the sequence (range [rangeMin ... rangeMax[)
+    //-------------------------------------------------------------------
+
+    float		nextf (float rangeMin, float rangeMax);
+
+
+  private:
+
+    void		next ();
+
+    unsigned long int	_state;
+};
+
+
+//--------------------------------------------------------
+// Random-number generator based on the C Standard Library
+// functions erand48(), nrand48() & company; generates a
+// uniformly distributed sequence.
+//--------------------------------------------------------
+
+class Rand48
+{
+  public:
+
+    //------------
+    // Constructor
+    //------------
+
+    Rand48 (unsigned long int seed = 0);
+    
+
+    //--------------------------------
+    // Re-initialize with a given seed
+    //--------------------------------
+
+    void		init (unsigned long int seed);
+
+
+    //----------------------------------------------------------
+    // Get the next value in the sequence (range: [false, true])
+    //----------------------------------------------------------
+
+    bool		nextb ();
+
+
+    //---------------------------------------------------------------
+    // Get the next value in the sequence (range: [0 ... 0x7fffffff])
+    //---------------------------------------------------------------
+
+    long int		nexti ();
+
+
+    //------------------------------------------------------
+    // Get the next value in the sequence (range: [0 ... 1[)
+    //------------------------------------------------------
+
+    double		nextf ();
+
+
+    //-------------------------------------------------------------------
+    // Get the next value in the sequence (range [rangeMin ... rangeMax[)
+    //-------------------------------------------------------------------
+
+    double		nextf (double rangeMin, double rangeMax);
+
+
+  private:
+
+    unsigned short int	_state[3];
+};
+
+
+//------------------------------------------------------------
+// Return random points uniformly distributed in a sphere with
+// radius 1 around the origin (distance from origin <= 1).
+//------------------------------------------------------------
+
+template <class Vec, class Rand>
+Vec		
+solidSphereRand (Rand &rand);
+
+
+//-------------------------------------------------------------
+// Return random points uniformly distributed on the surface of
+// a sphere with radius 1 around the origin.
+//-------------------------------------------------------------
+
+template <class Vec, class Rand>
+Vec		
+hollowSphereRand (Rand &rand);
+
+
+//-----------------------------------------------
+// Return random numbers with a normal (Gaussian)
+// distribution with zero mean and unit variance.
+//-----------------------------------------------
+
+template <class Rand>
+float
+gaussRand (Rand &rand);
+
+
+//----------------------------------------------------
+// Return random points whose distance from the origin
+// has a normal (Gaussian) distribution with zero mean
+// and unit variance.
+//----------------------------------------------------
+
+template <class Vec, class Rand>
+Vec
+gaussSphereRand (Rand &rand);
+
+
+//---------------------------------
+// erand48(), nrand48() and friends
+//---------------------------------
+
+IMATH_EXPORT double     erand48 (unsigned short state[3]);
+IMATH_EXPORT double     drand48 ();
+IMATH_EXPORT long int   nrand48 (unsigned short state[3]);
+IMATH_EXPORT long int   lrand48 ();
+IMATH_EXPORT void       srand48 (long int seed);
+
+
+//---------------
+// Implementation
+//---------------
+
+
+inline void
+Rand32::init (unsigned long int seed)
+{
+    _state = (seed * 0xa5a573a5L) ^ 0x5a5a5a5aL;
+}
+
+
+inline
+Rand32::Rand32 (unsigned long int seed)
+{
+    init (seed);
+}
+
+
+inline void
+Rand32::next ()
+{
+    _state = 1664525L * _state + 1013904223L;
+}
+
+
+inline bool
+Rand32::nextb ()
+{
+    next ();
+    // Return the 31st (most significant) bit, by and-ing with 2 ^ 31.
+    return !!(_state & 2147483648UL);
+}
+
+
+inline unsigned long int
+Rand32::nexti ()
+{
+    next ();
+    return _state & 0xffffffff;
+}
+
+
+inline float
+Rand32::nextf (float rangeMin, float rangeMax)
+{
+    float f = nextf();
+    return rangeMin * (1 - f) + rangeMax * f;
+}
+
+
+inline void
+Rand48::init (unsigned long int seed)
+{
+    seed = (seed * 0xa5a573a5L) ^ 0x5a5a5a5aL;
+
+    _state[0] = (unsigned short int) (seed & 0xFFFF);
+    _state[1] = (unsigned short int) ((seed >> 16) & 0xFFFF);
+    _state[2] = (unsigned short int) (seed & 0xFFFF);   
+}
+
+
+inline 
+Rand48::Rand48 (unsigned long int seed)
+{
+    init (seed);
+}
+
+
+inline bool
+Rand48::nextb ()
+{
+    return nrand48 (_state) & 1;
+}
+
+
+inline long int
+Rand48::nexti ()
+{
+    return nrand48 (_state);
+}
+
+
+inline double
+Rand48::nextf ()
+{
+    return erand48 (_state);
+}
+
+
+inline double
+Rand48::nextf (double rangeMin, double rangeMax)
+{
+    double f = nextf();
+    return rangeMin * (1 - f) + rangeMax * f;
+}
+
+
+template <class Vec, class Rand>
+Vec
+solidSphereRand (Rand &rand)
+{
+    Vec v;
+
+    do
+    {
+	for (unsigned int i = 0; i < Vec::dimensions(); i++)
+	    v[i] = (typename Vec::BaseType) rand.nextf (-1, 1);
+    }
+    while (v.length2() > 1);
+
+    return v;
+}
+
+
+template <class Vec, class Rand>
+Vec
+hollowSphereRand (Rand &rand)
+{
+    Vec v;
+    typename Vec::BaseType length;
+
+    do
+    {
+	for (unsigned int i = 0; i < Vec::dimensions(); i++)
+	    v[i] = (typename Vec::BaseType) rand.nextf (-1, 1);
+
+	length = v.length();
+    }
+    while (length > 1 || length == 0);
+
+    return v / length;
+}
+
+
+template <class Rand>
+float
+gaussRand (Rand &rand)
+{
+    float x;		// Note: to avoid numerical problems with very small
+    float y;		// numbers, we make these variables singe-precision
+    float length2;	// floats, but later we call the double-precision log()
+			// and sqrt() functions instead of logf() and sqrtf().
+    do
+    {
+	x = float (rand.nextf (-1, 1));
+	y = float (rand.nextf (-1, 1));
+	length2 = x * x + y * y;
+    }
+    while (length2 >= 1 || length2 == 0);
+
+    return x * sqrt (-2 * log (double (length2)) / length2);
+}
+
+
+template <class Vec, class Rand>
+Vec
+gaussSphereRand (Rand &rand)
+{
+    return hollowSphereRand <Vec> (rand) * gaussRand (rand);
+}
+
+IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IMATHRANDOM_H