/*!\file fast_rts64x.h
* \brief Быстрая реализация основных операций с числами
* \brief с плавающей запятой для DSP фирмы Texas Instruments
* \brief серии 64x, основанная на библиотеке fast_rts64x.lib
* \version 1.0
* \date 2008
*/
#ifndef __FAST_RTS_64X_H
#define __FAST_RTS_64X_H

#ifdef __cplusplus
extern "C" {
#include <fastrts62x64x.h>
}
#else
#include <fastrts62x64x.h>
#endif

class double_fst
{
public:
    double value;

    inline double_fst( double v=0 ) { value=v; }
    inline double_fst( float v ) { value=spdp(v); }
    inline double_fst( char v ) { value=intdp(v); }
    inline double_fst( short v ) { value=intdp(v); }
    inline double_fst( int v ) { value=intdp(v); }
    inline double_fst( long v ) { value=longdp(v); }
    inline double_fst( unsigned char v ) { value=uintdp(v); }
    inline double_fst( unsigned short v ) { value=uintdp(v); }
    inline double_fst( unsigned int v ) { value=uintdp(v); }
    inline double_fst( unsigned long v ) { value=ulongdp(v); }

    inline operator double() const { return value; }
    inline operator float() const { return dpsp(value); }
    inline operator char() const { return (char)dpint(value); }
    inline operator short() const { return (short)dpint(value); }
    inline operator int() const { return dpint(value); }
    inline operator long() const { return dplong(value); }
    inline operator unsigned char() const { return (unsigned char)dpuint(value); }
    inline operator unsigned short() const { return (unsigned short)dpuint(value); }
    inline operator unsigned int() const { return dpuint(value); }
    inline operator unsigned long() const { return dpulong(value); }

    inline void operator = ( double_fst r ) { value=r.value; }
    inline void operator = ( double v ) { value=v; }
    inline void operator = ( float v ) { value=spdp(v); }
    inline void operator = ( char v ) { value=intdp(v); }
    inline void operator = ( short v ) { value=intdp(v); }
    inline void operator = ( int v ) { value=intdp(v); }
    inline void operator = ( long v ) { value=longdp(v); }
    inline void operator = ( unsigned char v ) { value=uintdp(v); }
    inline void operator = ( unsigned short v ) { value=uintdp(v); }
    inline void operator = ( unsigned int v ) { value=uintdp(v); }
    inline void operator = ( unsigned long v ) { value=ulongdp(v); }

    inline void operator += ( double_fst r ) { value=adddp(value, r.value); }
    inline void operator -= ( double_fst r ) { value=subdp(value, r.value); }
    inline void operator *= ( double_fst r ) { value=mpydp(value, r.value); }
    inline void operator /= ( double_fst r ) { value=divdp(value, r.value); }

    inline void operator += ( double v ) { value=adddp(value, v); }
    inline void operator -= ( double v ) { value=subdp(value, v); }
    inline void operator *= ( double v ) { value=mpydp(value, v); }
    inline void operator /= ( double v ) { value=divdp(value, v); }

    inline void operator += ( float v ) { value=adddp(value, spdp(v)); }
    inline void operator -= ( float v ) { value=subdp(value, spdp(v)); }
    inline void operator *= ( float v ) { value=mpydp(value, spdp(v)); }
    inline void operator /= ( float v ) { value=divdp(value, spdp(v)); }

    inline void operator += ( char v ) { value=adddp(value, intdp(v)); }
    inline void operator -= ( char v ) { value=subdp(value, intdp(v)); }
    inline void operator *= ( char v ) { value=mpydp(value, intdp(v)); }
    inline void operator /= ( char v ) { value=divdp(value, intdp(v)); }

    inline void operator += ( short v ) { value=adddp(value, intdp(v)); }
    inline void operator -= ( short v ) { value=subdp(value, intdp(v)); }
    inline void operator *= ( short v ) { value=mpydp(value, intdp(v)); }
    inline void operator /= ( short v ) { value=divdp(value, intdp(v)); }

    inline void operator += ( int v ) { value=adddp(value, intdp(v)); }
    inline void operator -= ( int v ) { value=subdp(value, intdp(v)); }
    inline void operator *= ( int v ) { value=mpydp(value, intdp(v)); }
    inline void operator /= ( int v ) { value=divdp(value, intdp(v)); }

