Bitwise operations: Difference between revisions

If any operation is not available in your language, note it.

<br><br>

=={{header|11l}}==

{{trans|Kotlin}}

V y = 2

print(‘x = ’x)

x ROR y = -2147483646

</pre>

=={{header|360 Assembly}}==

BITWISE CSECT

USING BITWISE,R13

Bitwise operations are done using the accumulator and an immediate constant (prefixed with #) or a value at a specified memory location (no #.)

STA temp ;temp equals 5 for the following</syntaxhighlight>

;AND

AND temp</syntaxhighlight>

;OR

ORA temp</syntaxhighlight>

;XOR

EOR temp</syntaxhighlight>

;NOT

EOR #255</syntaxhighlight>

The 6502 doesn't have arithmetic shift right, but it can be replicated, provided the negative flag is set according to the value in the accumulator.

CLC ;clear the carry. That way, ROR will not accidentally shift a 1 into the top bit of a positive number

BPL SKIP

The 6502 can only rotate a value by one, not an arbitrary number. A looping routine is needed for rotates larger than 1.

Also, the 6502's <code>ROL</code> and <code>ROR</code> rotate instructions both rotate through the carry, unlike the instructions on other architectures with the same name. (68000, x86, and ARM all have a "ROR" command but it doesn't rotate through the carry on those CPUs.)

ROL ;if the carry was set prior to the ROL, A = 3. If the carry was clear, A = 2.</syntaxhighlight>

ROR ;if the carry was set prior to the ROR, A = 0x80. If clear, A = 0.</syntaxhighlight>

