| |
 Операции с плавающей точкой без FPU, На сколько падает производительность? |
|
|
|
|
 Apr 4 2008, 09:10
|
Эксперт
Группа: Свой
Сообщений: 1 467
Регистрация: 25-06-04
Пользователь №: 183
|
Цитата(sigmaN @ Apr 4 2008, 12:50)  Господа, ну послушайте не сэмплы с сайта, которые действительно ужасно звучат(они просто закодированы/раскодированы на стандартных настройках кодера), а проведите эксперимент самостоятельно. VBR дает обалденное качество на 4Кб/с, по сравнению с другими!
Ну может быть посоветуйте что-нибудь, чтобы было не хуже GSM по субъективным оценкам пользователей, но на скорости не более 4.5.
Задача вообще решаема?
GSM очень расточителен(целых 13Кб/с!) Целочисленный MELP 2.4 кб/cек считается не хуже gSM, но хуже всех стандартных вокодеров серии G co скоростью > 5.3 Портируйте этот целочисленный код прямо на С http://electronix.ru/forum/index.php?showt...335&hl=melpлегко получите 50 мипс (я проверял) http://electronix.ru/forum/index.php?showt...177&hl=melpЕсли важно потребление - делайте на BF. Снижая частоту штатно до 100мгц (напряжение питания 0.8в) вы легко получите 80 мвт потребления - 0.8в х 100 ма - лучше всякого тмс Остальные 50 мгц останутся на прибабахи типа эхоподавителя. Эхоподавитель NLMS можете взять у меня на С (на той же библиотеке ETSI, что и все стандартные вокодеры) http://electronix.ru/forum/index.php?showt...=21804&st=0Или переделать эхоподавитель из SPEEX с помощью той статьи про Frequency-Domain на fixed. http://people.xiph.org/~jm/papers/valin_taslp2006.pdfОни по ней делают. Но это уже серьёзная работа, а не "портирование"
|
|
|
|
|
|
|
|
Apr 4 2008, 10:50
|
Гуру
Группа: Свой
Сообщений: 4 363
Регистрация: 13-05-05
Из: Москва
Пользователь №: 4 987
|
Цитата(fontp @ Apr 4 2008, 11:52) С 6.3 я погорячился, исправил на 5.3 ещё до Вашего поста.
G723.1 (5.3) - это ACELP, c FS-1016 одного поля ягода. "A" в ACELP влияет на скорость поиска,
но не на размер таблицы, а значит качество звучания Не соглашусь, пожалуй. "А" - это алгебраический способ возбуждения адаптивной кодовой книги, в отличие от стохастического, как в "родном" CELP-е. Видимо, более эффективный - качество звучания ACELP-5,3 заметно выше, чем CELP-4,8. Особенно на высоких мужских и женских голосах. Цитата(fontp @ Apr 4 2008, 11:52) Слушать SPEEX нужно в соответствующем диапазоне > 4.8. На нижнем диапазоне 2.4 его лучше вообще не слушать. Я слушал сэмплы на 4 и 6 кб/с. Честно говоря, "нифпечатлило". Цитата(fontp @ Apr 4 2008, 11:52) ...А так всё примерно одинаково (FS1016, SPEEX, G723/1 - 5.3) - линейные предсказания, спектральные пары, кодовые книги и т.д. Примерно одна фигня Может быть, а только по мне G723.1 звучит всё-таки лучше. Правда, я давно этими делами не занимался, и у меня нет сейчас "работающих" реализаций для РС. Если у Вас есть, можно попробовать сравнить на разных речевых фрагментах, и выложить здесь результаты, на суд публики. Цитата(fontp @ Apr 4 2008, 11:52) ...Да ладно. Посмотрите как написано в FastFloat16 в соответствующем EE185 для BF
Мантиссы умножил, порядки сложил - вот и умножение
Нормализовал операнды к большему порядку, сложил мантиссы - вот и сложение
Или деление. Фигня. Нормализация и целочисленное деление.
Нормализация у BF - это две операции, норм и шифт. Ну, вот и попробуйте сделать операцию типа свёртки над двумя или более массивами в формате, скажем, 1.15, и то же самое с любым "плывучим" форматом. А потом сравним. Операции типа свёртки, кстати, отнимают около 90% вычислительной нагрузки при реализации вокодера CELP, так что остальное можно не учитывать. Цитата(fontp @ Apr 4 2008, 11:52) ...На ADSP2105, понятно, ничего не получится, нет там аппаратной нормализации :-) Ошибаетесь - есть.  Цитата(fontp @ Apr 4 2008, 11:52) ...Всё инлайн. Без проверок переполнения и потери точности. В 10 раз даже много. По-моему, в 10 раз всё-таки не получится... Могу предоставить пример исходника, на котором всё это можно проверить, но попозже.
--------------------
Самонадеянность слепа. Сомнения - спутник разума. (с)
|
|
|
|
|
|
|
|
Apr 4 2008, 11:15
|
Эксперт
Группа: Свой
Сообщений: 1 467
Регистрация: 25-06-04
Пользователь №: 183
|
Цитата(Stanislav @ Apr 4 2008, 14:50) Если у Вас есть, можно попробовать сравнить на разных речевых фрагментах, и выложить здесь результаты, на суд публики. У меня есть буквально ВСЁ, но не хочу я этим заниматься, времени жалко. Оно всё ещё и плывёт от условий. Про экспертов и их субъективные оценки, я, как эксперт, уже всё сказал: "Всякий эксперт при субъективной оценке должен учитывать, что его не только могут не позвать в другой раз, но могут и не заплатить в этот" (с) Наиважнейшее правило для всех экспертов. Копирайт мой собственный От МOS 3 до 3.5 - качество приемлемое От 3.5 до 4.0 - хорошее Ниже 3.0 - синтетическое Цитата: g729a сохраняет не ниже 3.5 при потере 3.5% пакетов, а при 5% качество падает до 3.0 g723.1 сохраняет стандартное качество 3.5 при потере менее 1% пакетов, а при 3% падает до 2.8 Конец цитаты. В общем, не очень-то это занятие продуктивное - сравнивать... Экспертам за это хоть деньги дают Цитата(Stanislav @ Apr 4 2008, 14:50) Ну, вот и попробуйте сделать операцию типа свёртки над двумя или более массивами в формате, скажем, 1.15, и то же самое с любым "плывучим" форматом. А потом сравним. По уму нужно конечно делать блочную нормализацию и лупить целочисленно Цитата(Stanislav @ Apr 4 2008, 14:50) Ошибаетесь - есть. По-моему, в 10 раз всё-таки не получится... Могу предоставить пример исходника, на котором всё это можно проверить, но попозже. Уже есть? Ну может и есть. Уже не помню Вот mult для BF из EE185 FastFloat.asm .global _mult_ff16; _mult_ff16: r3.l = r0.l + r1.l (ns); a0 = r0.h * r1.h; r2.l = signbits a0; // get the number of sign bits a0 = ashift a0 by r2.l; // normalize the mantissa r0 = a0; r0.l = r3.l - r2.l (ns); // adjust the exponent rts; _mult_ff16.end: А вот add _add_ff16: .global _add_ff16; r2.l = r0.l - r1.l (ns); // is Ex > Ey? cc = an; // negative result? r2.l = r2.l << 11 (s); // guarantee shift range [-16,15] r2.l = r2.l >>> 11; if !cc jump _add_ff16_1; // no, shift y r0.h = ashift r0.h by r2.l; // yes, shift x jump _add_ff16_2; _add_ff16_1: r2 = -r2 (v); r1.h = ashift r1.h by r2.l; // shift y a0 = 0; a0.l = r0.l; // you can't do r1.h = r2.h r1.l = a0 (iu); // so use a0.x as an intermediate storage place _add_ff16_2: r2.l = r0.h + r1.h (ns); // add fractional parts cc = v; // was there an overflow? if cc jump _add_ff16_3; // normalize r0.l = signbits r2.l; // get the number of sign bits r0.h = ashift r2.l by r0.l; // normalize the mantissa r0.l = r1.l - r0.l (ns); // adjust the exponent rts; Ну, там addd нужно немного доработать, чтобы избавить от глупостей проверки переполнения - это лишнее. Никаких Jump не должно быть, понятно. Никаких проверок. И всё в inline оформить Где здесь 20 тактов? :-) Цитата(fontp @ Apr 4 2008, 13:10) Целочисленный MELP 2.4 кб/cек считается не хуже gSM, но хуже всех стандартных вокодеров серии G
co скоростью > 5.3 про качество MELP почему-то не вставилось в тот раз http://maya.arcon.com/ddvpc/compmelp.htmЭто родные цифры качества Его качество 3-3.5 т.е. в точности соответствует GSM (13 кбит) и примерно CELP 1016 (4.8 кбит) Если нужно меньше 4 кбит, то это скорее всего melp
|
|
|
|
|
|
|
|
Apr 24 2008, 13:33
|
Частый гость
Группа: Свой
Сообщений: 178
Регистрация: 30-12-04
Из: Москва
Пользователь №: 1 762
|
Цитата(fontp @ Apr 22 2008, 11:21) Нужна затем, чтобы уйти от стандарта 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
|
|
|
|
|
|
|
|
Apr 25 2008, 06:08
|
Частый гость
Группа: Новичок
Сообщений: 84
Регистрация: 4-09-07
Из: Москва
Пользователь №: 30 277
|
Цитата(fontp @ Apr 24 2008, 17:39) Обёртка, то ладно...Надеюсь, все функции библиотеки объявлены как inline. Иначе - беда. Издержки на вызов функции А разве можно функции, собранные в файл-библиотеку fastrts62x64x.lib, объявить как inline. Вроде бы, т. к. они уже скомпилированны в библиотеку, то они не могут быть inline.
|
|
|
|
|
|
|
|
Apr 25 2008, 07:16
|
Эксперт
Группа: Свой
Сообщений: 1 467
Регистрация: 25-06-04
Пользователь №: 183
|
Цитата(Degun @ Apr 25 2008, 10:08) А разве можно функции, собранные в файл-библиотеку fastrts62x64x.lib, объявить как inline. Вроде бы, т. к. они уже скомпилированны в библиотеку, то они не могут быть inline. Так чего Вы тогда от него хотите? Короткие функции, вызываемые через Call по определению будут работать медленно. Для стандартных float это не так, они оформлены intrinsic и вставляются компилятором inline А вот Вы возьмите не библиотеку lib, а её исходный код. Повытаскивайте те функции, что Вам нужны в h-файл и припишите к каждой функции модификатор inline - и всё сразу станет во много раз быстрее.
|
|
|
|
|
|
|
|
Apr 25 2008, 12:49
|
Частый гость
Группа: Новичок
Сообщений: 84
Регистрация: 4-09-07
Из: Москва
Пользователь №: 30 277
|
Цитата(fontp @ Apr 25 2008, 11:16) Так чего Вы тогда от него хотите? Короткие функции, вызываемые через 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
|
|
|
|
|
|
|
|
Jun 17 2008, 13:37
|
Частый гость
Группа: Свой
Сообщений: 90
Регистрация: 18-06-07
Из: Екатеринбург
Пользователь №: 28 521
|
... а если переписать этот класс с использованием типа данных fract16 (для BLACKFIN), то будет работать быстрее? Цитата(Andrew32768 @ Jun 17 2008, 18:52) ... а если переписать этот класс с использованием типа данных fract16 (для BLACKFIN), то будет работать быстрее? или же fract16 виртуальный тип данных, не поддерживаемый напрямую процессором?
|
|
|
|
|
|
|
|
Jun 17 2008, 14:18
|
Частый гость
Группа: Свой
Сообщений: 90
Регистрация: 18-06-07
Из: Екатеринбург
Пользователь №: 28 521
|
Цитата(fontp @ Jun 17 2008, 20:00) Как это? fract16 - это short c прямой поддержкой процессором и библиотеками Какой же он виртуальный? Очевидно будет быстрее всего fract32 уже как бы синтетический, как бы виртуальный  я тоже читаю в описании, что его поддерживает процессор но почему же тогда в INCLUDE, куча definов, которые описывают элементарные операции с этим типом (деление, например)?
|
|
|
|
|
|
1 чел. читают эту тему (гостей: 1, скрытых пользователей: 0)
Пользователей: 0
|
|
|