    inline void operator += ( long v ) { value=adddp(value, longdp(v)); }
    inline void operator -= ( long v ) { value=subdp(value, longdp(v)); }
    inline void operator *= ( long v ) { value=mpydp(value, longdp(v)); }
    inline void operator /= ( long v ) { value=divdp(value, longdp(v)); }

    inline void operator += ( unsigned char v ) { value=adddp(value, uintdp(v)); }
    inline void operator -= ( unsigned char v ) { value=subdp(value, uintdp(v)); }
    inline void operator *= ( unsigned char v ) { value=mpydp(value, uintdp(v)); }
    inline void operator /= ( unsigned char v ) { value=divdp(value, uintdp(v)); }

    inline void operator += ( unsigned short v ) { value=adddp(value, uintdp(v)); }
    inline void operator -= ( unsigned short v ) { value=subdp(value, uintdp(v)); }
    inline void operator *= ( unsigned short v ) { value=mpydp(value, uintdp(v)); }
    inline void operator /= ( unsigned short v ) { value=divdp(value, uintdp(v)); }

    inline void operator += ( unsigned int v ) { value=adddp(value, uintdp(v)); }
    inline void operator -= ( unsigned int v ) { value=subdp(value, uintdp(v)); }
    inline void operator *= ( unsigned int v ) { value=mpydp(value, uintdp(v)); }
    inline void operator /= ( unsigned int v ) { value=divdp(value, uintdp(v)); }

    inline void operator += ( unsigned long v ) { value=adddp(value, ulongdp(v)); }
    inline void operator -= ( unsigned long v ) { value=subdp(value, ulongdp(v)); }
    inline void operator *= ( unsigned long v ) { value=mpydp(value, ulongdp(v)); }
    inline void operator /= ( unsigned long v ) { value=divdp(value, ulongdp(v)); }

    inline bool operator <  ( double_fst &r ) const { return value <  r.value; }
    inline bool operator >  ( double_fst &r ) const { return value >  r.value; }
    inline bool operator <= ( double_fst &r ) const { return value <= r.value; }
    inline bool operator >= ( double_fst &r ) const { return value >= r.value; }
    inline bool operator == ( double_fst &r ) const { return value == r.value; }
    inline bool operator != ( double_fst &r ) const { return value != r.value; }

    inline bool operator <  ( double v ) const { return value <  v; }
    inline bool operator >  ( double v ) const { return value >  v; }
    inline bool operator <= ( double v ) const { return value <= v; }
    inline bool operator >= ( double v ) const { return value >= v; }
    inline bool operator == ( double v ) const { return value == v; }
    inline bool operator != ( double v ) const { return value != v; }

    inline bool operator <  ( float v ) const { return value <  spdp(v); }
    inline bool operator >  ( float v ) const { return value >  spdp(v); }
    inline bool operator <= ( float v ) const { return value <= spdp(v); }
    inline bool operator >= ( float v ) const { return value >= spdp(v); }
    inline bool operator == ( float v ) const { return value == spdp(v); }
    inline bool operator != ( float v ) const { return value != spdp(v); }

    inline bool operator <  ( char v ) const { return value <  intdp(v); }
    inline bool operator >  ( char v ) const { return value >  intdp(v); }
    inline bool operator <= ( char v ) const { return value <= intdp(v); }
    inline bool operator >= ( char v ) const { return value >= intdp(v); }
    inline bool operator == ( char v ) const { return value == intdp(v); }
    inline bool operator != ( char v ) const { return value != intdp(v); }

    inline bool operator <  ( short v ) const { return value <  intdp(v); }
    inline bool operator >  ( short v ) const { return value >  intdp(v); }
    inline bool operator <= ( short v ) const { return value <= intdp(v); }
    inline bool operator >= ( short v ) const { return value >= intdp(v); }
    inline bool operator == ( short v ) const { return value == intdp(v); }
    inline bool operator != ( short v ) const { return value != intdp(v); }

    inline bool operator <  ( int v ) const { return value <  intdp(v); }
    inline bool operator >  ( int v ) const { return value >  intdp(v); }
    inline bool operator <= ( int v ) const { return value <= intdp(v); }
    inline bool operator >= ( int v ) const { return value >= intdp(v); }
    inline bool operator == ( int v ) const { return value == intdp(v); }
    inline bool operator != ( int v ) const { return value != intdp(v); }

