PMReal.h

//========================================================================================
//
// $File$
//
// Owner: jargast
//
// $Author$
//
// $DateTime$
//
// $Revision$
//
// $Change$
//
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or
// distribution of it requires the prior written permission of Adobe.
//
//========================================================================================

#ifndef __PMReal__
#define __PMReal__

#include <math.h>

#include "K2Assert.h"

#ifdef WINDOWS
#include <stdio.h>
#include <float.h>
#endif

#if defined(DEBUG)
#include <limits>
#endif


constexpr double kPMRealEpsilon = 1.0e-8;
constexpr double kPMPi = 3.141592653589793238462643383279502884197169399375105820974944;
constexpr double kPMMaxReal = 8.9884656743115795e+307;


// NOTE: Code Generation 7/24/96
//
// MSFT VC is quite good at inlining things and produces code nearly
// identical to using doubles.
//
// MW's shipping compiler is not as good -- it seems to only inline
// one level deep so that an inline containing an inline is never
// expanded. There are other compiler back ends for MW that we could
// try.




class PMReal
{
// ----- Constructors/destructors
public:
 typedef base_type data_type;

 constexpr PMReal() noexcept : fRealValue(0.0)
 {
 }

 constexpr PMReal(const PMReal& ) noexcept = default;
 constexpr PMReal(PMReal&&) noexcept = default;

 constexpr PMReal(double d) noexcept : fRealValue(d)
 {
 }

 friend PMReal ToPMReal(Fixed fx);

 // PMREALCLEANUP
 //operator double() { return fRealValue; }
 //operator const double&() const { return fRealValue; }

// ----- Conversion operators
 friend double ToDouble(const PMReal& r) noexcept;

 friend float ToFloat(const PMReal& r);

 friend Fixed ToFixed(const PMReal& r);

 friend int16 ToInt16(const PMReal& r);

 friend uint16 ToUInt16(const PMReal& r);

 friend int32 ToInt32(const PMReal& r);

 friend uint32 ToUInt32(const PMReal& r);

// ----- Math operators
 friend PMReal operator -(const PMReal& a);

 friend PMReal operator +(const PMReal& a, const PMReal& b);

 friend PMReal operator -(const PMReal& a, const PMReal& b);

 friend PMReal operator *(const PMReal& a, const PMReal& b);

 friend PMReal operator /(const PMReal& a, const PMReal& b);

// ----- Math functions
 friend PMReal Round(const PMReal& a);

 friend PMReal Floor(const PMReal& a);

 friend PMReal Ceiling(const PMReal& a);

 friend PMReal abs(const PMReal& a);

 friend PMReal NearestMultiple(const PMReal& a, const PMReal& factor);

 friend PMReal Mod(const PMReal& a, const PMReal& b);

// ----- Assignment Operators
 PMReal& operator=(const PMReal &) noexcept = default;
 PMReal& operator=(PMReal &&) noexcept = default;

 PMReal& operator +=(const PMReal& a);

 PMReal& operator -=(const PMReal& a);

 PMReal& operator *=(const PMReal& a);

 PMReal& operator /=(const PMReal& a);

// ----- Comparison Operators
 friend bool16 operator ==(const PMReal& a, const PMReal& b) noexcept;

 friend bool16 operator !=(const PMReal& a, const PMReal& b) noexcept;

 friend bool16 operator <(const PMReal& a, const PMReal& b) noexcept;

 friend bool16 operator >(const PMReal& a, const PMReal& b) noexcept;

 friend bool16 operator <=(const PMReal& a, const PMReal& b) noexcept;

 friend bool16 operator >=(const PMReal& a, const PMReal& b) noexcept;

 friend bool16 AnglesEqual(const PMReal& a, const PMReal& b) noexcept;

 friend bool16 EqualsWithEpsilon(const PMReal& a, const PMReal& b, double epsilon) noexcept;

private:
 double fRealValue;
};


/*--------------------------------------------------------------------*/
/*--------------------------------------------------------------------*/
/*--------------------------------------------------------------------*/

// Math operators
inline PMReal operator-(const PMReal& r)
{
#ifdef WINDOWS
 // Verify that exception handling is what we expect.
 ASSERT_MSG(kDefaultFPUExceptions == _controlfp(0, 0), FORMAT_ARGS("Unexpected floating point control word! You may see floating point exceptions (actual:0x%8.8X expected:0x%8.8X)",_controlfp(0, 0), kDefaultFPUExceptions));
#endif

 return -r.fRealValue;
}

inline PMReal operator+(const PMReal& a, const PMReal& b)
{
#ifdef WINDOWS
 // Verify that exception handling is what we expect.
 ASSERT_MSG(kDefaultFPUExceptions == _controlfp(0, 0), FORMAT_ARGS("Unexpected floating point control word! You may see floating point exceptions (actual:0x%8.8X expected:0x%8.8X)",_controlfp(0, 0), kDefaultFPUExceptions));
#endif

 return a.fRealValue + b.fRealValue;
}

inline PMReal operator-(const PMReal& a, const PMReal& b)
{
#ifdef WINDOWS
 // Verify that exception handling is what we expect.
 ASSERT_MSG(kDefaultFPUExceptions == _controlfp(0, 0), FORMAT_ARGS("Unexpected floating point control word! You may see floating point exceptions (actual:0x%8.8X expected:0x%8.8X)",_controlfp(0, 0), kDefaultFPUExceptions));
#endif

 return a.fRealValue - b.fRealValue;
}

inline PMReal operator*(const PMReal& a, const PMReal& b)
{
#ifdef WINDOWS
 // Verify that exception handling is what we expect.
 ASSERT_MSG(kDefaultFPUExceptions == _controlfp(0, 0), FORMAT_ARGS("Unexpected floating point control word! You may see floating point exceptions (actual:0x%8.8X expected:0x%8.8X)",_controlfp(0, 0), kDefaultFPUExceptions));
#endif

 return a.fRealValue * b.fRealValue;
}

