b'\n_START_ARTICLE_\nOperador a nivel de bits\n_START_PARAGRAPH_\nUna operaci\xc3\xb3n bit a bit o bitwise opera sobre n\xc3\xbameros binarios a nivel de sus bits individuales. Es una acci\xc3\xb3n primitiva r\xc3\xa1pida, soportada directamente por los procesadores. En procesadores simples de bajo costo, las operaciones de bit a bit, junto con los de adici\xc3\xb3n y sustracci\xc3\xb3n, son t\xc3\xadpicamente sustancialmente m\xc3\xa1s r\xc3\xa1pidas que la multiplicaci\xc3\xb3n y la divisi\xc3\xb3n, mientras que en los modernos procesadores de alto rendimiento usualmente las operaciones se realizan a la misma velocidad.\n_START_SECTION_\nOperadores bit a bit\n_START_PARAGRAPH_\nEn las explicaciones de abajo, cualquier indicaci\xc3\xb3n de una posici\xc3\xb3n de un bit es contada de derecha a izquierda a partir del bit menos significativo. Por ejemplo, el valor binario 0001 (el decimal 1) tiene ceros en cada posici\xc3\xb3n excepto en la primera.\n_START_SECTION_\nDeterminando el estado de bits\n_START_PARAGRAPH_\nEl AND puede ser usado para determinar si un bit particular est\xc3\xa1 encendido (1) o apagado (0). Por ejemplo, dado un patr\xc3\xb3n de bits 0011, para determinar si el segundo bit est\xc3\xa1 encendido se usa una operaci\xc3\xb3n AND con una m\xc3\xa1scara que contiene encendido solo el segundo bit, que es el que se quiere determinar:_NEWLINE_    0011_NEWLINE_AND 0010  (m\xc3\xa1scara)_NEWLINE_  = 0010_NEWLINE_Puesto que el resultado 0010 es diferente de cero, se sabe que el segundo bit en el patr\xc3\xb3n original est\xc3\xa1 encendido. Esto es a menudo llamado enmascaramiento del bit (bit masking). (Por analog\xc3\xada, al uso de las cintas de enmascarar, que cubren o enmascaran porciones que no deben ser alteradas o porciones que no son de inter\xc3\xa9s. En este caso, los valores 0 enmascaran los bits que no son de inter\xc3\xa9s).\n_START_SECTION_\nExtrayendo bits\n_START_PARAGRAPH_\nEl AND se puede usar para extraer determinados bits de un valor. Si en un byte, por ejemplo, tenemos representados dos d\xc3\xadgitos hexadecimales empaquetados, (uno en los 4 bits superiores y el otro en los 4 bits inferiores), podemos extraer cada d\xc3\xadgito hexadecimal usando el AND con las m\xc3\xa1scaras adecuadas:_NEWLINE_    0011 0101                    0011 0101_NEWLINE_AND 1111 0000  (m\xc3\xa1scara)     AND 0000 1111  (m\xc3\xa1scara)_NEWLINE_  = 0011 0000                  = 0000 0101_NEWLINE_  Hex. superior                Hex. inferior\n_START_SECTION_\nApagando bits\n_START_PARAGRAPH_\nEl AND tambi\xc3\xa9n se puede usar para apagar determinados bits. Solo hay que poner una m\xc3\xa1scara con bits en cero en las posiciones de los bits que se quieren apagar y 1 en los dem\xc3\xa1s bits. Todos los dem\xc3\xa1s bits con la m\xc3\xa1scara 1 pasar\xc3\xa1n inalterados, y los que tienen la m\xc3\xa1scara 0 se apagar\xc3\xa1n. Dado el ejemplo 0111, el segundo bit puede ser apagado usando un AND con el patr\xc3\xb3n que tiene un cero en el segundo bit y un 1 en el resto de los bits:_NEWLINE_    0111_NEWLINE_AND 1101  (m\xc3\xa1scara)_NEWLINE_  = 0101\n_START_SECTION_\nEncendiendo bits\n_START_PARAGRAPH_\nEl OR bit a bit, o bitwise, puede ser usado para encender un bit individual o un conjunto de bits. Para ello se usa una m\xc3\xa1scara OR con los bits que se quieren encender en 1 y el resto de los bits en cero. El resultado ser\xc3\xa1 que todos los bits originales quedar\xc3\xa1n como estaban excepto los bits en donde la m\xc3\xa1scara tenga 1, que resultar\xc3\xa1n encendidos. Por ejemplo, si en el patr\xc3\xb3n de bits 0101 se quiere encender el segundo bit se har\xc3\xa1 de la manera siguiente:_NEWLINE_   0101_NEWLINE_OR 0010  (m\xc3\xa1scara)_NEWLINE_ = 0111\n_START_SECTION_\nCopiando bits\n_START_PARAGRAPH_\nEl OR, y el desplazamiento l\xc3\xb3gico (explicado m\xc3\xa1s adelante), puede ser usado para copiar un grupo de bits a una posici\xc3\xb3n determinada._NEWLINE_Supongamos que tenemos el signo, el exponente, y la parte significativa de un n\xc3\xbamero, en diferentes registros de 32 bits, y queremos empaquetarlos para formar un n\xc3\xbamero en representaci\xc3\xb3n de punto flotante de simple precisi\xc3\xb3n de 32 bits:_NEWLINE_              Signo: 00000000000000000000000000000001_NEWLINE_          Exponente: 00000000000000000000000010000011_NEWLINE_Parte significativa: 00000000011100000111000000001110_NEWLINE_Todos ellos tienen los valores correctos y tenemos que mover cada uno de ellos a su posici\xc3\xb3n para poder armar el punto flotante._NEWLINE_Se debe mover el signo 31 posiciones hacia la izquierda, el exponente 23 posiciones hacia la izquierda, y la parte significativa no es necesaria moverla porque ya est\xc3\xa1 en la posici\xc3\xb3n correcta. Estos desplazamientos se hacen con la operaci\xc3\xb3n de desplazamiento hacia la izquierda descrito m\xc3\xa1s adelante:_NEWLINE_              Signo: 10000000000000000000000000000000   <-- Se desplaza el signo 31 posiciones hacia la izquierda_NEWLINE_          Exponente: 01000001100000000000000000000000   <-- Se desplaza el exponente 23 posiciones hacia la izquierda_NEWLINE_Parte significativa: 00000000011100000111000000001110   <-- La parte significativa no se mueve, ya est\xc3\xa1 en su lugar_NEWLINE_Ahora que tenemos cada parte del n\xc3\xbamero en su lugar, las combinamos para empaquetarlas y formar el n\xc3\xbamero en su representaci\xc3\xb3n de punto flotante de 32 bits. Para ello usamos el OR: (Resultado final) = (Signo) OR (Exponente) OR (Parte significativa):_NEWLINE_              Signo: 10000000000000000000000000000000_NEWLINE_          Exponente: 01000001100000000000000000000000_NEWLINE_Parte significativa: 00000000011100000111000000001110_NEWLINE_    Resultado final: 11000001111100000111000000001110_NEWLINE_Ya tenemos el n\xc3\xbamero en su representaci\xc3\xb3n de punto flotante definitiva.\n_START_SECTION_\nProcedimiento gen\xc3\xa9rico para copiar un grupo de bits\n_START_PARAGRAPH_\nPara copiar una serie de bits en un lugar determinado usando OR, se necesita que ese lugar donde se van a copiar tenga sus bits en cero (para hacer un espacio libre para poder copiar los bits). Tambi\xc3\xa9n se necesita que el registro donde se encuentran los bits que se quieren copiar tenga los dem\xc3\xa1s bits (los que no se quieren copiar) apagados. Ambas operaciones, aclarar los bits en el lugar del destino, y aclarar los bits que no se quieren copiar se hacen con AND:_NEWLINE_Tenemos dos registros de 16 bits:_NEWLINE_Registro A: 1011 1100 0110 1100_NEWLINE_Registro B: 1001 0001 1111 1010_NEWLINE_Queremos copiar los cuatro bits menos significativos del registro A en el registro B._NEWLINE_Para ello, primero aclaramos los 4 bits menos significativos de B con una operaci\xc3\xb3n AND, y as\xc3\xad tener un espacio libre:_NEWLINE_            1001 0001 1111 1010   <-- Valor original del registro B_NEWLINE_        AND 1111 1111 1111 0000   <-- M\xc3\xa1scara para aclarar los bits de B donde se van a copiar los que vienen de A_NEWLINE_          = 1001 0001 1111 0000   <-- Registro B preparado para recibir los 4 bits menos significativos de A_NEWLINE_Luego, aclaramos los bits de A que no queremos copiar, dejando solo los bits que queremos copiar:_NEWLINE_            1011 1100 0110 1100   <-- Valor original del registro A_NEWLINE_        AND 0000 0000 0000 1111   <-- M\xc3\xa1scara para dejar solo los bits de A que se quieren copiar_NEWLINE_          = 0000 0000 0000 1100   <-- Registro A con solo los bits que se desean copiar_NEWLINE_Ahora estamos listos para hacer el OR de A sobre B y combinar los 4 bits menos significativos de A sobre B:_NEWLINE_            0000 0000 0000 1100   <-- Registro A con los 4 bits que se desean copiar_NEWLINE_         OR 1001 0001 1111 0000   <-- Registro B con un espacio para los 4 bits que desean copiar_NEWLINE_          = 1001 0001 1111 1100   <-- Registro B con los 4 bits menos significativos de A copiados sobre \xc3\xa9l_NEWLINE_Ahora, el registro B tiene copiado los 4 bits menos significativos de A. El resto de los bits de B quedaron intactos.\n_START_SECTION_\nInvirtiendo bits selectivamente\n_START_PARAGRAPH_\nA diferencia del NOT, que invierte todos los bits de un operando, el XOR bit a bit, o bitwise, puede ser usado para invertir selectivamente uno o m\xc3\xa1s bits en un registro. Dado el patr\xc3\xb3n de bits 0011, el segundo y el cuarto bit pueden ser invertidos por XOR con una m\xc3\xa1scara con un patr\xc3\xb3n de bits conteniendo 1 en las posiciones que se quieren invertir, la segunda y cuarta, y 0 en las dem\xc3\xa1s. Los bits de las posiciones con cero de la m\xc3\xa1scara resultar\xc3\xa1n inalterados:_NEWLINE_    0011_NEWLINE_XOR 1010  (m\xc3\xa1scara)_NEWLINE_  = 1001\n_START_SECTION_\nAsignar cero a un registro\n_START_PARAGRAPH_\nLos programadores avanzados de lenguaje ensamblador usan XOR como una manera eficiente y r\xc3\xa1pida de asignar cero a un registro. Realizar XOR de un valor contra s\xc3\xad mismo siempre resulta en cero (A XOR A siempre es cero), y en muchas arquitecturas esta operaci\xc3\xb3n requiere menos ciclos de reloj y/o memoria que cargar un valor cero a un registro (A = 0).\n_START_SECTION_\nEn resumen\n_START_PARAGRAPH_\nLas operaciones bit a bit, o bitwise, pueden encender, apagar, dejar pasar, eliminar, o invertir, bits individualmente o en conjunto, usando la m\xc3\xa1scara adecuada con un OR, AND, o XOR:_NEWLINE_   0011                 1011                 10101                 10101                 1010_NEWLINE_OR 1000 (m\xc3\xa1scara)   AND 1110 (m\xc3\xa1scara)   AND 00111 (m\xc3\xa1scara)   AND 11000 (m\xc3\xa1scara)   XOR 1001 (m\xc3\xa1scara)_NEWLINE_ = 1011               = 1010               = 00101               = 10000               = 0011_NEWLINE_Enciende el         Apaga el             Deja pasar los 3      Elimina los 3         Invierte los bits_NEWLINE_bit superior        bit inferior         bits inferiores       bits inferiores_NEWLINE_                                                               inferior y superior_NEWLINE_NOT invierte los bits y XOR junto con AND permiten determinar si dos operandos tienen los bits de una determinada posici\xc3\xb3n iguales o diferentes:_NEWLINE_NOT 1011              11010_NEWLINE_  = 0100          XOR 10100_NEWLINE_invierte todos      = 01110  (0 = bit iguales, 1 = bits diferentes)_NEWLINE_los bits          AND 00010  (se filtra el segundo bits, que es el que interesa)_NEWLINE_                    = 00010_NEWLINE_                  Determina si los bits de la segunda posici\xc3\xb3n_NEWLINE_                  de los dos operandos son iguales o diferentes_NEWLINE_                      0 = iguales_NEWLINE_                      1 = diferentes\n_START_SECTION_\nDesplazamientos de bits\n_START_PARAGRAPH_\nLos desplazamientos de bit (bit shifts) son a veces considerados operaciones bit a bit, porque operan en la representaci\xc3\xb3n binaria de un n\xc3\xbamero entero en vez de sobre su valor num\xc3\xa9rico; sin embargo, los desplazamientos de bits no operan en pares de bits correspondientes, y por lo tanto no pueden ser llamados propiamente como "bit a bit" (bit-wise). En estas operaciones los d\xc3\xadgitos (bits) son movidos, o desplazados, hacia la izquierda o hacia la derecha. Los registros en un procesador de computador tienen un ancho fijo, as\xc3\xad que algunos bits \xe2\x80\x9cser\xc3\xa1n desplazados hacia fuera\xe2\x80\x9d ("shifted out"), es decir, "salen" del registro por un extremo, mientras que el mismo n\xc3\xbamero de bits son \xe2\x80\x9cdesplazados hacia adentro\xe2\x80\x9d ("shifted in"), es decir, "entran" por el otro extremo; las diferencias entre los operadores de desplazamiento de bits est\xc3\xa1n en c\xc3\xb3mo \xc3\xa9stos determinan los valores de los bits que entran al registro (desplazamiento hacia adentro) (shifted-in).\n_START_SECTION_\nDesplazamiento l\xc3\xb3gico\n_START_PARAGRAPH_\nHay dos desplazamientos l\xc3\xb3gicos (logical shifts). El desplazamiento l\xc3\xb3gico hacia la izquierda (left shift) y el desplazamiento l\xc3\xb3gico hacia la derecha (right shift). En el desplazamiento l\xc3\xb3gico los bits de un registro son desplazados (movidos) una o m\xc3\xa1s posiciones hacia la derecha o hacia la izquierda. Los bit que salen del registro por un extremo se pierden y en el otro extremo del registro se rellena con un bit cero por cada bit desplazado._NEWLINE_Por ejemplo. Si se tiene en un registro de 8 bits el valor 10110011, y se hace un desplazamiento hacia la izquierda de un bit, todos los bits se mueven una posici\xc3\xb3n hacia la izquierda, el bit de la izquierda se pierde y entra un bit cero de relleno por el lado derecho. En un desplazamiento de un bit hacia la derecha ocurre algo an\xc3\xa1logo, el bit de la derecha se pierde y el de la izquierda se rellena con un cero:_NEWLINE_      10110011              10110011           <-- Bits antes del desplazamiento_NEWLINE_1 <-- 0110011 <-- 0    0 --> 1011001 --> 1     <-- Desplazamiento_NEWLINE_      01100110              01011001           <-- Bits despu\xc3\xa9s del desplazamiento_NEWLINE_  Desplazamiento           Desplazamiento_NEWLINE_hacia la izquierda hacia la derecha_NEWLINE_En determinados procesadores, queda almacenado el \xc3\xbaltimo bit que sali\xc3\xb3 con el desplazamiento del registro. En la serie de los procesadores x86 dicho bit queda almacenado en el flag del acarreo.\n_START_SECTION_\nMoviendo bits\n_START_PARAGRAPH_\nEl desplazamiento l\xc3\xb3gico se usa para mover bits hacia la izquierda o hacia la derecha para colocarlos en la posici\xc3\xb3n adecuada._NEWLINE_Por ejemplo, supongamos que tenemos, en dos registros del tama\xc3\xb1o de un byte, a dos d\xc3\xadgitos hexadecimales (en representaci\xc3\xb3n binaria de 4 bits cada uno), y se quiere empaquetarlos en un solo byte, donde los 4 bits superiores es el hexadecimal m\xc3\xa1s significativo y los 4 bits inferiores es el hexadecimal menos significativo:_NEWLINE_0000 1001  <-- D\xc3\xadgito hexadecimal m\xc3\xa1s significativo   (hexadecimal 9)_NEWLINE_0000 1010  <-- D\xc3\xadgito hexadecimal menos significativo (hexadecimal A)_NEWLINE_Para empaquetarlos en un solo byte, primero hay que desplazar el hexadecimal m\xc3\xa1s significativo 4 posiciones hacia la izquierda. (Esto se hace con el desplazamiento l\xc3\xb3gico hacia la izquierda):_NEWLINE_1001 0000  <-- hexadecimal 9, desplazado 4 bits hacia la izquierda para colocarlo en la posici\xc3\xb3n correcta dentro del byte_NEWLINE_Luego, se hace un OR de los dos valores que contienen los d\xc3\xadgitos hexadecimales para que queden combinados en un solo byte:_NEWLINE_   0000 1010  <-- Hexadecimal menos significativo A_NEWLINE_OR 1001 0000  <-- OR con el hexadecimal m\xc3\xa1s significativo 9, el cual ya est\xc3\xa1 en su posici\xc3\xb3n_NEWLINE_   1001 1010  <-- Byte con los dos hexadecimales empaquetados (hexadecimal 9A)_NEWLINE_Ahora tenemos un byte con el valor de 1001 1010, el cual tiene los dos d\xc3\xadgitos hexadecimales empaquetados.\n_START_SECTION_\nMultiplicaci\xc3\xb3n y divisi\xc3\xb3n por 2n, de enteros sin signo\n_START_PARAGRAPH_\nEn n\xc3\xbameros enteros sin signo, el desplazamiento l\xc3\xb3gico hacia la izquierda equivale a una multiplicaci\xc3\xb3n por 2 y el desplazamiento l\xc3\xb3gico hacia la derecha equivale a una divisi\xc3\xb3n por 2. En la divisi\xc3\xb3n (desplazamiento hacia la derecha), se pierde el bit menos significativo, dando como resultado un truncamiento del resultado (redondeo hacia abajo, hacia menos infinito). As\xc3\xad, 6 / 2 es igual a 3, pero 7 / 2 es igual a 3,5, pero el 0,5 se pierde quedando el resultado en 3._NEWLINE_Los programadores de lenguaje ensamblador usan esta propiedad para hacer multiplicaciones y divisiones r\xc3\xa1pidas, de enteros sin signo, por una potencia de 2, en donde n desplazamientos equivalen a multiplicar o dividir por 2\xe2\x81\xbf. Tambi\xc3\xa9n, si el procesador no tiene operaciones de multiplicaci\xc3\xb3n y divisi\xc3\xb3n de enteros, o si \xc3\xa9stas son muy lentas, se puede multiplicar o dividir usando desplazamientos y sumas para multiplicar y desplazamientos y restas para dividir. Por ejemplo, para multiplicar un entero por 10, se procede como sigue (en el lenguaje ensamblador del x86):_NEWLINE_Se quiere multiplicar el contenido del registro EAX por 10:_NEWLINE_En las instrucciones de abajo, EAX y EBX son registros del procesador, SHL (shift left), desplaza el registro indicado una posici\xc3\xb3n (un bit) hacia la izquierda (que equivale a multiplicar por 2), MOV copia el registro de la derecha sobre el registro de la izquierda, y ADD suma el registro de la derecha al registro de la izquierda._NEWLINE_SHL EAX, 1      ; EAX = EAX * 2     EAX = 2n   ; desplaza a la izquierda el contenido del registro EAX una posici\xc3\xb3n,_NEWLINE_                                               ; (multiplica EAX por 2)MOV EBX, EAX    ; EBX = EAX         EBX = 2n   ; copia el registro EAX en EBX, ahora los dos registros tienen 2nSHL EBX, 1      ; EBX = EBX * 2     EBX = 4n   ; multiplica EBX por 2, obteniendo 4nSHL EBX, 1      ; EBX = EBX * 2     EBX = 8n   ; vuelve a multiplicar EBX por 2, obteniendo 8nADD EAX, EBX    ; EAX = EAX + EBX   EAX = 2n + 8n = 10n  ; suma EBX (8n) a EAX (2n),_NEWLINE_                                                         ; (ahora EAX tiene el valor original multiplicado por 10)\n_START_SECTION_\nDesplazamiento aritm\xc3\xa9tico\n_START_PARAGRAPH_\nLos desplazamientos aritm\xc3\xa9ticos son similares a los desplazamientos l\xc3\xb3gicos, solo que los aritm\xc3\xa9ticos est\xc3\xa1n pensados para trabajar sobre n\xc3\xbameros enteros con signo en representaci\xc3\xb3n de complemento a dos en lugar de enteros sin signo. Los desplazamientos aritm\xc3\xa9ticos permiten la multiplicaci\xc3\xb3n y la divisi\xc3\xb3n por dos, de n\xc3\xbameros enteros con signo, por una potencia de dos. Desplazar n bits hacia la izquierda o a la derecha equivale a multiplicar o dividir por 2\xe2\x81\xbf, (asumiendo que el valor no hace desbordamiento (overflow o underflow))._NEWLINE_El desplazamiento aritm\xc3\xa9tico hacia la izquierda es exactamente igual al desplazamiento l\xc3\xb3gico hacia la izquierda. De hecho son dos nombres diferentes para exactamente la misma operaci\xc3\xb3n. Al desplazar los bits una posici\xc3\xb3n hacia la izquierda es equivalente a una multiplicaci\xc3\xb3n por 2 independientemente de si es un n\xc3\xbamero entero con signo o sin signo. En los procesadores x86, el ensamblador tiene dos pnem\xc3\xb3nicos para el desplazamiento l\xc3\xb3gico y el aritm\xc3\xa9tico hacia la izquierda, pero cuando el programa es ensamblado, solo hay un opcode para ambos en la instrucci\xc3\xb3n en lenguaje de m\xc3\xa1quina._NEWLINE_El desplazamiento aritm\xc3\xa9tico hacia la derecha es diferente al desplazamiento l\xc3\xb3gico hacia la derecha. En los enteros sin signo, para dividir por 2, se debe usar el desplazamiento l\xc3\xb3gico, el cual siempre agrega un 0 en el extremo izquierdo por cada desplazamiento de un bit hacia la derecha. En cambio, en los enteros con signo, se debe usar el desplazamiento aritm\xc3\xa9tico hacia la derecha, el cual copia el bit del signo (el bit m\xc3\xa1s significativo (MSB)) en el espacio vac\xc3\xado que queda en el extremo izquierdo cada vez que se hace un desplazamiento de un bit hacia la derecha. De esta manera, se divide efectivamente por 2 al entero con signo._NEWLINE_Si el entero con signo es positivo, (con el bit del signo igual a 0), se insertar\xc3\xa1 el bit 0 del signo en el extremo izquierdo al desplazar un bit hacia la derecha (igual que el desplazamiento l\xc3\xb3gico hacia la derecha), pero si es un entero negativo, (con el bit del signo igual a 1), se insertar\xc3\xa1 el bit 1 del bit del signo en el extremo izquierdo. De esta manera, el signo del n\xc3\xbamero se preserva con la divisi\xc3\xb3n por 2 y el n\xc3\xbamero resultante tiene sentido. Si se insertara un 0 a la izquierda a un n\xc3\xbamero negativo (como lo har\xc3\xada el desplazamiento l\xc3\xb3gico hacia la derecha), en primer lugar, este n\xc3\xbamero negativo cambiar\xc3\xada de signo a positivo, y en segundo lugar, la interpretaci\xc3\xb3n de los bits restantes no tendr\xc3\xadan sentido._NEWLINE_Estos ejemplos utilizan un registro de 8 bits:_NEWLINE_  00010111 (Decimal 23) (Desplazamiento aritm\xc3\xa9tico hacia la izquierda de un n\xc3\xbamero positivo)_NEWLINE_= 00101110 (Decimal 46) (El bit de la izquierda se pierde y un bit 0 se a\xc3\xb1ade a la derecha)_NEWLINE__NEWLINE_  11010111 (Decimal -41) (Desplazamiento aritm\xc3\xa9tico hacia la izquierda de un n\xc3\xbamero negativo)_NEWLINE_= 10101110 (Decimal -82) (El bit de la izquierda se pierde y un bit 0 se a\xc3\xb1ade a la derecha)_NEWLINE__NEWLINE_  00010111 (Decimal 23) (Desplazamiento aritm\xc3\xa9tico hacia la derecha de un n\xc3\xbamero positivo)_NEWLINE_= 00001011 (Decimal 11) (El bit de la derecha se pierde y el bit del signo anterior se conserva en el resultado)_NEWLINE__NEWLINE_  11010111 (Decimal -41) (Desplazamiento aritm\xc3\xa9tico hacia la derecha de un n\xc3\xbamero negativo)_NEWLINE_= 11101011 (Decimal -21) (El bit de la derecha se pierde y el bit del signo anterior se conserva en el resultado)_NEWLINE_Si el n\xc3\xbamero binario es tratado como complemento a 1, entonces la misma operaci\xc3\xb3n de desplazamiento hacia la derecha resulta en una divisi\xc3\xb3n por 2\xe2\x81\xbf redondeando hacia el cero.'