    inline bool operator <  ( long v ) const { return value <  longdp(v); }
    inline bool operator >  ( long v ) const { return value >  longdp(v); }
    inline bool operator <= ( long v ) const { return value <= longdp(v); }
    inline bool operator >= ( long v ) const { return value >= longdp(v); }
    inline bool operator == ( long v ) const { return value == longdp(v); }
    inline bool operator != ( long v ) const { return value != longdp(v); }

    inline bool operator <  ( unsigned char v ) const { return value <  uintdp(v); }
    inline bool operator >  ( unsigned char v ) const { return value >  uintdp(v); }
    inline bool operator <= ( unsigned char v ) const { return value <= uintdp(v); }
    inline bool operator >= ( unsigned char v ) const { return value >= uintdp(v); }
    inline bool operator == ( unsigned char v ) const { return value == uintdp(v); }
    inline bool operator != ( unsigned char v ) const { return value != uintdp(v); }

    inline bool operator <  ( unsigned short v ) const { return value <  uintdp(v); }
    inline bool operator >  ( unsigned short v ) const { return value >  uintdp(v); }
    inline bool operator <= ( unsigned short v ) const { return value <= uintdp(v); }
    inline bool operator >= ( unsigned short v ) const { return value >= uintdp(v); }
    inline bool operator == ( unsigned short v ) const { return value == uintdp(v); }
    inline bool operator != ( unsigned short v ) const { return value != uintdp(v); }

    inline bool operator <  ( unsigned int v ) const { return value <  uintdp(v); }
    inline bool operator >  ( unsigned int v ) const { return value >  uintdp(v); }
    inline bool operator <= ( unsigned int v ) const { return value <= uintdp(v); }
    inline bool operator >= ( unsigned int v ) const { return value >= uintdp(v); }
    inline bool operator == ( unsigned int v ) const { return value == uintdp(v); }
    inline bool operator != ( unsigned int v ) const { return value != uintdp(v); }

    inline bool operator <  ( unsigned long v ) const { return value <  ulongdp(v); }
    inline bool operator >  ( unsigned long v ) const { return value >  ulongdp(v); }
    inline bool operator <= ( unsigned long v ) const { return value <= ulongdp(v); }
    inline bool operator >= ( unsigned long v ) const { return value >= ulongdp(v); }
    inline bool operator == ( unsigned long v ) const { return value == ulongdp(v); }
    inline bool operator != ( unsigned long v ) const { return value != ulongdp(v); }
};

//Для типа double_fst
inline double_fst operator + (double_fst l, double_fst r) { return double_fst(adddp(l.value,r.value)); }
inline double_fst operator - (double_fst l, double_fst r) { return double_fst(subdp(l.value,r.value)); }
inline double_fst operator * (double_fst l, double_fst r) { return double_fst(mpydp(l.value,r.value)); }
inline double_fst operator / (double_fst l, double_fst r) { return double_fst(divdp(l.value,r.value)); }

//Для типа double
inline double_fst operator + ( double l, double_fst r ) { return double_fst(adddp(l, r.value)); }
inline double_fst operator - ( double l, double_fst r ) { return double_fst(subdp(l, r.value)); }
inline double_fst operator * ( double l, double_fst r ) { return double_fst(mpydp(l, r.value)); }
inline double_fst operator / ( double l, double_fst r ) { return double_fst(divdp(l, r.value)); }
inline double_fst operator + ( double_fst l, double r ) { return double_fst(adddp(l.value, r)); }
inline double_fst operator - ( double_fst l, double r ) { return double_fst(subdp(l.value, r)); }
inline double_fst operator * ( double_fst l, double r ) { return double_fst(mpydp(l.value, r)); }
inline double_fst operator / ( double_fst l, double r ) { return double_fst(divdp(l.value, r)); }

//Для типа float
inline double_fst operator + ( float l, double_fst r ) { return double_fst(adddp(spdp(l), r.value)); }
inline double_fst operator - ( float l, double_fst r ) { return double_fst(subdp(spdp(l), r.value)); }
inline double_fst operator * ( float l, double_fst r ) { return double_fst(mpydp(spdp(l), r.value)); }
inline double_fst operator / ( float l, double_fst r ) { return double_fst(divdp(spdp(l), r.value)); }
inline double_fst operator + ( double_fst l, float r ) { return double_fst(adddp(l.value, spdp(r))); }
inline double_fst operator - ( double_fst l, float r ) { return double_fst(subdp(l.value, spdp(r))); }
inline double_fst operator * ( double_fst l, float r ) { return double_fst(mpydp(l.value, spdp(r))); }
inline double_fst operator / ( double_fst l, float r ) { return double_fst(divdp(l.value, spdp(r))); }

