Comment effectuer une opération bitwise sur des nombres à virgule flottante

si vous essayez de changer les bits dans la représentation en virgule flottante, vous pouvez faire quelque chose comme ceci:

union fp_bit_twiddler {
    float f;
    int i;
} q;
q.f = a;
q.i &= (1 << 3);
a = q.f;

comme AndreyT le note, accéder à une union comme celle-ci invoque un comportement indéfini, et le compilateur pourrait faire pousser des bras et vous étrangler. Faire ce qu'il suggère à la place.

float a = 1.4123;
unsigned int* inta = reinterpret_cast<unsigned int*>(&a);
*inta = *inta & (1 << 3);

Regardez ce qui suit. Inspiré par la racine carrée inverse rapide:

#include <iostream>
using namespace std;

int main()
{
    float x, td = 2.0;
    int ti = *(int*) &td;
    cout << "Cast int: " << ti << endl;
    ti = ti>>4;
    x = *(float*) &ti;
    cout << "Recast float: " << x << endl;
    return 0; 
}

@mobrule:

mieux:

#include <stdint.h>
...
union fp_bit_twiddler {
    float f;
    uint32_t u;
} q;

/* mutatis mutandis ... */

Pour ces valeurs int sera probablement ok, mais en général, vous devez utiliser ints non signés pour le bit shifting pour éviter les effets des changements arithmétiques. Et l'uint32_t fonctionnera même sur les systèmes dont les ints ne sont pas 32 bits.

l'implémentation de Python dans les opérations en bitwise à virgule flottante (recette Python)" des opérations en bitwise à virgule flottante fonctionne en représentant des nombres en binaire qui s'étend à l'infini vers la gauche aussi bien que vers la droite à partir du point fractionnel. Parce que les nombres à virgule flottante ont un zéro signé sur la plupart des architectures, il utilise pour représenter les nombres négatifs (en fait, il fait semblant pour ce faire et utilise quelques astuces pour atteindre l'apparence).

ne doivent pas être utilisés sur les flotteurs, car les flotteurs sont spécifiques au matériel, quelle que soit la similitude de matériel que vous ayez. Quel projet / Travail voulez-vous risquer sur "bien ça a fonctionné sur ma machine"? Au lieu de cela, pour C++, vous pouvez obtenir un "feel" similaire pour les opérateurs de bit shift en surchargeant l'opérateur stream sur un" objet "wrapper pour un float:

// Simple object wrapper for float type as templates want classes.
class Float
{
float m_f;
public:
    Float( const float & f )
    : m_f( f )
    {
    }

    operator float() const
    {
        return m_f;
    }
};

float operator>>( const Float & left, int right )
{
    float temp = left;
    for( right; right > 0; --right )
    {
        temp /= 2.0f;
    }
    return temp;
}

float operator<<( const Float & left, int right )
{
    float temp = left;
    for( right; right > 0; --right )
    {
        temp *= 2.0f;
    }
    return temp;
}

int main( int argc, char ** argv )
{
    int a1 = 40 >> 2; 
    int a2 = 40 << 2;
    int a3 = 13 >> 2;
    int a4 = 256 >> 2;
    int a5 = 255 >> 2;

    float f1 = Float( 40.0f ) >> 2; 
    float f2 = Float( 40.0f ) << 2;
    float f3 = Float( 13.0f ) >> 2;
    float f4 = Float( 256.0f ) >> 2;
    float f5 = Float( 255.0f ) >> 2;
}

vous aurez un reste, que vous pouvez jeter en fonction de votre désir application.

float a = 1.4123;
int *b = (int *)&a;
*b = *b & (1 << 3);
// a is now the IEEE floating-point value caused by the manipulation of *b
// equals 1.121039e-44 (tested on my system)

c'est similaire à la réponse de Justin, sauf qu'il ne crée une vue des bits dans les mêmes registres que a . Ainsi, lorsque vous manipulez *b , la valeur de a change en conséquence.

FWIW, il y a un vrai cas d'utilisation pour les opérations bit-wise sur floating point (je viens de le rencontrer récemment) - shaders écrits pour les GPUs qui ne prennent en charge que les anciennes versions de GLSL (1.2 et antérieures n'avaient pas de support pour les opérateurs bit-wise), et où il y aurait perte de précision si les flotteurs étaient convertis en ints.

les opérations bit-wise peuvent être mises en œuvre sur des nombres à virgule flottante en utilisant des restes (modulo) et des vérifications d'inégalité. Exemple:

float A = 0.625; //value to check; ie, 160/256
float mask = 0.25; //bit to check; ie, 1/4
bool result = (mod(A, 2.0 * mask) >= mask); //non-zero if bit 0.25 is on in A

ce qui précède suppose que A se situe entre [0..1) et qu'il n'y a qu'un "bit" dans le masque à vérifier, mais il pourrait être généralisé pour les cas plus complexes.

Cette idée est basée sur certaines infos trouvées sur est-il-possible-pour-mettre en œuvre-bit-à-bit-opérateurs-aide-entier-de l'arithmétique

S'il n'y a même pas de fonction mod intégrée, cela peut aussi être implémenté assez facilement. Exemple:

float mod(float num, float den)
{
    return num - den * floor(num / den);
}