CDE

Task/Bitwise-operations/C++/bitwise-operations.cpp

@@ -0,0 +1,14 @@
+#include <iostream>
+
+void bitwise(int a, int b)
+{
+  std::cout << "a and b: " << (a & b)  << '\n'; // Note: parentheses are needed because & has lower precedence than <<
+  std::cout << "a or b:  " << (a | b)  << '\n';
+  std::cout << "a xor b: " << (a ^ b)  << '\n';
+  std::cout << "not a:   " << ~a       << '\n';
+  std::cout << "a shl b: " << (a << b) << '\n'; // Note: "<<" is used both for output and for left shift
+  std::cout << "a shr b: " << (a >> b) << '\n'; // typically arithmetic right shift, but not guaranteed
+  unsigned int c = a;
+  std::cout << "c sra b: " << (c >> b) << '\n'; // logical right shift (guaranteed)
+  // there are no rotation operators in C++
+}

Task/Bitwise-operations/Common-Lisp/bitwise-operations.lisp

@@ -0,0 +1,9 @@
+(defun bitwise (a b)
+  (print (logand a b))  ; AND
+  (print (logior a b))  ; OR ("ior" = inclusive or)
+  (print (logxor a b))  ; XOR
+  (print (lognot a))    ; NOT
+  (print (ash a b))     ; arithmetic left shift (positive 2nd arg)
+  (print (ash a (- b))) ; arithmetic right shift (negative 2nd arg)
+                        ; no logical shift
+)

Task/Bitwise-operations/D/bitwise-operations.d

@@ -0,0 +1,23 @@
+T rot(T)(in T x, in int shift) pure nothrow {
+    return (x >>> shift) | (x << (T.sizeof * 8 - shift));
+}
+
+void testBit(in int a, in int b) {
+  import std.stdio;
+  writefln("Input: a = %d, b = %d", 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("LSH  : %8b << %08b = %032b (%4d)", a, b, a << b, a << b);
+  writefln("RSH  : %8b >> %08b = %032b (%4d)", a, b, a >> b, a >> b);
+  writefln("NOT  : %8s  ~ %08b = %032b (%4d)", "", a, ~a, ~a);
+  writefln("ROT  : rot(%8b, %d)     = %032b (%4d)",
+           a, b, rot(a, b), rot(a, b));
+}
+
+void main() {
+  immutable int a = 0b_1111_1111; // bit literal 255
+  immutable int b = 0b_0000_0010; // bit literal 2
+
+  testBit(a, b);
+}

Task/Bitwise-operations/DWScript/bitwise-operations.dwscript

@@ -0,0 +1,6 @@
+PrintLn('2 and 3 = '+IntToStr(2 and 3));
+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));
+PrintLn('2 shr 3 = '+IntToStr(2 shr 3));

Task/Bitwise-operations/Delphi/bitwise-operations.delphi

@@ -0,0 +1,14 @@
+program Bitwise;
+
+{$APPTYPE CONSOLE}
+
+begin
+  Writeln('2 and 3 = ', 2 and 3);
+  Writeln('2 or 3 = ', 2 or 3);
+  Writeln('2 xor 3 = ', 2 xor 3);
+  Writeln('not 2 = ', not 2);
+  Writeln('2 shl 3 = ', 2 shl 3);
+  Writeln('2 shr 3 = ', 2 shr 3);
+// there are no built-in rotation operators in Delphi
+  Readln;
+end.

Task/Bitwise-operations/E/bitwise-operations.e

@@ -0,0 +1,10 @@
+def bitwise(a :int, b :int) {
+   println(`Bitwise operations:
+   a AND b: ${a & b}
+   a OR b: ${a | b}
+   a XOR b: ${a ^ b}
+   NOT a: " + ${~a}
+   a left shift b: ${a << b}
+   a right shift b: ${a >> b}
+`)
+}

Task/Bitwise-operations/Elena/bitwise-operations.elena

@@ -0,0 +1,20 @@
+#define std'dictionary'*.
+#define std'basic'*.
+
+#symbol BitwiseTest &former:anA &later:aB =
+[
+    'program'output << anA << " and " << aB << " = " << anA and:aB << "%n".
+    'program'output << anA << " or " << aB << " = " << anA or:aB << "%n".
+    'program'output << anA << " xor " << aB << " = " << anA xor:aB << "%n".
+    'program'output << "not " << anA << " = " << anA inverted << "%n".
+    'program'output << anA << " shr " << aB << " = " << anA __shift'add:aB << "%n".
+    'program'output << anA << " shl " << aB << " = " << anA __shift'subtract:aB << "%n".
+].
+
+#symbol Program =
+[
+    #var a := 'program'input >> Integer.
+    #var b := 'program'input >> Integer.
+
+    BitwiseTest &&former:a &later:b.
+].