inline PMReal operator/(const PMReal& a, const PMReal& b)
{
#ifdef WINDOWS
 // Verify that exception handling is what we expect.
 ASSERT_MSG(kDefaultFPUExceptions == _controlfp(0, 0), FORMAT_ARGS("Unexpected floating point control word! You may see floating point exceptions (actual:0x%8.8X expected:0x%8.8X)",_controlfp(0, 0), kDefaultFPUExceptions));
#endif

 return a.fRealValue / b.fRealValue;
}


// Math functions
inline PMReal Floor(const PMReal& a)
{
 //return (a.fRealValue < 0.0 && a.fRealValue != double(int32(a.fRealValue)) ? int32(a.fRealValue - 1.0) : int32(a.fRealValue));
 return ::floor (a.fRealValue);
}

inline PMReal Ceiling(const PMReal& a)
{
 return (a.fRealValue > 0.0 && a.fRealValue != double(int32(a.fRealValue)) ? int32(a.fRealValue + 1.0) : int32(a.fRealValue));
}

inline PMReal Round(const PMReal& a)
{
 PMReal r(a.fRealValue + 0.5);

 return ::Floor(r);
}

inline PMReal abs(const PMReal& a)
{
// NOTE: Implicit construction on return
 return ::fabs(a.fRealValue);
}

inline PMReal NearestMultiple(const PMReal&a, const PMReal& factor)
{
 return ::Round (a / factor) * factor;
}

inline PMReal Mod(const PMReal& a, const PMReal& b)
{
// NOTE: Implicit construction on return
 return ::fmod(a.fRealValue, b.fRealValue);
}

// Conversion operators
inline Fixed ToFixed(const PMReal& r)
{
 ASSERT(static_cast<int32>(r.fRealValue) >= kMinInt16);
 ASSERT(static_cast<int32>(r.fRealValue) <= kMaxInt16);

 PMReal a(::Round(r * 65536.0));
 return int32(a.fRealValue);
}

inline double ToDouble (const PMReal& r) noexcept
{
 return r.fRealValue;
}

inline float ToFloat (const PMReal& r)
{
 return (float) r.fRealValue;
}

inline int16 ToInt16 (const PMReal& r)
{
 ASSERT(r.fRealValue >= kMinInt16);
 ASSERT(r.fRealValue <= kMaxInt16);

 return (int16) r.fRealValue;
}

inline uint16 ToUInt16 (const PMReal& r)
{
 ASSERT(r.fRealValue >= 0.0);
 ASSERT(r.fRealValue <= kMaxUInt16);

 return (uint16) r.fRealValue;
}

inline int32 ToInt32 (const PMReal& r)
{
 ASSERT_MSG(r.fRealValue >= kMinInt32, FORMAT_ARGS("Value %4.4f is too small to convert to int32",r.fRealValue));
 ASSERT_MSG(r.fRealValue <= kMaxInt32, FORMAT_ARGS("Value %4.4f is too large to convert to int32",r.fRealValue));

 return (int32) r.fRealValue;
}

inline uint32 ToUInt32 (const PMReal& r)
{
 ASSERT(r.fRealValue >= 0.0);
 ASSERT(r.fRealValue <= kMaxUInt32);

 return (uint32) r.fRealValue;
}

inline PMReal ToPMReal (Fixed fx)
{
 // NOTE: Implicit construction on return
 return double(fx) * 0.0000152587890625; // 1/65536
}

inline PMReal& PMReal::operator+=(const PMReal& a)
{
 fRealValue += a.fRealValue;

 return *this;
}

inline PMReal& PMReal::operator-=(const PMReal& a)
{
 fRealValue -= a.fRealValue;

 return *this;
}

inline PMReal& PMReal::operator*=(const PMReal& a)
{
 fRealValue *= a.fRealValue;

 return *this;
}

inline PMReal& PMReal::operator/=(const PMReal& a)
{
 fRealValue /= a.fRealValue;

 return *this;
}


// Comparison operators
inline bool16 operator<(const PMReal& a, const PMReal& b) noexcept
{
 return a.fRealValue < (b.fRealValue - kPMRealEpsilon);
}

inline bool16 operator>(const PMReal& a, const PMReal& b) noexcept
{
 return a.fRealValue > (b.fRealValue + kPMRealEpsilon);
}

inline bool16 operator<=(const PMReal& a, const PMReal& b) noexcept
{
 return a.fRealValue <= (b.fRealValue + kPMRealEpsilon);
}

inline bool16 operator>=(const PMReal& a, const PMReal& b) noexcept
{
 return a.fRealValue >= (b.fRealValue - kPMRealEpsilon);
}

inline bool16 operator==(const PMReal& a, const PMReal& b) noexcept
{
 return ::fabs(a.fRealValue - b.fRealValue) < kPMRealEpsilon;
}

inline bool16 operator!=(const PMReal& a, const PMReal& b) noexcept
{
 return !(a == b);
}

 // allow epsilon compare with angles in degress (360 == 0)
inline bool16 AnglesEqual(const PMReal& a, const PMReal& b) noexcept
{
 if (a == b)
 return kTrue;
 else if (a > b)
 return ::fabs((a.fRealValue - 360.0) - b.fRealValue) < kPMRealEpsilon;
 else
 return ::fabs(a.fRealValue - (b.fRealValue - 360.0)) < kPMRealEpsilon;
}

inline bool16 EqualsWithEpsilon(const PMReal& a, const PMReal& b, double epsilon) noexcept
{
 return ::fabs(a.fRealValue - b.fRealValue) < epsilon;
}
#endif