//Для типа char
inline double_fst operator + ( char l, double_fst r ) { return double_fst(adddp(intdp(l), r.value)); }
inline double_fst operator - ( char l, double_fst r ) { return double_fst(subdp(intdp(l), r.value)); }
inline double_fst operator * ( char l, double_fst r ) { return double_fst(mpydp(intdp(l), r.value)); }
inline double_fst operator / ( char l, double_fst r ) { return double_fst(divdp(intdp(l), r.value)); }
inline double_fst operator + ( double_fst l, char r ) { return double_fst(adddp(l.value, intdp(r))); }
inline double_fst operator - ( double_fst l, char r ) { return double_fst(subdp(l.value, intdp(r))); }
inline double_fst operator * ( double_fst l, char r ) { return double_fst(mpydp(l.value, intdp(r))); }
inline double_fst operator / ( double_fst l, char r ) { return double_fst(divdp(l.value, intdp(r))); }

//Для типа short
inline double_fst operator + ( short l, double_fst r ) { return double_fst(adddp(intdp(l), r.value)); }
inline double_fst operator - ( short l, double_fst r ) { return double_fst(subdp(intdp(l), r.value)); }
inline double_fst operator * ( short l, double_fst r ) { return double_fst(mpydp(intdp(l), r.value)); }
inline double_fst operator / ( short l, double_fst r ) { return double_fst(divdp(intdp(l), r.value)); }
inline double_fst operator + ( double_fst l, short r ) { return double_fst(adddp(l.value, intdp(r))); }
inline double_fst operator - ( double_fst l, short r ) { return double_fst(subdp(l.value, intdp(r))); }
inline double_fst operator * ( double_fst l, short r ) { return double_fst(mpydp(l.value, intdp(r))); }
inline double_fst operator / ( double_fst l, short r ) { return double_fst(divdp(l.value, intdp(r))); }

//Для типа int
inline double_fst operator + ( int l, double_fst r ) { return double_fst(adddp(intdp(l), r.value)); }
inline double_fst operator - ( int l, double_fst r ) { return double_fst(subdp(intdp(l), r.value)); }
inline double_fst operator * ( int l, double_fst r ) { return double_fst(mpydp(intdp(l), r.value)); }
inline double_fst operator / ( int l, double_fst r ) { return double_fst(divdp(intdp(l), r.value)); }
inline double_fst operator + ( double_fst l, int r ) { return double_fst(adddp(l.value, intdp(r))); }
inline double_fst operator - ( double_fst l, int r ) { return double_fst(subdp(l.value, intdp(r))); }
inline double_fst operator * ( double_fst l, int r ) { return double_fst(mpydp(l.value, intdp(r))); }
inline double_fst operator / ( double_fst l, int r ) { return double_fst(divdp(l.value, intdp(r))); }

//Для типа long
inline double_fst operator + ( long l, double_fst r ) { return double_fst(adddp(longdp(l), r.value)); }
inline double_fst operator - ( long l, double_fst r ) { return double_fst(subdp(longdp(l), r.value)); }
inline double_fst operator * ( long l, double_fst r ) { return double_fst(mpydp(longdp(l), r.value)); }
inline double_fst operator / ( long l, double_fst r ) { return double_fst(divdp(longdp(l), r.value)); }
inline double_fst operator + ( double_fst l, long r ) { return double_fst(adddp(l.value, longdp(r))); }
inline double_fst operator - ( double_fst l, long r ) { return double_fst(subdp(l.value, longdp(r))); }
inline double_fst operator * ( double_fst l, long r ) { return double_fst(mpydp(l.value, longdp(r))); }
inline double_fst operator / ( double_fst l, long r ) { return double_fst(divdp(l.value, longdp(r))); }

//Для типа unsigned char
inline double_fst operator + ( unsigned char l, double_fst r ) { return double_fst(adddp(uintdp(l), r.value)); }
inline double_fst operator - ( unsigned char l, double_fst r ) { return double_fst(subdp(uintdp(l), r.value)); }
inline double_fst operator * ( unsigned char l, double_fst r ) { return double_fst(mpydp(uintdp(l), r.value)); }
inline double_fst operator / ( unsigned char l, double_fst r ) { return double_fst(divdp(uintdp(l), r.value)); }
inline double_fst operator + ( double_fst l, unsigned char r ) { return double_fst(adddp(l.value, uintdp(r))); }
inline double_fst operator - ( double_fst l, unsigned char r ) { return double_fst(subdp(l.value, uintdp(r))); }
inline double_fst operator * ( double_fst l, unsigned char r ) { return double_fst(mpydp(l.value, uintdp(r))); }
inline double_fst operator / ( double_fst l, unsigned char r ) { return double_fst(divdp(l.value, uintdp(r))); }

