Минимальный и максимальный ноль

Меня беспокоят следующие случаи

min(-0.0,0.0)
max(-0.0,0.0)
minmag(-x,x) 
maxmag(-x,x)

Согласно Wikipedia IEEE 754-2008 говорится о минимальном и максимальном

Операции min и max определены, но оставляют некоторую свободу действий для случая, когда входы равны по значению, но отличаются в представлении. В частности:

min (+ 0, -0) или min (-0, + 0) должно производить что-то со значением нуля, но всегда может возвращать первый аргумент.

Я несколько тестов сравнивал fmin, fmax, min и max, как определено ниже

#define max(a,b) \
   ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a > _b ? _a : _b; })
#define min(a,b) \
   ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a < _b ? _a : _b; })

и _mm_min_ps и _mm_max_ps, которые вызывают инструкцию SSE minps и maxps.

Вот результаты (код, который я использовал для проверки этого, размещен ниже)

fmin(-0.0,0.0)       = -0.0
fmax(-0.0,0.0)       =  0.0
min(-0.0,0.0)        =  0.0
max(-0.0,0.0)        =  0.0
_mm_min_ps(-0.0,0.0) =  0.0
_mm_max_ps(-0.0,0.0) = -0.0

Как вы можете видеть, каждый случай возвращает разные результаты. Итак, мой главный вопрос - что говорят стандартные библиотеки C и С++?. fmin(-0.0,0.0) должен равняться -0.0 и fmax(-0.0,0.0) должен равняться 0.0 или могут быть разными реализациями, позволяющими определять его иначе? Если это реализована реализация, это означает, что для обеспечения совместимости кода с другой реализацией стандартной библиотеки C (.eg от разных компиляторов) необходимо выполнить проверку, чтобы определить, как они реализуют min и max?

Как насчет minmag(-x,x) и maxmag(-x,x)? Они определены в IEEE 754-2008. Являются ли эти реализации определенными, по крайней мере, в IEEE 754-2008? Я делаю вывод из комментария Wikipdia о min и max, что они определены в реализации. Но стандартная библиотека C не определяет эти функции, насколько я знаю. В OpenCL эти функции определяются как

maxmag Возвращает x, если | х | > | y |, или y, если | y | > | x |, в противном случае fmax (x, y).

minmag Возвращает x, если | x | < | y |, или y, если | y | < | x |, в противном случае fmin (x, y).

Набор инструкций x86 не содержит инструкций minmag и maxmag, поэтому я должен был реализовать их. Но в моем случае мне нужна производительность и создание ветки для случая, когда величины равны, неэффективны.

Набор команд Itaninum содержит команды minmag и maxmag (famin и famax), и в этом случае, насколько я могу сказать (от чтения), в этом случае он возвращает второй аргумент. Однако это не то, что minps и maxps. Странно, что _mm_min_ps(-0.0,0.0) = 0.0 и _mm_max_ps(-0.0,0.0) = -0.0. Я бы ожидал, что они вернут первый аргумент в обоих случаях или второй. Почему инструкции minps и maxps определены таким образом?

#include <stdio.h>
#include <x86intrin.h>
#include <math.h>

#define max(a,b) \
   ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a > _b ? _a : _b; })

#define min(a,b) \
   ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a < _b ? _a : _b; })

int main(void) {
    float a[4] = {-0.0, -1.0, -2.0, -3.0};   
    float b[4] = {0.0, 1.0, 2.0, 3.0};
    __m128 a4 = _mm_load_ps(a);
    __m128 b4 = _mm_load_ps(b);
    __m128 c4 = _mm_min_ps(a4,b4);
    __m128 d4 = _mm_max_ps(a4,b4);
    { float c[4]; _mm_store_ps(c,c4); printf("%f %f %f %f\n", c[0], c[1], c[2], c[3]); }
    { float c[4]; _mm_store_ps(c,d4); printf("%f %f %f %f\n", c[0], c[1], c[2], c[3]); }

    printf("%f %f %f %f\n", fmin(a[0],b[0]), fmin(a[1],b[1]), fmin(a[2],b[2]), fmin(a[3],b[3]));
    printf("%f %f %f %f\n", fmax(a[0],b[0]), fmax(a[1],b[1]), fmax(a[2],b[2]), fmax(a[3],b[3]));

    printf("%f %f %f %f\n", min(a[0],b[0]), min(a[1],b[1]), min(a[2],b[2]), min(a[3],b[3]));
    printf("%f %f %f %f\n", max(a[0],b[0]), max(a[1],b[1]), max(a[2],b[2]), max(a[3],b[3]));    
}
//_mm_min_ps: 0.000000, -1.000000, -2.000000, -3.000000
//_mm_max_ps: -0.000000, 1.000000, 2.000000, 3.000000
//fmin: -0.000000, -1.000000, -2.000000, -3.000000
//fmax: 0.000000, 1.000000, 2.000000, 3.000000
//min: 0.000000, -1.000000, -2.000000, -3.000000
//max: 0.000000, 1.000000, 2.000000, 3.000000

Edit:

В отношении С++ я тестировал std::min(-0.0,0.0) и std::max(-0.0,0.0), и оба возвращали -0.0. Что показывает, что std::min не совпадает с fmin, а std::max не совпадает с fmax.