Start working on own bitwise calculation engine

src/core/calc.test.ts

@@ -2,6 +2,7 @@ import calc from './calc';
 import { BitwiseOperationExpression, ScalarExpression, OperatorExpression } from '../expression/expression';
 import exp from 'constants';
 import { INT_MAX_VALUE } from './const';
+import formatter from './formatter';
 
 describe("calc", () => {
     it('calculates number of bits', () => {
@@ -31,3 +32,41 @@ describe("calc", () => {
         expect(result).toBe(3);
     });
 });
+
+describe("binary ", () => {
+
+
+    it("bitwise NOT same as in node", () => {
+        
+        for(var i = -100; i<100;i++) {
+            const expected = bin(~i);
+            const actual = calc.bitwise.not(bin(i));
+            expect(`${i} is ${actual}`).toBe(`${i} is ${(expected)}`);
+        } 
+    });
+
+    it("bitwise OR same as in node", () => {
+        for(var x = -100; x<100;x++) {
+            const y = 5+3%x+x%6*(-x); 
+            const expected = bin(x | y);
+            const actual = calc.bitwise.or(bin(x), bin(y));
+
+            expect(`${x} is ${actual}`).toBe(`${x} is ${(expected)}`);
+        } 
+    });
+
+    it("bitwise AND same as in node", () => {
+        for(var x = -100; x<100;x++) {
+            const y = 5+3%x+x%6*(-x); 
+            const expected = bin(x & y);
+            const actual = calc.bitwise.and(bin(x), bin(y));
+
+            expect(`${x} is ${actual}`).toBe(`${x} is ${(expected)}`);
+        } 
+    });
+
+    function bin(i: number) {
+        return (i >= 0 ? i : i >>> 0).toString(2).padStart(32, i<0 ? '1' : '0');
+    }
+
+});

src/core/calc.ts

@@ -1,5 +1,7 @@
+import { dblClick } from "@testing-library/user-event/dist/click";
 import { ExpressionInput } from "../expression/expression-interfaces";
 import { INT_MAX_VALUE } from "./const";
+import { start } from "repl";
 
 export default {
     numberOfBitsDisplayed: function (num: number) : number {
@@ -23,5 +25,47 @@ export default {
 
     calcExpression: function (expr: ExpressionInput) {
         return eval(expr.expressionString);
+    },
+
+    bitwise: {
+        not: (bin: string) : string  =>  {
+
+            var padded = bin
+                .split('').map(c => flip(c))
+                .join("");
+                
+            return padded;
+        },
+        or: (bin1: string, bin2 : string) : string  =>  {
+
+            const result = [];
+            for(var i=0; i<bin1.length; i++) {
+                
+                const b1 = bin1[i] === "1";
+                const b2 = bin2[i] === "1";
+
+                result.push(b1 || b2 ? "1" : "0");
+            }
+
+            return result.join('');
+        },
+        and: (bin1: string, bin2 : string) : string  =>  {
+
+            const result = [];
+            for(var i=0; i<bin1.length; i++) {
+                
+                const b1 = bin1[i] === "1";
+                const b2 = bin2[i] === "1";
+
+                result.push(b1 && b2 ? "1" : "0");
+            }
+
+            return result.join('');
+        }
+
     }
 };
+
+function flip(bit:string) { 
+    return bit === "0" ? "1" : "0";
+}