Bitwise operations: Difference between revisions

 

=={{header|8051 Assembly}}==

Integer one is assumed to be a, integer two assumed to be b.

The end result of each operation resides in a.

The shift and rotate operations should likely push psw and pop psw because they affect the carry flag.

anl a, b

 

loop:

rr a

 

=={{header|ACL2}}==

Unlisted operations are not available

(list (logand a b)

(logior a b)

(lognot a)

(ash a b)

 

=={{header|ActionScript}}==

ActionScript does not support bitwise rotations.

{

trace("And: ", a & b);

trace("Right Shift(Arithmetic): ", a >> b);

trace("Right Shift(Logical): ", a >>> b);

=={{header|Ada}}==

The following program performs all required operations and prints the resulting values in base 2 for easy checking of the bit values.

 

 

 

=={{header|Aikido}}==

{{trans|Javascript}}

 

There is no rotate support built in to Aikido.

println("a AND b: " + (a & b))

println("a OR b: "+ (a | b))

println("a >> b: " + (a >> b)) // arithmetic right shift

println("a >>> b: " + (a >>> b)) // logical right shift

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Standard - no extensions to language used}}

* 2r00000000000000000000000010101010, 4r0000000000002222, 8r00000000252, 16r000000aa

* and as an array of BOOL: FFFFFFFFFFFFFFFFFFFFFFFFTFTFTFTF

 

PRIO SLC = 8, SRC = 8; # SLC and SRC are not built in, define and overload them here #

bitwise(16rff,16raa,5)

END CO

Output:

<pre> bits shorths: +1 1 plus the number of extra SHORT BITS types

</pre>

Note that an INT can be widened into BITS, and BITS can be widened into an array of BOOL. eg:

INT i := 170;

BITS j := BIN i;

i := ABS j;

 

Output:

<pre>

+85, 8r0125, FTFTFTFT

</pre>

 

=={{header|AutoHotkey}}==

bitwise(a, b)

{

MsgBox % "a << b: " . a << b ; left shift

MsgBox % "a >> b: " . a >> b ; arithmetic right shift

 

=={{header|AWK}}==

Standard awk does not have bitwise operators. Gawk has built-in functions for many bitwise operations. No rotation of bits.

{{works with|gawk}}

 

n = 11

p = 1

print n " >> " p " = " rshift(n, p) # right shift

printf "not %d = 0x%x\n", n, compl(n) # bitwise complement

 

[[OpenBSD]] <code>/usr/bin/awk</code> (a variant of [[nawk]]) has these same functions, with a few differences. Gawk uses 53-bit unsigned integers, but OpenBSD awk uses 32-bit signed integers. Therefore Gawk prints <code>not 11 = 0x1ffffffffffff4</code>, but OpenBSD awk prints <code>not 11 = 0xfffffff4</code>.

=={{header|Axe}}==

r₁→A

r₂→B

Disp "NOT:",not(A)ʳ▶Dec,i

.No language support for shifts or rotations

 

Note that the symbols for AND, OR, and XOR are the stat plot marks near the bottom of the Catalog.

=={{header|Babel}}==

 

 

 

 

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

QuickBasic does not have shift or rotate operations defined. Here are the logical operations:

PRINT a AND b

PRINT a OR b

PRINT a XOR b

PRINT NOT a

 

{{works with|FreeBASIC}}

FreeBASIC does not have rotate operators. Shift Right operator performs arithmetic shift if the left value is signed number and logical shift if the left value is unsigned number.

DIM u AS UInteger

 

u = a

PRINT "a SHR b (logical) = "; u SHR b

 

=={{header|BASIC256}}==

a = 0b00010001

b = 0b11110000

print a

print a | b # bitwise or on two integer values

=={{header|Batch File}}==

The SET command with the /A option supports arithmetic and bit operations on signed 8 byte integers.

 

The following script (bitops.bat) not only demonstrates the basic bit operations, it also uses bit operations to convert each integral value into a string of 32 binary digits.

@echo off

setlocal

)

exit /b

 

Sample output

11111101000000000000000000000001

</pre>

=={{header|BBC BASIC}}==

number2% = 8

PRINT ~ number1% >> number2% : REM right shift (arithmetic)

PRINT ~ (number1% << number2%) OR (number1% >>> (32-number2%)) : REM left rotate

 

=={{header|C}}==

