Простой способ сравнения дублей

Question

Я пишу числовой код, который должен делать обширные (и, возможно, быстрые) сравнения чисел с двойной точностью. Мое решение для сравнения двух чисел A и B включает смещение A влево (или вправо) на epsilon и проверку того, является ли результат больше (или меньше), чем B. Если это так, два двойника одинаковы. (Дополнительное кодирование необходимо выполнить для отрицательных или нулевых чисел).

Это сравнение функции:

#define S_ 
inline double s_l (double x){ 
    if(x>0){return 0.999999999*x;} 
    else if(x<0){return 1.00000001*x;} 
    else {return x-0.000000000001;} 
} 
inline double s_r (double x){ 
    if(x>0){return 1.00000001*x;} 
    else if(x<0){return 0.999999999*x;} 
    else{return x+0.000000000001;} 
} 
inline bool s_equal (double x,double y){ 
    if(x==y){return true;} 
    else if(x<y && s_r(x)>y){return true;} 
    else if(x>y && s_l(x)<y){return true;} 
    else{return false;} 
} 
#endif 

Поскольку это является частью MonteCarlo алгоритма и s_equal (х, у) называется миллионы раз, я задаюсь вопросом, есть ли лучше или быстрее способ кодирования это, понятно на простом уровне.

Answer 1

Я делаю что-то вроде abs ((x-y)/x) < 1.0e-10.

Вам нужно разделить на x, если оба значения огромны или малы.

Answer 2

Если вы используете C++ 11, то вы могли бы использовать новые math библиотечные функции, такие как:

bool isgreater(float x, float y)

Больше документации на std::isgreater можно было here.

В противном случае всегда есть is_equal в boost. Кроме того, у SO уже есть куча связанных (не уверены, одинаковых) вопросов, таких как here, here и here.

Answer 3

Я был удивлен, обнаружив значительное ускорение, избегая всех двойную точность математики:

#define S_L(x) (x)+((x)<0?1024:-1024) 
#define S_R(x) (x)+((x)<0?-1024:1024) 
#define S_EQUAL(x,y) (S_L(x)<(y) && S_R(x)>(y)) 

double foo;                  
double bar;                  
long *pfoo;                  
long *pbar;                  

pfoo = (long*)&foo;                
pbar = (long*)&bar;   

double result1 = S_R(*pfoo); 
double result2 = S_L(*pbar); 
bool result3 = S_EQUAL(*pfoo, *pbar); 

(Во время тестирования я прооперировал случайно сгенерированные двойники между 1М и 1М, выполнением каждой операции 100M раз . с различным входом для каждой итерации каждой операции была приурочена в независимом цикле, сравнивая раз системы -. не стена раз включая накладные петли и генерацию случайных чисел, это решение было около 25% быстрее)

слова. предупреждения: здесь есть много зависимостей аппаратное обеспечение, диапазон ваших удвоений, поведение вашего оптимизатора и т. д. и т. д. Такие ошибки являются обычным явлением, когда вы начинаете угадывать свой компилятор. Я был потрясен, увидев, насколько это было для меня быстрее, так как мне всегда говорили, что целые и плавающие единицы хранятся настолько раздельно на аппаратных средствах, что передача бит от одного к другому всегда требует операции с аппаратной памятью. Кто знает, как хорошо это сработает для вас.

Вам, вероятно, придется немного поиграть с магическими цифрами (1024-е), чтобы заставить его делать то, что вы хотите, - если это возможно.