=={{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

rr a

djnz b, loop</syntaxhighlight>

=={{header|8086 Assembly}}==

;AND

MOV BX,0444h

AND AX,BX</syntaxhighlight>

;OR

MOV BX,0444h

OR AX,BX</syntaxhighlight>

;XOR

MOV BX,0444h

XOR AX,BX</syntaxhighlight>

;NOT

NOT AX</syntaxhighlight>

;Left Shift

MOV CL,02h

SHL AX,CL</syntaxhighlight>

;Right Shift

MOV CL,02h

SHR AX,CL</syntaxhighlight>

;Arithmetic Right Shift

MOV CL,02h

SAR AX,CL</syntaxhighlight>

;Left Rotate

MOV CL,02h

ROL AX,CL</syntaxhighlight>

;Right Rotate

MOV CL,02h

ROR AX,CL</syntaxhighlight>

;Left Rotate Through Carry

MOV CL,02h

RCL AX,CL</syntaxhighlight>

;Right Rotate Through Carry

MOV CL,02h

RCR AX,CL</syntaxhighlight>

=={{header|ABAP}}==

This works in ABAP 7.40 and above. The missing arithmetic shift operations have been implemented with arithmetic, whereas the logical shift and the rotate operations have been implemented using the built in string functions shift_left and shift_right.

report z_bitwise_operations.

a rotr b -> C000003F, 11000000000000000000000000111111, -1073741761

</pre>

=={{header|ACL2}}==

Unlisted operations are not available

(list (logand a b)

(logior a b)

(ash a b)

(ash a (- b))))</syntaxhighlight>

=={{header|Action!}}==

RETURN (a!$FF)

127 SHL 2 = 252

</pre>

=={{header|ActionScript}}==

ActionScript does not support bitwise rotations.

{

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

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

}</syntaxhighlight>

=={{header|Ada}}==

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

use Ada.Text_IO, Interfaces;

Put_Line (Unsigned_8'Image (Rotate_Right (X, N)));

end Bitwise;</syntaxhighlight>

=={{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)) // logical right shift

}</syntaxhighlight>

=={{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 #

</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;

+85, 8r0125, FTFTFTFT

</pre>

=={{header|ALGOL W}}==

% Algol W does not have xor, arithmetic right shift, left rotate or right rotate %

procedure bitOperations ( integer value n1, n2 ) ;

write( n1, " shr ", n2, " = ", number( b1 shr n2 ), " ( right-shift )" )

end bitOPerations ;</syntaxhighlight>

=={{header|AppleScript}}==

Applescript has no bitwise operators. It's probably not the right tool to reach for if you need to work with bits.

use framework "Foundation"

use scripting additions

'''Second option''' – writing our own bitwise functions for Applescript:

use framework "Foundation"

use scripting additions

A '''third option''' is the mathematical one, although it still involves looping through the hypothetical bits where two numbers are involved, unless I've missed a trick. The handlers below all assume positive number inputs (except for ''arithmeticRightShift()'') and attempt to return results of class integer. The "hi bits" of numbers which don't fit the specified register sizes are discarded.

set out to 0

-- Multiplying equivalent bit values by each other gives 1 where they're both 1 and 0 otherwise.

rightRotate(92, 7, 8) --> 184

rightRotate(92, 7, 16) --> 47104</syntaxhighlight>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

</syntaxhighlight>

=={{header|Arturo}}==

b: 2

255 SHL 2 = 1020

255 SHR 2 = 63 </pre>

=={{header|AutoHotkey}}==

bitwise(a, b)

{

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

}</syntaxhighlight>

=={{header|AutoIt}}==

No arithmetic shift.

Func bitwise($a, $b)

MsgBox(1, '', _

255 ROL 5: 8160

255 ROR 5: 63495</pre>

=={{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

[[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

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

=={{header|Babel}}==

In Babel, we prefix the logic operators with a 'c' to denote that they are C-style operations, that is, they are word-width operations, not arbitrary size operations. The following program combines the numbers 5 and 9 using the various bitwise operators and then displays the results.

{{Out}}

The cnot operator works on just one operand:

{{Out}}

<pre>[val 0xfffffff6 ]</pre>

=={{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

{{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

Commodore BASIC V2.0 does not have '''XOR''', '''left shift''', '''right shift''', '''right arithmetic shift''', '''left rotate''', and '''right rotate''' operators. In this implementation the '''XOR''' operation is done with an equivalent formula.

20 INPUT "B="; B

30 PRINT "A AND B =" A AND B :rem AND

==={{header|IS-BASIC}}===

110 PRINT A;"and";B;"=";A AND B

120 PRINT A;"band";B;"=";A BAND B

The disassembly of the Z80 code would be:

3a 83 40 ld a, (4083)

47 ld b, a

Finally, observe that the first line reserves 15 bytes for our machine code routine by hiding them in a comment.

20 INPUT A

30 INPUT B

Tiny BASIC has only one data type- the signed 16-bit integer- and no bitwise operations. This code emulates bitwise operations on unsigned 15-bit integers. Since the logic gates AND, NOR, and NXOR are characterised by having exactly two, exactly zero, and exactly one on bit in their inputs, their code is identical except for having a different number of target on bits (line 500 onward). The OR and XOR gates are just NOT NOR and NOT NXOR. The shift and rotate operations are simple divisions and mutiplications by 2, with care taken to avoid overflow, and a carry flag where applicable.

REM VARIABLES

REM A = first number

GOTO 500

</syntaxhighlight>

=={{header|BASIC256}}==

a = 0b00010001

b = 0b11110000

print a | b # bitwise or on two integer values

print a & b # bitwise or on two integer values</syntaxhighlight>

=={{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

11111101000000000000000000000001

</pre>

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

number2% = 8

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

PRINT ~ (number1% >>> number2%) OR (number1% << (32-number2%)) : REM right rotate</syntaxhighlight>

=={{header|beeswax}}==

###>N{` AND `~{~` = `&{Nz1~3J

UXe#

Example:

julia> beeswax("Bitops.bswx",0,0.0,Int(20000))

i9223653511831486512

Arithmetic shift right is not originally implemented in beeswax because it does not make sense for unsigned integers, but for negative numbers, it can be realized easily with

as demonstrated above.

In beeswax, rotate left (ROL) and rotate right (ROT) operators are implemented using modulo 64, so rotations by more than 63 bits wrap around:

A ROR B = A>>>(B%64)+A<<(64-B%64)</syntaxhighlight>

=={{header|Befunge}}==

1 2 3 4 5 6>61g-:| 8 9

>&&\481p >88*61p371p >:61g\`!:68*+71g81gp| 7 >61g2/61p71g1+71pv

1 22 23 106 42 10

</pre>

=={{header|C}}==

{

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

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

ret</syntaxhighlight>

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

{

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

// there are no rotation operators in C#

}</syntaxhighlight>

=={{header|C++}}==

{{trans|C}}

void bitwise(int a, int b)

}</syntaxhighlight>

=={{header|Clojure}}==

(bit-or x y)

(bit-xor x y)

(bit-shift-right x n)

;;There is no built-in for rotation.</syntaxhighlight>

=={{header|COBOL}}==

Results are displayed in decimal.

PROGRAM-ID. bitwise-ops.

{{works with|Visual COBOL}}

PROGRAM-ID. mf-bitwise-ops.

GOBACK

.</syntaxhighlight>

=={{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

output

> coffee foo.coffee

and 2

>> 2

</syntaxhighlight>

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

(print (logand a b)) ; AND

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

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"

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"

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

</syntaxhighlight>

=={{header|D}}==

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

}

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}

Readln;

end.</syntaxhighlight>

=={{header|DWScript}}==

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

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

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

PrintLn('2 shr 3 = '+IntToStr(2 shr 3));</syntaxhighlight>

=={{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}

`)

}</syntaxhighlight>

=={{header|ECL}}==

BitwiseOperations(INTEGER A, INTEGER B) := FUNCTION

BitAND := A & B;

*/

</syntaxhighlight>

=={{header|Elena}}==

ELENA 4.x :

extension testOp

255 shl 2 = 1020

</pre>

=={{header|Elixir}}==

use Bitwise

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).

outputs:

255 band 170 = 170

255 bor 170 = 255

255 bsr 170 = 0

</syntaxhighlight>

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

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

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

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

// No rotation operators.</syntaxhighlight>

=={{header|Factor}}==

{

[ bitand "a AND b: " write . ]

outputs:

b=5

a AND b: 5

a asr b: 7</syntaxhighlight>

Currently rotation and logical shifts are not implemented.

=={{header|FALSE}}==

Only AND, OR, and NOT are available.

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

"a & b = "&."

~a = "%~."

"</syntaxhighlight>

=={{header|Forth}}==

: bitwise ( a b -- )

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

2drop ;</syntaxhighlight>

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

! arithmetically equivalent to: MOD((K / 2**7), 2**8)</syntaxhighlight>

The following INTRINSIC ELEMENTAL SUBROUTINE is also defined:

program bits_rosetta

implicit none

</syntaxhighlight>

Output

Input a= 14 b= 3

AND : 00000000000000000000000000001110 & 00000000000000000000000000000011 = 00000000000000000000000000000010 2

ROT : 00000000000000000000000000001110 ~ 00000000000000000000000000000011 = 11000000000000000000000000000001 -1073741823

</syntaxhighlight>

=={{header|Free Pascal}}==

{$mode objfpc}

var

Readln;

end.</syntaxhighlight>

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64 (Note the (U)Integer type is 64 bits)

x ROR y = 4611686018427387902

</pre>

=={{header|FutureBasic}}==

FB does not have a bitwise symbol for not, but rather uses the "not" expression. It does not support predefined bitwise symbols for rotate left and rotate right, but functions in this demo provide that capability.

def fn rotl( b as long, n as long ) as long = ( ( 2^n * b) mod 256) or (b > 127)

Rotate right : fn rotr( a, b ) = 11000000000000000000000000111111 : -1073741761

</pre>

=={{header|Go}}==

import "fmt"

rol: 1000110100111111

ror: 1101001111111000</pre>

=={{header|Groovy}}==

println """

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

Program:

Output:

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

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

=={{header|Harbour}}==

Harbour language has a set of core functions, which are fully optimized

at compile time, to perform bitwise operations.

PROCEDURE Main(...)

local n1 := 42, n2 := 2

Rotate left --> 168

Rotate right --> -2147483638

=={{header|Haskell}}==

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

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

print $ shiftL (-1 :: Word) 1

print $ shiftR (-1 :: Word) 1

=={{header|HicEst}}==

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

i = IOR( k, j)

i = IEOR(k, j)

i = NOT( k )</syntaxhighlight>

=={{header|HPPPL}}==

BEGIN

PRINT(BITAND(a, b));

// HPPPL has no builtin rotates or arithmetic right shift.

END;</syntaxhighlight>

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

bitdemo(255,2)

bitdemo(-15,3)

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, "^";

];

</syntaxhighlight>

=={{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

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

Further test

bXOR/ 3333 5555 7777 9999

8664

</syntaxhighlight>

=={{header|Java}}==

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

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

}</syntaxhighlight>

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

a = a * 8;</syntaxhighlight>

=={{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)); // logical right shift

}</syntaxhighlight>

=={{header|Julia}}==

@show 1 & 2 # AND

@show 1 | 2 # OR

rol(A,5) = Bool[true,true,false,false,true]

</pre>

=={{header|Kotlin}}==

we wrap Java's 'rotate' methods as infix functions */

infix fun Int.rol(distance: Int): Int = Integer.rotateLeft(this, distance)

x ROR y = -2147483646

</pre>

=={{header|LFE}}==

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

(lists:map

(lambda (x) (io:format "~p~n" `(,x)))

Example usage:

> (bitwise 255 170)

170

>

</syntaxhighlight>

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

Written as functions.

' bitwise operations on byte-sized variables

end function

</syntaxhighlight>

=={{header|Lingo}}==

Lingo has built-in functions for bitwise AND, OR, XOR and NOT:

put bitOR(2,7)

put bitXOR(2,7)

put bitNOT(7)</syntaxhighlight>

Bit shifting and rotating has to be implemented by custom functions.

=={{header|LiveCode}}==

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

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

and: 2, or: 255, xor: 253, not: 4294967040</syntaxhighlight>

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

declare i32 @printf(i8* nocapture, ...) nounwind</syntaxhighlight>

=={{header|Logo}}==

{{works with|UCB Logo}}

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

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

bitwise 255 5</syntaxhighlight>

The output of this program is:

a or b: 255

a xor b: 250

a lshift -b: 7

-a ashift -b: -8</syntaxhighlight>

=={{header|LSE64}}==

{{incorrect|LSE64|No reason given.}}

2dup : over over

\ a \ 7 bitwise # hex literals</syntaxhighlight>

=={{header|Lua}}==

LuaBitOp implements bitwise functionality for Lua:

local vb = {

==={{header|Lua 5.3+}}===

As of Lua 5.3 most of the required operations are built-in, and those still missing could be derived from them:

b = 0x4

print(string.format("%8X and %8X = %16X", a, b, a&b))

AA55AA55 rol 4 = A55AA55A

AA55AA55 ror 4 = 5AA55AA5</pre>

=={{header|Maple}}==

with(Bits):

bit:=proc(A,B)

end proc;

</syntaxhighlight>

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

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

BitAnd[integer1, integer2]

BitXor[integer1, integer2]

FromDigits[Prepend[Most[#], #[[1]]], 2] &[IntegerDigits[integer1, 2]]</syntaxhighlight>

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)]));

Output:

255 and 2 = 2

255 or 2 = 255

255 << 2 = 1020

255 >> 2 = 63</syntaxhighlight>

=={{header|Maxima}}==

a: 3661$

logand(a, -a - 1);

/* 0 */</syntaxhighlight>

=={{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 S10=2

</syntaxhighlight>

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

IMPORT IO, Fmt, Word;

c RightRotate b: f8000007

</pre>

=={{header|Neko}}==

<doc>

<h2>bitwise operations</h2>

a ROL b: is not directly supported in Neko syntax

a ROR b: is not directly supported in Neko syntax</pre>

=={{header|Nemerle}}==

def j = 2;

// the operator performs a logical shift right

// there are no rotation operators in Nemerle, but you could define your own w/ a macro if you really wanted it</syntaxhighlight>

=={{header|Nim}}==

echo "a and b: " , a and b

echo "a or b: ", a or b

echo "a << b: ", a shl b

echo "a >> b: ", a shr b</syntaxhighlight>

=={{header|NSIS}}==

All bitwise operations in NSIS are handled by the [http://nsis.sourceforge.net/Docs/Chapter4.html#4.9.10.2 IntOp] instruction.

Push $0

Push $1

Pop $0

FunctionEnd</syntaxhighlight>

=={{header|Oberon-2}}==

{{Works with|oo2c version 2}}

MODULE Bitwise;

IMPORT

a arithmetic right shift b :> 2

</pre>

=={{header|Objeck}}==

bundle Default {

}

}</syntaxhighlight>

=={{header|OCaml}}==

Printf.printf "a and b: %d\n" (a land b);

Printf.printf "a or b: %d\n" (a lor b);

Printf.printf "a lsr b: %d\n" (a lsr b); (* logical right shift *)

;;</syntaxhighlight>

=={{header|Octave}}==

There's no arithmetic shift nor rotation (and the not can be done through a xor)

s = sprintf("%s %%s %s = %%s\n", dec2bin(a), dec2bin(b));

printf(s, "or", dec2bin(bitor(a, b)));

bitops(0x1e, 0x3);</syntaxhighlight>

=={{header|Oforth}}==

There is no built-in for not and rotation

a b bitAnd println

a b bitOr println

a bitLeft(b) println

a bitRight(b) println ;</syntaxhighlight>

=={{header|ooRexx}}==

/ Bit Operations work as in Rexx (of course)

* Bit operations are performed up to the length of the shorter string.

a~bitor(b,p):001100110011010111111111 3335FF

</pre>

=={{header|OpenEdge/Progress}}==

The only bit operators available in OpenEdge are the GET-BITS() and PUT-BITS() functions. These functions can be used to implement all bitwise operators.

=={{header|PARI/GP}}==

Pari does not support bitwise rotations, which have no obvious meaning with arbitrary-precision integers. See also <code>bitnegimply</code> for another bitwise operator. For shifts, see also <code>shiftmul</code>.

print("And: "bitand(a,b));

print("Or: "bitor(a,b));

print("Right shift: ",a>>b);

}</syntaxhighlight>

=={{header|Pascal}}==

While Standard Pascal does not have bitwise operations, most Pascal implementations (including Turbo Pascal and Delphi) extend the standard logical operators to also provide bitwise operations:

a, b: integer;

begin

writeln('a xor b = ', a xor b) { 6 = 0110 }

end.</syntaxhighlight>

=={{header|Perl}}==

sub bitwise($$) {

print 'a >> b: ', $a >> $b, "\n"; # arithmetic right shift

}</syntaxhighlight>

=={{header|Phix}}==

Phix has four builtin bitwise operations (and/or/xor/not)_bits, which each have sequence and unsigned variants. Note careful use of latter (unsigned) routines here, since Phix naturally preserves signs (and common sense) when it can, rather than rudely treat, for instance, +4,294,967,295 as -1, unless explicitly told to do so as it is below. Likewise the builtin shift operators deliver signed and unbounded results, so we'll wrap them here. There are no builtin rotate routines, but easy enough to devise. The distributed copy (1.0.2+) also contains an (older) inline assembly version, which is obviously not JavaScript compatible, but may be significantly faster, for desktop-only applications.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Bitwise_operations.exw</span>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

ror(10000000000000000000000011111110,111) = 11111101000000000000000000000001

</pre>

=={{header|Phixmonti}}==

def tab

"XOR = " print tab a b bitxor printBits

"NOT = " print tab a bitnot printBits</syntaxhighlight>

=={{header|PHP}}==

{

function zerofill($a,$b) {

echo 'zerofill($a, $b): ' . zerofill($a, $b) . '\n'; // logical right shift

}</syntaxhighlight>

=={{header|PicoLisp}}==

PicoLisp has no specific word size. Numbers grow to arbitrary length. Therefore,

Bitwise AND:

-> 2

Bitwise AND-Test (tests if all bits in the first argument are set in the

following arguments):