{

printf("a and b: %d\n", a & b);

/* there are no rotation operators in C */

return 0;

 

To rotate an integer, you can combine a left shift and a right shift:

unsigned int rotr(unsigned int x, unsigned int s)

{

return (x >> s) | (x << 32 - s);

movl 4(%esp), %eax ; arg1: x

movl 8(%esp), %ecx ; arg2: s

rorl %cl, %eax ; right rotate x by s

=={{header|C sharp|C#}}==

{

Console.WriteLine("a and b is {0}", a & b);

// the operator performs a logical shift right

// there are no rotation operators in C#

 

=={{header|Clojure}}==

(bit-or x y)

(bit-xor x y)

(bit-shift-left x n)

(bit-shift-right x n)

=={{header|COBOL}}==

PROGRAM-ID. bitwise-ops.

 

01 a PIC 1(32) USAGE BIT.

01 b PIC 1(32) USAGE BIT.

01 result PIC 1(32) USAGE BIT.

LINKAGE SECTION.

01 a-int USAGE BINARY-LONG.

DISPLAY "a exclusive-or b is " result-disp

 

 

 

{{works with|Visual COBOL}}

PROGRAM-ID. mf-bitwise-ops.

DATA DIVISION.

LOCAL-STORAGE SECTION.

01 result USAGE BINARY-LONG.

78 arg-len VALUE LENGTH OF result.

LINKAGE SECTION.

01 a USAGE BINARY-LONG.

01 b USAGE BINARY-LONG.

PROCEDURE DIVISION USING a, b.

main-line.

CALL "CBL_AND" USING a, result, VALUE arg-len

DISPLAY "a and b is " result

MOVE b TO result

CALL "CBL_OR" USING a, result, VALUE arg-len

DISPLAY "a or b is " result

MOVE a TO result

CALL "CBL_NOT" USING result, VALUE arg-len

DISPLAY "Not a is " result

MOVE b TO result

CALL "CBL_XOR" USING a, result, VALUE arg-len

DISPLAY "a exclusive-or b is " result

MOVE b TO result

CALL "CBL_EQ" USING a, result, VALUE arg-len

DISPLAY "Logical equivalence of a and b is " result

MOVE b TO result

CALL "CBL_IMP" USING a, result, VALUE arg-len

DISPLAY "Logical implication of a and b is " result

 

 

=={{header|CoffeeScript}}==

CoffeeScript provides sugar for some JavaScript operators, but the bitwise operators are taken directly from JS. See more here: http://coffeescript.org/#operators

 

f = (a, b) ->

p "and", a & b

 

f(10,2)

 

output

> coffee foo.coffee

and 2

<< 40

>> 2

=={{header|Common Lisp}}==

(print (logand a b)) ; AND

(print (logior a b)) ; OR ("ior" = inclusive or)

(print (ash a (- b))) ; arithmetic right shift (negative 2nd arg)

; no logical shift

 

Left and right logical shift may be implemented by the following functions:

 

(defun shl (x width bits)

"Compute bitwise left shift of x by 'bits' bits, represented on 'width' bits"

 

(defun shr (x width bits)

(logand (ash x (- bits))

(1- (ash 1 width))))

 

Left and right rotation may be implemented by the following functions:

 

(defun rotl (x width bits)

"Compute bitwise left rotation of x by 'bits' bits, represented on 'width' bits"

 

(defun rotr (x width bits)

(logior (logand (ash x (- (mod bits width)))

(1- (ash 1 width)))

(logand (ash x (- width (mod bits width)))

(1- (ash 1 width)))))

=={{header|D}}==

return (x >>> shift) | (x << (T.sizeof * 8 - shift));

}

 

testBit(a, b);

{{out}}

<pre>Input: a = 255, b = 2

 

Compilers are usually able to optimize the code pattern of the rot function to one CPU instruction plus loads. The DMD compiler too performs such optimization.

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

// there are no built-in rotation operators in Delphi

Readln;

=={{header|DWScript}}==

PrintLn('2 or 3 = '+IntToStr(2 or 3));

PrintLn('2 xor 3 = '+IntToStr(2 xor 3));

PrintLn('not 2 = '+IntToStr(not 2));

PrintLn('2 shl 3 = '+IntToStr(2 shl 3));

=={{header|E}}==

E provides arbitrary-size integers, so there is no distinct arithmetic and logical shift right. E does not provide bit rotate operations.

 

println(`Bitwise operations:

a AND b: ${a & b}

a right shift b: ${a >> b}

`)

 

=={{header|ECL}}==

BitwiseOperations(INTEGER A, INTEGER B) := FUNCTION

BitAND := A & B;

*/

 

=={{header|Elena}}==

 

{

}

 

{{out}}

<pre>

 

=={{header|Elixir}}==

use Bitwise

end

 

 

{{out}}

255 >>> 2 = 63

</pre>

=={{header|Erlang}}==

All these operations are built-in functions except right arithmetic shift, left rotate, and right rotate.

 

-module(bitwise_operations).

 

io:format("~p bsl ~p = ~p\n",[A,B,A bsl B]),

io:format("~p bsr ~p = ~p\n",[A,B,A bsr B]).

 

outputs:

255 band 170 = 170

255 bor 170 = 255

255 bsl 170 = 381627307539845370001346183518875822092557105621893120

255 bsr 170 = 0

=={{header|F_Sharp|F#}}==

printfn "a and b: %d" (a &&& b)

printfn "a or b: %d" (a ||| b)

printfn "a shr b: %d" (a >>> b) // arithmetic shift

printfn "a shr b: %d" ((uint32 a) >>> b) // logical shift

=={{header|Factor}}==

{

[ bitand "a AND b: " write . ]

[ abs shift "a asl b: " write . ]

[ neg shift "a asr b: " write . ]

 

outputs:

b=5

a AND b: 5

NOT a: -256

a asl b: 8160

Currently rotation and logical shifts are not implemented.

=={{header|FALSE}}==

Only AND, OR, and NOT are available.

\$@$@$@$@\ { 3 copies }

"a & b = "&."

a | b = "|."

~a = "%~."

=={{header|Forth}}==

: bitwise ( a b -- )

cr ." a = " over . ." b = " dup .

cr ." a shr b = " 2dup rshift .

cr ." a ashr b = " 2dup arshift .

Rotation is not standard, but may be provided in particular Forth implementations, or as an assembly instruction in CODE words.

=={{header|Fortran}}==

In ISO Fortran 90 and later the following BIT INTRINSIC functions are defined:

logical :: a

! returns them as the rightmost bits of an otherwise

! zero-filled integer. For non-negative K this is

The following INTRINSIC ELEMENTAL SUBROUTINE is also defined:

 

program bits_rosetta

implicit none

write(*,fmt2) 'or : ', a,' | ',b,' = ',ior(a, b),ior(a, b)

write(*,fmt2) 'xor : ', a,' ^ ',b,' = ',ieor(a, b),ieor(a, b)

write(*,fmt2) 'not : ', a,' ~ ',b,' = ',not(a),not(a)

write(*,fmt2) 'rot : ', a,' r ',b,' = ',ishftc(a,-abs(b)),ishftc(a,-abs(b))

 

end program bits_rosetta

Output

Input a= 14 b= 3

AND : 00000000000000000000000000001110 & 00000000000000000000000000000011 = 00000000000000000000000000000010 2

NOT : 00000000000000000000000000001110 ~ 00000000000000000000000000000011 = 11111111111111111111111111110001 -15

ROT : 00000000000000000000000000001110 ~ 00000000000000000000000000000011 = 11000000000000000000000000000001 -1073741823

 

=={{header|Go}}==

 

import "fmt"

 

 

 

 

}

 

func main() {

Output:

b: 0000000000000110

and: 0000000000000100

shl: 1000110100000000

shr: 0000001111111000

ras: 1111111111111000

rol: 1000110100111111

=={{header|Groovy}}==

println """

a & b = ${a} & ${b} = ${a & b}

a >>> b = ${a} >>> ${b} = ${a >>> b} logical (zero-filling) shift

"""

 

Program:

 

Output:

a >> b = -15 >> 3 = -2 arithmetic (sign-preserving) shift

a >>> b = -15 >>> 3 = 536870910 logical (zero-filling) shift</pre>

 

=={{header|Haskell}}==

 

The operations in ''Data.Bits'' work on ''Int'', ''Integer'', and any of the sized integer and word types.

bitwise :: Int -> Int -> IO ()

 

If you were shifting Words (unsigned integers) instead of Ints, then the shift would be automatically logical shifts:

import Data.Word

=={{header|HicEst}}==

There is no rotate and no shift support built in to HicEst

i = IOR( k, j)

i = IEOR(k, j)

=={{header|Icon}} and {{header|Unicon}}==

bitdemo(255,2)

bitdemo(-15,3)

procedure demowrite(vs,v)

return write(vs, ": ", v, " = ", int2bit(v),"b")

 

Icon/Unicon implements bitwise operations on integers. Because integers can be transparently large integers operations that require fixed sizes don't make sense and aren't defined. These include rotation and logical shifting (shift is arithmetic) . Please note also that 'not' is a reserved word and the negation function is 'icom'

i shift 3: -120 = -1111000b

i shift -3: -2 = -10b</pre>

=={{header|Inform 6}}==

Inform 6 has no xor or rotate operators. It also has no shift operators, although the Z-machine, its usual target architecture, does. These can be accessed with inline assembly, which is done here.

 

print "a and b: ", a & b, "^";

print "a or b: ", a | b, "^";

print "a >> b (logical): ", temp, "^";

];

=={{header|J}}==

 

Here are the "[http://www.jsoftware.com/help/dictionary/dbdotn.htm bitwise operators]":

 

bOR=: 23 b. NB. 16+#.0 1 1 1

bXOR=: 22 b. NB. 16+#.0 1 1 0

bRAshift=: 34 b.~ -

bLrot=: 32 b.~

 

And here is a routine which takes a list of bitwise operators and two numbers and displays a table of results from combining those two numbers with each of the operators:

 

:

smoutput (((":x),"1' ',.(>u),.' '),"1":y),"1' => ',"1'.X'{~#:x u`:0 y

 

And here they are in action:

 

254 bAND 3 => ............................X.

254 bOR 3 => ......................XXXXXXXX

254 bRAshift 3 => .........................XXXXX

254 bLrot 3 => ...................XXXXXXX....

 

Further test

bXOR/ 3333 5555 7777 9999

8664

=={{header|Java}}==

System.out.println("a AND b: " + (a & b));

System.out.println("a OR b: "+ (a | b));

System.out.println("a rol b: " + Integer.rotateLeft(a, b)); //rotate left, Java 1.5+

System.out.println("a ror b: " + Integer.rotateRight(a, b)); //rotate right, Java 1.5+

All of the operators may be combined with the <tt>=</tt> operator to save space. For example, the following lines each do the same thing:

a = a << 3;

a *= 8; //2 * 2 * 2 = 8

=={{header|JavaScript}}==

There are no integers in Javascript, but there are still bitwise operators. They will convert their number operands into integers before performing they task. In other languages, these operators are very close to the hardware and very fast. In JavaScript, they are very far from the hardware and very slow and rarely used.

 

alert("a AND b: " + (a & b));

alert("a OR b: "+ (a | b));

alert("a >> b: " + (a >> b)); // arithmetic right shift

alert("a >>> b: " + (a >>> b)); // logical right shift

 

 

=={{header|LFE}}==

 

All these operations are built-in functions except right arithmetic shift, left rotate, and right rotate.

 

 

(defun bitwise

((a b 'binary)

 

Example usage:

> (bitwise 255 170)

170

ok

>

=={{header|Liberty BASIC}}==

Written as functions.

' bitwise operations on byte-sized variables

 

dec2Bin$ =right$( "00000000" +dec2Bin$, 8)

end function

=={{header|LiveCode}}==

put " or:" && (255 bitor 2) & comma after bitops

put " xor:" && (255 bitxor 2) & comma after bitops

 

-- Ouput

LiveCode does not provide built-in bit-shift operations.

=={{header|LLVM}}==

;e means little endian

;p: { pointer size : pointer abi : preferred alignment for pointers }

 

;Declare external fuctions

=={{header|Logo}}==

{{works with|UCB Logo}}

(print [a and b:] BitAnd :a :b)

(print [a or b:] BitOr :a :b)

(print [-a ashift -b:] AShift minus :a minus :b)

end

The output of this program is:

a or b: 255

a xor b: 250

a lshift b: 8160

a lshift -b: 7

=={{header|Lua}}==

 

LuaBitOp implements bitwise functionality for Lua:

 

 

local vb = {

assert(bit.bxor(1,2) == 3)

assert(bit.bor(1,2,4,8,16,32,64,128) == 255)

 

The ''RiscLua'' dialect, for [http://lua.riscos.org.uk/ '''RISC OS'''], has

& (and), | (or), ^^ (xor), << (logical shift left), >> (logical shift right)

and a unary operation ~ (negate).

=={{header|Mathematica}}/ {{header|Wolfram Language}}==

Most functions are built-in or can be made really easily:

BitAnd[integer1, integer2]

BitXor[integer1, integer2]

 

(*right arithmetic shift*)

The function BitShiftLeft, BitShiftRight, RotateRight, RotateLeft all take a second argument, which is the displacement, by default it is set to 1. BitAnd, BitXor and BitOr can handle more than 2 arguments:

gives back:

=={{header|MATLAB}} / {{header|Octave}}==

Newer versions of MATLAB have even more bitwise operations than those demonstrated here. A complete list of bitwise operations for the newest version of MATLAB can be found at [http://www.mathworks.com/help/toolbox/fixedpoint/ref/f20333.html#bp7caxc-42 MathWorks]

 

 

disp(sprintf('%d and %d = %d', [a b bitand(a,b)]));

disp(sprintf('%d >> %d = %d', [a b bitshift(a,-b)]));

 

 

Output:

255 and 2 = 2

255 or 2 = 255

255 xor 2 = 253

255 << 2 = 1020

=={{header|Maxima}}==

 

a: 3661$

 

logand(a, -a - 1);

=={{header|MAXScript}}==

(

format "a and b: %\n" (bit.and a b)

)

 

 

MAXScript doesn't have arithmetic shift or rotate operations.

=={{header|ML/I}}==

ML/I only supports bitwise AND and OR operations. These are available from version CKD onwards.

 

"" Bitwise operations

"" assumes macros on input stream 1, terminal on stream 2

MCSET S1=1

*MCSET S10=2

=={{header|Modula-3}}==

 

 

IMPORT IO, Fmt, Word;

BEGIN

Bitwise(255, 5);

 

Output:

c RightRotate b: f8000007

</pre>