¿Qué hace la función CreateMask de BitVector32?

Question

¿Qué hace el CreateMask ( ) función de BitVector32 do? No entendí qué es una máscara.

Me gustaría entender las siguientes líneas de código. ¿Crear máscara solo establece el bit en verdadero?

  // Creates and initializes a BitVector32 with all bit flags set to FALSE.
  BitVector32 myBV = new BitVector32( 0 );

  // Creates masks to isolate each of the first five bit flags.
  int myBit1 = BitVector32.CreateMask();
  int myBit2 = BitVector32.CreateMask( myBit1 );
  int myBit3 = BitVector32.CreateMask( myBit2 );
  int myBit4 = BitVector32.CreateMask( myBit3 );
  int myBit5 = BitVector32.CreateMask( myBit4 );

  // Sets the alternating bits to TRUE.
  Console.WriteLine( "Setting alternating bits to TRUE:" );
  Console.WriteLine( "   Initial:         {0}", myBV.ToString() );
  myBV[myBit1] = true;
  Console.WriteLine( "   myBit1 = TRUE:   {0}", myBV.ToString() );
  myBV[myBit3] = true;
  Console.WriteLine( "   myBit3 = TRUE:   {0}", myBV.ToString() );
  myBV[myBit5] = true;
  Console.WriteLine( "   myBit5 = TRUE:   {0}", myBV.ToString() );

¿Cuál es la aplicación práctica de esto?

Answer 1

BitVector32.CreateMask () es una sustitución del operador de desplazamiento a la izquierda ( < < ) que en la mayoría de los casos da como resultado la multiplicación por 2 (el desplazamiento a la izquierda no es circular, por lo que puede comenzar a perder dígitos, se explica más aquí )

BitVector32 vector = new BitVector32();
int bit1 = BitVector32.CreateMask();
int bit2 = BitVector32.CreateMask(bit1);
int bit3 = 1 << 2;
int bit5 = 1 << 4;

Console.WriteLine(vector.ToString());
vector[bit1 | bit2 | bit3 | bit5] = true;
Console.WriteLine(vector.ToString());

Salida:

  

BitVector32 {00000000000000000000000000000000}   BitVector32 {00000000000000000000000000010111}

Answer 2

Devuelve una máscara que puede usar para recuperar más fácilmente bits interesantes.

Es posible que desee consulte Wikipedia para saber qué es una máscara.

En resumen: una máscara es un patrón en forma de matriz de 1s para los bits que le interesan y 0s para los demás.

Si tiene algo como 01010 y está interesado en obtener los últimos 3 bits, su máscara se vería como 00111. Luego, cuando realice un AND bit a bit en 01010 y 00111 obtendrá los últimos tres bits (00010), dado que AND solo es 1 si ambos bits están configurados, y ninguno de los bits al lado de los primeros tres está configurado en la máscara.

Un ejemplo podría ser más fácil de entender:

BitVector32.CreateMask() => 1 (binary 1)
BitVector32.CreateMask(1) => 2 (binary 10)
BitVector32.CreateMask(2) => 4 (binary 100)
BitVector32.CreateMask(4) => 8 (binary 1000)

CreateMask (int) devuelve el número dado multiplicado por 2.

NOTA : El primer bit es el bit menos significativo, es decir, el bit más alejado a la derecha.

Answer 3

Revise esta otra publicación texto del enlace . Y también, CreateMask no devuelve el número dado multiplicado por 2. CreateMask crea una máscara de bits basada en una posición específica en la palabra de 32 bits (ese es el parámetro que está pasando), que generalmente es x ^ 2 cuando habla de un solo bit (bandera).

Answer 4

Me topé con esta pregunta tratando de averiguar qué hace exactamente CreateMask . No sentí que las respuestas actuales respondieran la pregunta por mí. Después de leer y experimentar un poco, me gustaría compartir mis hallazgos:

Básicamente, lo que dice Maksymilian es correcto: "BitVector32.CreateMask es una sustitución del operador de desplazamiento a la izquierda (< <) que en la mayoría de los casos resulta en la multiplicación por 2".

Porque < < es un operador binario y CreateMask solo toma un argumento, me gustaría agregar que BitVector32.CreateMask (x) es equivalente a x < < 1 .

Cajas fronterizas

Sin embargo, BitVector32.CreateMask (x) no es equivalente a x < < 1 para dos casos de borde:

1. BitVector32.CreateMask (int.MinValue) :
   Se lanzará una InvalidOperationException. int.MinValue corresponde a 10000000000000000000000000000000 . Esto parece un poco extraño. Especialmente considerando cualquier otro valor con un 1 como el bit más a la izquierda (es decir, números negativos) funciona bien. Por el contrario: int.MinValue < < 1 no arrojaría una excepción y solo devolvería 0.

2. Cuando llama a BitVector32.CreateMask (0) (o BitVector32.CreateMask () ). Esto devolverá 1
   (es decir, 00000000000000000000000000000000 se convierte en 00000000000000000000000000000001 ),
   mientras que 0 < < 1 solo devolvería 0.

Multiplicación por 2

CreateMask casi siempre es equivalente a la multiplicación por 2. Además de los dos casos especiales anteriores, difiere cuando el segundo bit de la izquierda es diferente del bit de la izquierda . Se firma un int, por lo que el bit más a la izquierda indica el signo. En ese escenario, el signo se voltea. P.ej. CreateMask (-1) (o 11111111111111111111111111111111 ) da como resultado -2 (o 11111111111111111111111111111110 ), pero CreateMask (int.MaxValue) (o 01111111111111111111111111111111 ) también da como resultado -2.

De todos modos, probablemente no deberías usarlo para este propósito. Según tengo entendido, cuando usas un BitVector32, realmente solo debes considerarlo como una secuencia de 32 bits. El hecho de que usen ints en combinación con BitVector32 probablemente sea solo porque es conveniente.

¿Cuándo es útil CreateMask?

Honestamente no lo sé. Parece de la documentación y el nombre " anterior " del argumento de la función que pretendían que se usara en algún tipo de secuencia: "Use CreateMask () para crear la primera máscara de una serie y CreateMask (int) para todas las máscaras posteriores."

Sin embargo, en el ejemplo de código, lo usan para crear las máscaras para los primeros 5 bits, para posteriormente realizar algunas operaciones en esos bits. No puedo imaginar que esperen que escriba 32 llamadas seguidas en CreateMask para poder hacer algunas cosas con los bits cerca de la izquierda.