¿Cómo calcula esta función el valor absoluto de un flotante a través de una operación NOT y AND?

Estoy tratando de entender cómo funciona el siguiente fragmento de código. Este programa utiliza instrucciones de vector SIMD (Intel SSE) para calcular el valor absoluto de 4 flotadores (así, básicamente, una función vectorizada "fabs ()").

Aquí está el fragmento:

#include <iostream>
#include "xmmintrin.h"

template <typename T>
struct alignas(16) sse_t
{
    T data[16/sizeof(T)];
};

int main()
{
    sse_t<float> x;
    x.data[0] = -4.;
    x.data[1] = -20.;
    x.data[2] = 15.;
    x.data[3] = -143.;
    __m128 a = _mm_set_ps1(-0.0); // ???
    __m128 xv = _mm_load_ps(x.data);
    xv = _mm_andnot_ps(a,xv); // <-- Computes absolute value
    sse_t<float> result;
    _mm_store_ps(result.data, xv);
    std::cout << "x[0]: " << result.data[0] << std::endl;
    std::cout << "x[1]: " << result.data[1] << std::endl;
    std::cout << "x[2]: " << result.data[2] << std::endl;
    std::cout << "x[3]: " << result.data[3] << std::endl;
}

Ahora, sé que funciona, ya que ejecuté el programa yo mismo para probarlo. Cuando se compila con g ++ 4.8.2, el resultado es:

x[0]: 4
x[1]: 20
x[2]: 15
x[3]: 143

Tres preguntas (relacionadas) me desconciertan:

Primero, ¿cómo es posible tomar una función bit a bit y aplicarla en un flotador? Si intento esto en Vanilla C ++, me informa que esto solo funciona para tipos integrales (lo cual tiene sentido).

Pero, segundo, y más importante: ¿cómo funciona? ¿Cómo te ayuda tomar un NOT y un AND? Intentar esto en Python con un tipo integral solo te da el resultado esperado: cualquier número integral Y -1 (que NO es 0), simplemente te devuelve ese número, pero no cambia el signo. Entonces, ¿cómo funciona aquí?

En tercer lugar, noté que si cambio el valor del flotador utilizado para la operación NAND (marcado con tres ???), de -0.0 a 0.0, el programa ya no me da el valor absoluto. Pero, ¿cómo puede existir un -0.0 y cómo ayuda?

Referencias útiles:

Guía intrínseca de Intel