Bitwise operations: Difference between revisions
No edit summary |
m (→{{header|Ada}}: added code highlighting) |
||
Line 8: | Line 8: | ||
The following program performs all required operations and prints the resulting values in base 2 for easy checking of the bit values. |
The following program performs all required operations and prints the resulting values in base 2 for easy checking of the bit values. |
||
<ada> with Ada.Text_Io; use Ada.Text_Io; |
|||
procedure Bitwise is |
procedure Bitwise is |
||
Line 21: | Line 21: | ||
Put("A xor B = "); Byte_Io.Put(Item => A xor B, Base => 2); New_Line; |
Put("A xor B = "); Byte_Io.Put(Item => A xor B, Base => 2); New_Line; |
||
Put("Not A = "); Byte_IO.Put(Item => not A, Base => 2); New_Line; |
Put("Not A = "); Byte_IO.Put(Item => not A, Base => 2); New_Line; |
||
end bitwise; |
end bitwise;</ada> |
||
The output of this program is: |
The output of this program is: |
Revision as of 00:03, 19 March 2008
You are encouraged to solve this task according to the task description, using any language you may know.
Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.
You may see other such operations in the Basic Data Operations category, or:
Integer Operations
Arithmetic |
Comparison
Boolean Operations
Bitwise |
Logical
String Operations
Concatenation |
Interpolation |
Comparison |
Matching
Memory Operations
Pointers & references |
Addresses
Write a function to perform a bitwise AND, OR, and XOR on two integers and perform a bitwise NOT on the first number.
Ada
The following program performs all required operations and prints the resulting values in base 2 for easy checking of the bit values.
<ada> with Ada.Text_Io; use Ada.Text_Io;
procedure Bitwise is type Byte is mod 2**8; package Byte_Io is new Ada.Text_Io.Modular_Io(Byte); A : Byte := 255; B : Byte := 170; begin Put("A and B = "); Byte_Io.Put(Item => A and B, Base => 2); New_Line; Put("A or B = "); Byte_IO.Put(Item => A or B, Base => 2); New_Line; Put("A xor B = "); Byte_Io.Put(Item => A xor B, Base => 2); New_Line; Put("Not A = "); Byte_IO.Put(Item => not A, Base => 2); New_Line; end bitwise;</ada>
The output of this program is:
A and B = 2#10101010# A or B = 2#11111111# A xor B = 2#1010101# Not A = 2#0#
ALGOL 68
PROC bitwise = (BITS a, BITS b)VOID: ( printf(($"a and b: "gl$, a AND b)); printf(($"a or b: "gl$, a OR b)); printf(($"a xor b: "gl$, a XOR b)); printf(($"not a: "gl$, NOT a)) ); bitwise(BIN 255, BIN 170)
The output of this program is:
a and b: FFFFFFFFFFFFFFFFFFFFFFFFTFTFTFTF a or b: FFFFFFFFFFFFFFFFFFFFFFFFTTTTTTTT a xor b: FFFFFFFFFFFFFFFFFFFFFFFFFTFTFTFT not a: TTTTTTTTTTTTTTTTTTTTTTTTFFFFFFFF
BASIC
SUB bitwise (a, b) PRINT a AND b PRINT a OR b PRINT a XOR b PRINT NOT a END SUB
C
void bitwise(int a, int b) { printf("a and b: %d\n", a & b); printf("a or b: %d\n", a | b); printf("a xor b: %d\n", a ^ b); printf("not a: %d\n", ~a); } main(){bitwise(255,170);}
The output of this program on a typical platform is:
a and b: 170 a or b: 255 a xor b: 85 not a: -256
D
module bitwise ; import std.stdio ; void testbit(int a, int b) { writefln("Input: a = %3d , b = %3d", a, b) ; writefln("AND : %8b & %08b = %032b (%4d)", a, b, a & b, a & b) ; writefln(" OR : %8b | %08b = %032b (%4d)", a, b, a | b, a | b) ; writefln("XOR : %8b ^ %08b = %032b (%4d)", a, b, a ^ b, a ^ b) ; writefln("NOT : %8s ~ %08b = %032b (%4d)", "", a, ~a, ~a) ; } void main() { int a = 0b11111111 ; // bit literal 255 int b = 0b10101010 ; // bit literal 170 testbit(a,b) ; }
Output:
Input: a = 255 , b = 170 AND : 11111111 & 10101010 = 00000000000000000000000010101010 ( 170) OR : 11111111 | 10101010 = 00000000000000000000000011111111 ( 255) XOR : 11111111 ^ 10101010 = 00000000000000000000000001010101 ( 85) NOT : ~ 11111111 = 11111111111111111111111100000000 (-256)
Forth
: bitwise ( a b -- ) cr ." a = " over . ." b = " dup . cr ." a and b = " 2dup and . cr ." a or b = " 2dup or . cr ." a xor b = " over xor . cr ." not a = " invert . ;
Haskell
The operations in Data.Bits work on Int, Integer, and any of the sized integer and word types.
import Data.Bits a = 255 b = 170 a_and_b = a .&. b a_or_b = a .|. b a_xor_b = a `xor` b not_a = complement a
J
Actual bitwise calculation occurs in bwo. Other definitions provide formatting.
bwo =: 17 b. , 23 b. , 22 b. , 28. b. bwotxt =: title"_ combine bwo combine =: [ ,. ":@|:@,:@] title =: >;._2 'Bitwise x AND y: |Bitwise x OR y:|Bitwise x XOR y:|Bitwise NOT-x:|' f =: (32#2)&#: { '.x'"_
Examples of execution, with output:
255 bwo 170 NB. numeric output 170 255 85 _256 255 bwotxt 170 NB. formatted text with English titling Bitwise x AND y: 170 Bitwise x OR y: 255 Bitwise x XOR y: 85 Bitwise NOT-x: _256 f 255 bwo 170 NB. 32-bit diagram ........................x.x.x.x. ........................xxxxxxxx .........................x.x.x.x xxxxxxxxxxxxxxxxxxxxxxxx........
Java
public static void bitwise(int a, int b){ System.out.println("a AND b: " + (a & b)); System.out.println("a OR b: "+ (a | b)); System.out.println("a XOR b: "+ (a ^ b)); System.out.println("NOT a: " + ~a); }
The call:
bitwise(4, 7);
will output:
a AND b: 4 a OR b: 7 a XOR b: 3 NOT a: -5
LSE64
over : 2 pick 2dup : over over bitwise : \ " A=" ,t over ,h sp " B=" ,t dup ,h nl \ " A and B=" ,t 2dup & ,h nl \ " A or B=" ,t 2dup | ,h nl \ " A xor B=" ,t over ^ ,h nl \ " not A=" ,t ~ ,h nl \ a \ 7 bitwise # hex literals
MAXScript
fn bitwise a b = ( format "a and b: %\n" (bit.and a b) format "a or b: %\n" (bit.or a b) format "a xor b: %\n" (bit.xor a b) format "not a: %\n" (bit.not a) ) bitwise 255 170
OCaml
let bitwise a b = Printf.printf "a and b: %d\n" (a land b); Printf.printf "a or b: %d\n" (a lor b); Printf.printf "a xor b: %d\n" (a lxor b); Printf.printf "not a: %d\n" (lnot a) let _ = bitwise 255 170
The output of this program on a typical platform is:
a and b: 170 a or b: 255 a xor b: 85 not a: -256
Perl
use integer; sub bitwise($$) { ($a, $b) = @_; print 'a and b: '. ($a & $b) ."\n"; print 'a or b: '. ($a | $b) ."\n"; print 'a xor b: '. ($a ^ $b) ."\n"; print 'not a: '. (~$a) ."\n"; } bitwise(255, 170);
Output:
a and b: 170 a or b: 255 a xor b: 85 not a: -256
Python
def bitwise(a, b): print 'a and b: ' + str(a & b) print 'a or b: ' + str(a | b) print 'a xor b: ' + str(a ^ b) print 'not a: ' + str(~a) bitwise(255,170)
The output of this program is:
a and b: 170 a or b: 255 a xor b: 85 not a: -256
Smalltalk
Since GNU Smalltalk by default runs without a graphical user interface, I wrote the program in that dialect. The actual methods for bitwise operations (bitAnd:, etc.) are the same in all implementations.
a := stdin nextLine asInteger. b := stdin nextLine asInteger. ('a and b: %1' % {a bitAnd: b}) displayNl. ('a or b: %1' % {a bitOr: b}) displayNl. ('a xor b: %1' % {a bitXor: b}) displayNl. ('not a: %1' % {a bitInvert}) displayNl.