integer - gates - idempotent law boolean algebra

operaciones booleanas con enteros

Question

Esto es probablemente bastante básico ... pero parece que no lo entiendo:

Cómo

(2 & 1) = 0
(3 & 1) = 1
(4 & 1) = 0

etc.

Este patrón anterior parece ayudar a encontrar números pares

o

(0 | 1) = 1
(1 | 1) = 1
(2 | 1) = 3
(3 | 1) = 4
(4 | 1) = 5
(5 | 1) = 5

Sé cómo funciona el álgebra booleana entre bits. Pero no entiendo cómo funciona el álgebra de Boole con números enteros (en C # como mínimo).

gracias por adelantado.

Answer 1

Está haciendo operaciones bit a bit en el entero. Que está haciendo una lógica y / o de cada bit en el primer entero con el bit correspondiente en el otro entero. Luego devuelve el resultado de todas estas operaciones. Por ejemplo, 4 = 0100 y 1 = 0001, una lógica y de estos sería y bits los bits en orden y obtener 0000 (ya que 0 & 0 = 0, 1 & 0 = 0, 0 & 0 = 0 y 0 & 1 = 0). Para o, obtendrías 0101 (ya que 0 | 0 = 0, 1 | 0 = 1, 0 | 0 = 0 y 0 | 1 = 1). El truco es que estas son operaciones bit a bit, no operaciones lógicas que operan solo en valores booleanos en C #.

Answer 2

Funciona de la misma manera en C # que en binario.

2 | 1 = 3 2 | 1 = 3 y 4 | 1 = 5 4 | 1 = 5 .

Para entender esto, debes pensar en la representación binaria de 1,2,3,4 y 5:

010 | 001 = 011 010 | 001 = 011 y 100 | 001 = 101 100 | 001 = 101 .

Similar:

010 & 001 = 000 y 011 & 001 = 001

Answer 3

La clave es que la CPU está haciendo 32 operaciones booleanas en paralelo, una para cada posición de bits de los enteros de entrada (suponiendo enteros de 32 bits, por supuesto).

Answer 4

Obtendrá el primer resultado porque está realizando un booleano and entre las cadenas de bits de los dos números:

2 & 1 => 010 & 001 = 000 = 0
3 & 1 => 011 & 001 = 001 = 1
4 & 1 => 100 & 001 = 000 = 0
5 & 1 => 101 & 001 = 001 = 1

En efecto, está probando si el bit ''1'' está configurado, lo que solo será cierto para los números impares.

Al realizar or operaciones:

0 | 1 => 000 | 001 = 001 = 1
1 | 1 => 001 | 001 = 001 = 1
2 | 1 => 010 | 001 = 011 = 3
3 | 1 => 011 | 001 = 011 = 3
4 | 1 => 100 | 001 = 101 = 5
5 | 1 => 101 | 001 = 101 = 5

Como en este caso el efecto o el or es establecer siempre el bit 1 , los números pares se incrementarán en uno al número impar mayor más cercano.