You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

205 lines
6.2 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#ifndef hsWideDefined
#define hsWideDefined
#include "hsTypes.h"
struct hsWide {
Int32 fHi;
UInt32 fLo;
hsWide* Set(Int32 lo) { fLo = lo; if (lo < 0) fHi = -1L; else fHi = 0; return this; }
hsWide* Set(Int32 hi, UInt32 lo) { fHi = hi; fLo = lo; return this; }
inline hsBool IsNeg() const { return fHi < 0; }
inline hsBool IsPos() const { return fHi > 0 || (fHi == 0 && fLo != 0); }
inline hsBool IsZero() const { return fHi == 0 && fLo == 0; }
inline hsBool IsWide() const;
hsBool operator==(const hsWide& b) const { return fHi == b.fHi && fLo == b.fLo; }
hsBool operator<(const hsWide& b) const { return fHi < b.fHi || fHi == b.fHi && fLo < b.fLo; }
hsBool operator>( const hsWide& b) const { return fHi > b.fHi || fHi == b.fHi && fLo > b.fLo; }
hsBool operator!=( const hsWide& b) const { return !( *this == b); }
hsBool operator<=(const hsWide& b) const { return !(*this > b); }
hsBool operator>=(const hsWide& b) const { return !(*this < b); }
inline hsWide* Negate();
inline hsWide* Add(Int32 scaler);
inline hsWide* Add(const hsWide* a);
inline hsWide* Sub(const hsWide* a);
inline hsWide* ShiftLeft(unsigned shift);
inline hsWide* ShiftRight(unsigned shift);
inline hsWide* RoundRight(unsigned shift);
inline Int32 AsLong() const; // return bits 31-0, checking for over/under flow
inline hsFixed AsFixed() const; // return bits 47-16, checking for over/under flow
inline hsFract AsFract() const; // return bits 61-30, checking for over/under flow
hsWide* Mul(Int32 a); // this updates the wide
hsWide* Mul(Int32 a, Int32 b); // this sets the wide
hsWide* Div(Int32 denom); // this updates the wide
hsWide* Div(const hsWide* denom); // this updates the wide
hsFixed FixDiv(const hsWide* denom) const;
hsFract FracDiv(const hsWide* denom) const;
Int32 Sqrt() const;
Int32 CubeRoot() const;
#if HS_CAN_USE_FLOAT
double AsDouble() const { return fHi * double(65536) * double(65536) + fLo; }
hsWide* Set(double d)
{
Int32 hi = Int32(d / double(65536) / double(65536));
Int32 lo = Int32(d - double(hi));
return Set(hi, lo);
}
#endif
};
const hsWide kPosInfinity64 = { kPosInfinity32, 0xffffffff };
const hsWide kNegInfinity64 = { kNegInfinity32, 0 };
/////////////////////// Inline implementations ///////////////////////
#define TOP2BITS(n) (UInt32(n) >> 30)
#define TOP3BITS(n) (UInt32(n) >> 29)
#if HS_PIN_MATH_OVERFLOW && HS_DEBUG_MATH_OVERFLOW
#define hsSignalMathOverflow() hsDebugMessage("Math overflow", 0)
#define hsSignalMathUnderflow() hsDebugMessage("Math underflow", 0)
#else
#define hsSignalMathOverflow()
#define hsSignalMathUnderflow()
#endif
#define WIDE_ISNEG(hi, lo) (Int32(hi) < 0)
#define WIDE_LESSTHAN(hi, lo, hi2, lo2) ((hi) < (hi2) || (hi) == (hi2) && (lo) < (lo2))
#define WIDE_SHIFTLEFT(outH, outL, inH, inL, shift) do { (outH) = ((inH) << (shift)) | ((inL) >> (32 - (shift))); (outL) = (inL) << (shift); } while (0)
#define WIDE_NEGATE(hi, lo) do { (hi) = ~(hi); if (((lo) = -Int32(lo)) == 0) (hi) += 1; } while (0)
#define WIDE_ADDPOS(hi, lo, scaler) do { UInt32 tmp = (lo) + (scaler); if (tmp < (lo)) (hi) += 1; (lo) = tmp; } while (0)
#define WIDE_SUBWIDE(hi, lo, subhi, sublo) do { (hi) -= (subhi); if ((lo) < (sublo)) (hi) -= 1; (lo) -= (sublo); } while (0)
/////////////////////// Inline implementations ///////////////////////
inline hsWide* hsWide::Negate()
{
WIDE_NEGATE(fHi, fLo);
return this;
}
inline hsWide* hsWide::Add(Int32 scaler)
{
if (scaler >= 0)
WIDE_ADDPOS(fHi, fLo, scaler);
else
{ scaler = -scaler;
if (fLo < UInt32(scaler))
fHi--;
fLo -= scaler;
}
return this;
}
inline hsWide* hsWide::Add(const hsWide* a)
{
UInt32 newLo = fLo + a->fLo;
fHi += a->fHi;
if (newLo < (fLo | a->fLo))
fHi++;
fLo = newLo;
return this;
}
inline hsWide* hsWide::Sub(const hsWide* a)
{
WIDE_SUBWIDE(fHi, fLo, a->fHi, a->fLo);
return this;
}
inline hsWide* hsWide::ShiftLeft(unsigned shift)
{
WIDE_SHIFTLEFT(fHi, fLo, fHi, fLo, shift);
return this;
}
inline hsWide* hsWide::ShiftRight(unsigned shift)
{
fLo = (fLo >> shift) | (fHi << (32 - shift));
fHi = fHi >> shift; // fHi >>= shift; Treated as logical shift on CW9-WIN32, which breaks for fHi < 0
return this;
}
inline hsWide* hsWide::RoundRight(unsigned shift)
{
return this->Add(1L << (shift - 1))->ShiftRight(shift);
}
inline Int32 hsWide::AsLong() const
{
#if HS_PIN_MATH_OVERFLOW
if (fHi > 0 || fHi == 0 && (Int32)fLo < 0)
{ hsSignalMathOverflow();
return kPosInfinity32;
}
if (fHi < -1L || fHi == -1L && (Int32)fLo >= 0)
{ hsSignalMathOverflow();
return kNegInfinity32;
}
#endif
return (Int32)fLo;
}
inline hsBool hsWide::IsWide() const
{
return (fHi > 0 || fHi == 0 && (Int32)fLo < 0) || (fHi < -1L || fHi == -1L && (Int32)fLo >= 0);
}
inline hsFixed hsWide::AsFixed() const
{
hsWide tmp = *this;
return tmp.RoundRight(16)->AsLong();
}
inline hsFract hsWide::AsFract() const
{
hsWide tmp = *this;
return tmp.RoundRight(30)->AsLong();
}
#endif