//Для типа unsigned short
inline double_fst operator + ( unsigned short l, double_fst r ) { return double_fst(adddp(uintdp(l), r.value)); }
inline double_fst operator - ( unsigned short l, double_fst r ) { return double_fst(subdp(uintdp(l), r.value)); }
inline double_fst operator * ( unsigned short l, double_fst r ) { return double_fst(mpydp(uintdp(l), r.value)); }
inline double_fst operator / ( unsigned short l, double_fst r ) { return double_fst(divdp(uintdp(l), r.value)); }
inline double_fst operator + ( double_fst l, unsigned short r ) { return double_fst(adddp(l.value, uintdp(r))); }
inline double_fst operator - ( double_fst l, unsigned short r ) { return double_fst(subdp(l.value, uintdp(r))); }
inline double_fst operator * ( double_fst l, unsigned short r ) { return double_fst(mpydp(l.value, uintdp(r))); }
inline double_fst operator / ( double_fst l, unsigned short r ) { return double_fst(divdp(l.value, uintdp(r))); }

//Для типа unsigned int
inline double_fst operator + ( unsigned int l, double_fst r ) { return double_fst(adddp(uintdp(l), r.value)); }
inline double_fst operator - ( unsigned int l, double_fst r ) { return double_fst(subdp(uintdp(l), r.value)); }
inline double_fst operator * ( unsigned int l, double_fst r ) { return double_fst(mpydp(uintdp(l), r.value)); }
inline double_fst operator / ( unsigned int l, double_fst r ) { return double_fst(divdp(uintdp(l), r.value)); }
inline double_fst operator + ( double_fst l, unsigned int r ) { return double_fst(adddp(l.value, uintdp(r))); }
inline double_fst operator - ( double_fst l, unsigned int r ) { return double_fst(subdp(l.value, uintdp(r))); }
inline double_fst operator * ( double_fst l, unsigned int r ) { return double_fst(mpydp(l.value, uintdp(r))); }
inline double_fst operator / ( double_fst l, unsigned int r ) { return double_fst(divdp(l.value, uintdp(r))); }

//Для типа unsigned long
inline double_fst operator + ( unsigned long l, double_fst r ) { return double_fst(adddp(ulongdp(l), r.value)); }
inline double_fst operator - ( unsigned long l, double_fst r ) { return double_fst(subdp(ulongdp(l), r.value)); }
inline double_fst operator * ( unsigned long l, double_fst r ) { return double_fst(mpydp(ulongdp(l), r.value)); }
inline double_fst operator / ( unsigned long l, double_fst r ) { return double_fst(divdp(ulongdp(l), r.value)); }
inline double_fst operator + ( double_fst l, unsigned long r ) { return double_fst(adddp(l.value, ulongdp(r))); }
inline double_fst operator - ( double_fst l, unsigned long r ) { return double_fst(subdp(l.value, ulongdp(r))); }
inline double_fst operator * ( double_fst l, unsigned long r ) { return double_fst(mpydp(l.value, ulongdp(r))); }
inline double_fst operator / ( double_fst l, unsigned long r ) { return double_fst(divdp(l.value, ulongdp(r))); }

#endif //__FAST_RTS_64X_H

/*!\file fastfloat.h
* \brief This class stores floating point numbers as integers,
* \brief with BITS shift, i.e. value XYZ is stored as XYZ * RATIO
* \version 1.0
* \date 25 april 2008
*/
#ifndef __FAST_FLOAT_H
#define __FAST_FLOAT_H

