Операции с плавающей точкой без FPU, На сколько падает производительность? Опции

[sigmaN]

Интересно, а можно ли на целочисленном DSP с запасом производительности(скажем в 3-5 раз) зарулить вокодер на плавающей точке?

И вообще, каков overhead, так сказать, FP операций на проце без FPU?
Страдает ли точность вычисления?
Что нужно для подобных "извращений"?
Может быть есть какая-то библиотека виртуального FPU, так сказать?
DSP Техас 55 серии.

[Degun]

Кто пробовал для DSP фирмы Texas Instruments серии 62x или 64x пользоваться библиотекой Fast Run Time Support Library fastrts64x.lib, которая вроде бы предоставляет быструю реализацию основных операций с типами double и float. Насколько она действительно быстрее тех же операций, но встроенных в компилятор? Будет ли выигрыш? Если нет, то зачем она нужна вообще?

[fontp]

Кто пробовал для DSP фирмы Texas Instruments серии 62x или 64x пользоваться библиотекой Fast Run Time Support Library fastrts64x.lib, которая вроде бы предоставляет быструю реализацию основных операций с типами double и float. Насколько она действительно быстрее тех же операций, но встроенных в компилятор? Будет ли выигрыш? Если нет, то зачем она нужна вообще?

Нужна затем, чтобы уйти от стандарта IEEE и игнорировать всякие overflow/underflow. Как всегда проверки на ошибки забирают большую часть усилий и вся мощь уходит зазря. В Borland C тоже всегда был "fast float" и смысл тот же - не делать проверок и ускориться раза в 2.
Насколько быстро это всё будет для TI? Да не очень . Раз в 50-100 медленнее такта процессора (т.е. вычислений fixed). Длинна слова-то - стандартная и мантисса/порядок не выровнены на границу 16 бит

[rifch]

Нужна затем, чтобы уйти от стандарта IEEE и игнорировать всякие overflow/underflow. Как всегда проверки на ошибки забирают большую часть усилий и вся мощь уходит зазря. В Borland C тоже всегда был "fast float" и смысл тот же - не делать проверок и ускориться раза в 2.
Насколько быстро это всё будет для TI? Да не очень . Раз в 50-100 медленнее такта процессора (т.е. вычислений fixed). Длинна слова-то - стандартная и мантисса/порядок не выровнены на границу 16 бит

Сделал для функций этой библиотеки обёртку. Но оказалось, что с ней интересующая меня функция билинейного масштабирования работает даже медленее, чем при использовании встроенных в компилятор типа double. Из-за чего это? Может из-за накладных расходов на организацию классов?

Код

/*!\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

[fontp]

Сделал для функций этой библиотеки обёртку. Но оказалось, что с ней интересующая меня функция билинейного масштабирования работает даже медленее, чем при использовании встроенных в компилятор типа double. Из-за чего это? Может из-за накладных расходов на организацию классов?

Обёртка, то ладно...Надеюсь, все функции библиотеки объявлены как inline. Иначе - беда. Издержки на вызов функции

[Degun]

Обёртка, то ладно...Надеюсь, все функции библиотеки объявлены как inline. Иначе - беда. Издержки на вызов функции

А разве можно функции, собранные в файл-библиотеку fastrts62x64x.lib, объявить как inline. Вроде бы, т. к. они уже скомпилированны в библиотеку, то они не могут быть inline.

[fontp]

А разве можно функции, собранные в файл-библиотеку fastrts62x64x.lib, объявить как inline. Вроде бы, т. к. они уже скомпилированны в библиотеку, то они не могут быть inline.

Так чего Вы тогда от него хотите? Короткие функции, вызываемые через Call по определению будут работать медленно. Для стандартных float это не так, они оформлены intrinsic и вставляются компилятором inline
А вот Вы возьмите не библиотеку lib, а её исходный код. Повытаскивайте те функции, что Вам нужны в h-файл и припишите к каждой функции модификатор inline - и всё сразу станет во много раз быстрее.

[Degun]

Так чего Вы тогда от него хотите? Короткие функции, вызываемые через Call по определению будут работать медленно. Для стандартных float это не так, они оформлены intrinsic и вставляются компилятором inline
А вот Вы возьмите не библиотеку lib, а её исходный код. Повытаскивайте те функции, что Вам нужны в h-файл и припишите к каждой функции модификатор inline - и всё сразу станет во много раз быстрее.

Как-то это некрасиво - лучше пойти другим путём. Я сделал класс на основе представления плавающего числа типа double в виде целочисленного типа long long (на основе класса fastfloat по ссылке http://www.koders.com/cpp/fid5E90955711BFB...1C652C383C.aspx). Такой подход предоставляет полный эквивалент числа с плавающей запятой без использования последнего. Моя тестовая функция билинейного масштабирования при этом сразу стала выполняться в полтора раза быстрее. И это при том, что я её ещё не оптимизировал насчёт применения DMA (тогда бы улучшение производительности было бы гораздо заметнее). Так что предлагаю к использованию (охотно принимаются замечания по улучшению производительности этого класса или замеченные ошибки).

Код

/*!\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

Сообщение отредактировал Degun - Apr 25 2008, 12:51