class fastdouble
{
private:
    enum { BITS = 16, RATIO = 65536 };
    long long value;
    inline fastdouble( long v, bool ) : value( v ) {} // for operator-()
public:
    inline fastdouble() { value=0; }
    inline fastdouble( double v ) { value=static_cast<long long>(v * RATIO + 0.5); }
    inline fastdouble( float v ) { value=static_cast<long long>(v * RATIO + 0.5); }
    inline fastdouble( char v ) { value=static_cast<long long>(v) << BITS; }
    inline fastdouble( short v ) { value=static_cast<long long>(v) << BITS; }
    inline fastdouble( int v ) { value=static_cast<long long>(v) << BITS; }
    inline fastdouble( long v ) { value=static_cast<long long>(v) << BITS; }
    inline fastdouble( unsigned char v ) { value=static_cast<long long>(v) << BITS; }
    inline fastdouble( unsigned short v ) { value=static_cast<long long>(v) << BITS; }
    inline fastdouble( unsigned int v ) { value=static_cast<long long>(v) << BITS; }
    inline fastdouble( unsigned long v ) { value=static_cast<long long>(v) << BITS; }

    inline void operator =( fastdouble r ) { value=r.value; }
    inline void operator =( double v ) { value=static_cast<long long>(v * RATIO + 0.5); }
    inline void operator =( float v ) { value=static_cast<long long>(v * RATIO + 0.5); }
    inline void operator =( char v ) { value=static_cast<long long>(v) << BITS; }
    inline void operator =( short v ) { value=static_cast<long long>(v) << BITS; }
    inline void operator =( int v ) { value=static_cast<long long>(v) << BITS; }
    inline void operator =( long v ) { value=static_cast<long long>(v) << BITS; }
    inline void operator =( unsigned char v ) { value=static_cast<long long>(v) << BITS; }
    inline void operator =( unsigned short v ) { value=static_cast<long long>(v) << BITS; }
    inline void operator =( unsigned int v ) { value=static_cast<long long>(v) << BITS; }
    inline void operator =( unsigned long v ) { value=static_cast<long long>(v) << BITS; }

    inline double toDouble() const { return static_cast<double>( value ) / RATIO; }
    inline long toLong() const { return static_cast<long>(value >> BITS); }

    inline operator double() const { return toDouble(); }
    inline operator float() const { return (float)toDouble(); }
    inline operator char() const { return (char)toLong(); }
    inline operator short() const { return (short)toLong(); }
    inline operator int() const { return (int)toLong(); }
    inline operator long() const { return toLong(); }
    inline operator unsigned char() const { return (unsigned char)toLong(); }
    inline operator unsigned short() const { return (unsigned short)toLong(); }
    inline operator unsigned int() const { return (unsigned int)toLong(); }
    inline operator unsigned long() const { return (unsigned long)toLong(); }

    inline fastdouble operator - () const { return fastdouble( -value, false ); }

    inline fastdouble& operator += ( fastdouble r ) { value += r.value; return *this; }
    inline fastdouble& operator -= ( fastdouble r ) { value -= r.value; return *this; }
    inline fastdouble& operator *= ( fastdouble r ) { value  = ( value * r.value ) >> BITS; return *this; }
    inline fastdouble& operator /= ( fastdouble r ) { value  = ( value << BITS ) / r.value; return *this; }

    inline fastdouble& operator += ( double v ) { value += static_cast<long long>( v * RATIO + 0.5 ); return *this; }
    inline fastdouble& operator -= ( double v ) { value -= static_cast<long long>( v * RATIO + 0.5 ); return *this; }
    inline fastdouble& operator *= ( double v ) { value  = static_cast<long long >( value * v + 0.5 ); return *this; }
    inline fastdouble& operator /= ( double v ) { value  = static_cast<long long>( value / v + 0.5 ); return *this; }

    inline fastdouble& operator += ( float v ) { value += static_cast<long long>( v * RATIO + 0.5 ); return *this; }
    inline fastdouble& operator -= ( float v ) { value -= static_cast<long long>( v * RATIO + 0.5 ); return *this; }
    inline fastdouble& operator *= ( float v ) { value  = static_cast<long long>( value * v + 0.5 ); return *this; }
    inline fastdouble& operator /= ( float v ) { value  = static_cast<long long>( value / v + 0.5 ); return *this; }

    inline fastdouble& operator += ( char v ) { value += static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator -= ( char v ) { value -= static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator *= ( char v ) { value *= v; return *this; }
    inline fastdouble& operator /= ( char v ) { value /= v; return *this; }

    inline fastdouble& operator += ( short v ) { value += static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator -= ( short v ) { value -= static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator *= ( short v ) { value *= v; return *this; }
    inline fastdouble& operator /= ( short v ) { value /= v; return *this; }

    inline fastdouble& operator += ( int v ) { value += static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator -= ( int v ) { value -= static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator *= ( int v ) { value *= v; return *this; }
    inline fastdouble& operator /= ( int v ) { value /= v; return *this; }

    inline fastdouble& operator += ( long v ) { value += static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator -= ( long v ) { value -= static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator *= ( long v ) { value *= v; return *this; }
    inline fastdouble& operator /= ( long v ) { value /= v; return *this; }

    inline fastdouble& operator += ( unsigned char v ) { value += static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator -= ( unsigned char v ) { value -= static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator *= ( unsigned char v ) { value *= v; return *this; }
    inline fastdouble& operator /= ( unsigned char v ) { value /= v; return *this; }

    inline fastdouble& operator += ( unsigned short v ) { value += static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator -= ( unsigned short v ) { value -= static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator *= ( unsigned short v ) { value *= v; return *this; }
    inline fastdouble& operator /= ( unsigned short v ) { value /= v; return *this; }

    inline fastdouble& operator += ( unsigned int v ) { value += static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator -= ( unsigned int v ) { value -= static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator *= ( unsigned int v ) { value *= v; return *this; }
    inline fastdouble& operator /= ( unsigned int v ) { value /= v; return *this; }

    inline fastdouble& operator += ( unsigned long v ) { value += static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator -= ( unsigned long v ) { value -= static_cast<long long>( v ) << BITS; return *this; }
    inline fastdouble& operator *= ( unsigned long v ) { value *= v; return *this; }
    inline fastdouble& operator /= ( unsigned long v ) { value /= v; return *this; }

    //Для типа fastdouble
    inline bool operator <  ( fastdouble r ) const { return value < r.value; }
    inline bool operator <= ( fastdouble r ) const { return value <= r.value; }
    inline bool operator >  ( fastdouble r ) const { return value > r.value; }
    inline bool operator >= ( fastdouble r ) const { return value >= r.value; }
    inline bool operator == ( fastdouble r ) const { return value == r.value; }
    inline bool operator != ( fastdouble r ) const { return value != r.value; }
};

//Для типа fastdouble
inline fastdouble operator+ ( fastdouble l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator- ( fastdouble l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator* ( fastdouble l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator/ ( fastdouble l, fastdouble r ) { return fastdouble( l ) /= r; }

//Для типа double
inline fastdouble operator + ( double l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( double l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( double l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( double l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, double r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, double r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, double r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, double r ) { return fastdouble( l ) /= r; }

//Для типа float
inline fastdouble operator + ( float l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( float l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( float l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( float l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, float r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, float r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, float r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, float r ) { return fastdouble( l ) /= r; }

//Для типа char
inline fastdouble operator + ( char l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( char l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( char l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( char l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, char r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, char r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, char r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, char r ) { return fastdouble( l ) /= r; }

//Для типа short
inline fastdouble operator + ( short l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( short l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( short l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( short l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, short r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, short r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, short r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, short r ) { return fastdouble( l ) /= r; }

//Для типа int
inline fastdouble operator + ( int l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( int l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( int l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( int l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, int r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, int r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, int r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, int r ) { return fastdouble( l ) /= r; }

//Для типа long
inline fastdouble operator + ( long l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( long l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( long l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( long l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, long r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, long r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, long r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, long r ) { return fastdouble( l ) /= r; }

//Для типа unsigned char
inline fastdouble operator + ( unsigned char l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( unsigned char l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( unsigned char l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( unsigned char l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, unsigned char r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, unsigned char r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, unsigned char r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, unsigned char r ) { return fastdouble( l ) /= r; }

//Для типа unsigned short
inline fastdouble operator + ( unsigned short l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( unsigned short l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( unsigned short l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( unsigned short l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, unsigned short r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, unsigned short r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, unsigned short r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, unsigned short r ) { return fastdouble( l ) /= r; }

//Для типа unsigned int
inline fastdouble operator + ( unsigned int l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( unsigned int l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( unsigned int l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( unsigned int l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, unsigned int r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, unsigned int r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, unsigned int r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, unsigned int r ) { return fastdouble( l ) /= r; }

//Для типа unsigned long
inline fastdouble operator + ( unsigned long l, fastdouble r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( unsigned long l, fastdouble r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( unsigned long l, fastdouble r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( unsigned long l, fastdouble r ) { return fastdouble( l ) /= r; }
inline fastdouble operator + ( fastdouble l, unsigned long r ) { return fastdouble( l ) += r; }
inline fastdouble operator - ( fastdouble l, unsigned long r ) { return fastdouble( l ) -= r; }
inline fastdouble operator * ( fastdouble l, unsigned long r ) { return fastdouble( l ) *= r; }
inline fastdouble operator / ( fastdouble l, unsigned long r ) { return fastdouble( l ) /= r; }


//Для типа double
inline bool operator <  ( fastdouble l, double r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, double r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, double r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, double r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, double r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, double r ) { return l != fastdouble( r ); }

inline bool operator <  ( double l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( double l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( double l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( double l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( double l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( double l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа float
inline bool operator <  ( fastdouble l, float r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, float r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, float r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, float r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, float r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, float r ) { return l != fastdouble( r ); }

inline bool operator <  ( float l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( float l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( float l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( float l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( float l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( float l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа char
inline bool operator <  ( fastdouble l, char r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, char r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, char r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, char r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, char r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, char r ) { return l != fastdouble( r ); }

inline bool operator <  ( char l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( char l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( char l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( char l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( char l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( char l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа short
inline bool operator <  ( fastdouble l, short r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, short r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, short r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, short r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, short r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, short r ) { return l != fastdouble( r ); }

inline bool operator <  ( short l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( short l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( short l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( short l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( short l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( short l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа int
inline bool operator <  ( fastdouble l, int r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, int r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, int r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, int r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, int r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, int r ) { return l != fastdouble( r ); }

inline bool operator <  ( int l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( int l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( int l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( int l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( int l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( int l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа long
inline bool operator <  ( fastdouble l, long r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, long r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, long r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, long r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, long r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, long r ) { return l != fastdouble( r ); }

inline bool operator <  ( long l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( long l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( long l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( long l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( long l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( long l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа unsigned char
inline bool operator <  ( fastdouble l, unsigned char r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, unsigned char r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, unsigned char r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, unsigned char r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, unsigned char r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, unsigned char r ) { return l != fastdouble( r ); }

inline bool operator <  ( unsigned char l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( unsigned char l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( unsigned char l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( unsigned char l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( unsigned char l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( unsigned char l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа unsigned short
inline bool operator <  ( fastdouble l, unsigned short r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, unsigned short r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, unsigned short r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, unsigned short r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, unsigned short r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, unsigned short r ) { return l != fastdouble( r ); }

inline bool operator <  ( unsigned short l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( unsigned short l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( unsigned short l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( unsigned short l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( unsigned short l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( unsigned short l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа unsigned int
inline bool operator <  ( fastdouble l, unsigned int r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, unsigned int r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, unsigned int r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, unsigned int r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, unsigned int r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, unsigned int r ) { return l != fastdouble( r ); }

inline bool operator <  ( unsigned int l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( unsigned int l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( unsigned int l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( unsigned int l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( unsigned int l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( unsigned int l, fastdouble r ) { return fastdouble( l ) != r; }

//Для типа unsigned long
inline bool operator <  ( fastdouble l, unsigned long r ) { return l <  fastdouble( r ); }
inline bool operator <= ( fastdouble l, unsigned long r ) { return l <= fastdouble( r ); }
inline bool operator >  ( fastdouble l, unsigned long r ) { return l >  fastdouble( r ); }
inline bool operator >= ( fastdouble l, unsigned long r ) { return l >= fastdouble( r ); }
inline bool operator == ( fastdouble l, unsigned long r ) { return l == fastdouble( r ); }
inline bool operator != ( fastdouble l, unsigned long r ) { return l != fastdouble( r ); }

inline bool operator <  ( unsigned long l, fastdouble r ) { return fastdouble( l ) <  r; }
inline bool operator <= ( unsigned long l, fastdouble r ) { return fastdouble( l ) <= r; }
inline bool operator >  ( unsigned long l, fastdouble r ) { return fastdouble( l ) >  r; }
inline bool operator >= ( unsigned long l, fastdouble r ) { return fastdouble( l ) >= r; }
inline bool operator == ( unsigned long l, fastdouble r ) { return fastdouble( l ) == r; }
inline bool operator != ( unsigned long l, fastdouble r ) { return fastdouble( l ) != r; }

#if 1  // change to 0 to turn fastdouble usage off
#else
#define fastdouble double
#define fasttodouble( v ) double( v )
#define fasttolong( v ) long( v )
#endif

#endif //__FAST_FLOAT_H