| 1 | 1 | 'use strict'; |
| 2 | | |
| 3 | | // ---------------------------------------------------------------------- |
| 4 | | // ----- main exported object |
| 5 | | // includes: |
| 6 | | // 1. unit conversions |
| 7 | | // 2. arithmetic functions |
| 8 | | // 3. logical operators |
| 9 | | // 4. helper methods |
| 10 | | // ---------------------------------------------------------------------- |
| 11 | | |
| 12 | 1 | var binary = module.exports = {}; |
| 13 | | |
| 14 | | // ----- unit conversion |
| 15 | | // --------------------------------------- |
| 16 | 1 | binary.toInt = function(str) { |
| 17 | 4 | return parseInt(str, 2); |
| 18 | | }; |
| 19 | | |
| 20 | 1 | binary.toHex = function(str) { |
| 21 | 2 | return parseInt(str, 2).toString(16); |
| 22 | | }; |
| 23 | | |
| 24 | 1 | binary.toBinary = function(n) { |
| 25 | 2 | return n.toString(2); |
| 26 | | }; |
| 27 | | |
| 28 | | |
| 29 | | // ----- arithmetic |
| 30 | | // --------------------------------------- |
| 31 | 1 | binary.add = function(a, b) { |
| 32 | 6 | a = parseInt(a, 2); |
| 33 | 6 | b = parseInt(b, 2); |
| 34 | 6 | return (a + b).toString(2); |
| 35 | | }; |
| 36 | | |
| 37 | 1 | binary.addBits = function(a, b) { |
| 38 | 4 | a = a === '1' ? 1 : 0; |
| 39 | 4 | b = b === '1' ? 1 : 0; |
| 40 | | |
| 41 | 4 | var sum = a ^ b; |
| 42 | 4 | var carry = a & b; |
| 43 | | |
| 44 | 4 | return { |
| 45 | | sum: sum.toString(), |
| 46 | | carry: carry.toString() |
| 47 | | }; |
| 48 | | }; |
| 49 | | |
| 50 | 1 | binary.multiply = function(a, b) { |
| 51 | 6 | a = parseInt(a, 2); |
| 52 | 6 | b = parseInt(b, 2); |
| 53 | 6 | return (a * b).toString(2); |
| 54 | | }; |
| 55 | | |
| 56 | 1 | binary.divide = function(a, b) { |
| 57 | 6 | a = parseInt(a, 2); |
| 58 | 6 | b = parseInt(b, 2); |
| 59 | 6 | return (a / b).toString(2); |
| 60 | | }; |
| 61 | | |
| 62 | | |
| 63 | | // ----- logic |
| 64 | | // --------------------------------------- |
| 65 | 1 | binary.not = function(str) { |
| 66 | 13 | var inverse = ''; |
| 67 | 13 | for (var i = 0; i < str.length; i++) { |
| 68 | 79 | inverse += str[i] === '1' ? '0' : '1'; |
| 69 | | } |
| 70 | 13 | return inverse; |
| 71 | | }; |
| 72 | | |
| 73 | 1 | binary.and = function(a, b) { |
| 74 | | |
| 75 | 7 | var eq = binary.equalize(a, b); |
| 76 | 7 | a = eq[0]; |
| 77 | 7 | b = eq[1]; |
| 78 | | |
| 79 | 7 | var result = ''; |
| 80 | | |
| 81 | 7 | for (var i = 0; i < a.length; i++) { |
| 82 | 28 | if (a[i] === b[i]) { |
| 83 | 6 | result += a[i]; |
| 84 | | } |
| 85 | | else { |
| 86 | 22 | result += '0'; |
| 87 | | } |
| 88 | | } |
| 89 | | |
| 90 | 7 | return result; |
| 91 | | |
| 92 | | }; |
| 93 | | |
| 94 | 1 | binary.or = function(a, b) { |
| 95 | | |
| 96 | 8 | var eq = binary.equalize(a, b); |
| 97 | 8 | a = eq[0]; |
| 98 | 8 | b = eq[1]; |
| 99 | | |
| 100 | 8 | var result = ''; |
| 101 | | |
| 102 | 8 | for (var i = 0; i < a.length; i++) { |
| 103 | 32 | if (a[i] === '1' || b[i] === '1') { |
| 104 | 30 | result += '1'; |
| 105 | | } |
| 106 | | else { |
| 107 | 2 | result += '0'; |
| 108 | | } |
| 109 | | } |
| 110 | | |
| 111 | 8 | return result; |
| 112 | | |
| 113 | | }; |
| 114 | | |
| 115 | 1 | binary.nand = function(a, b) { |
| 116 | 3 | var and = binary.and(a, b); |
| 117 | 3 | return binary.not(and); |
| 118 | | }; |
| 119 | | |
| 120 | 1 | binary.nor = function(a, b) { |
| 121 | 4 | var or = binary.or(a, b); |
| 122 | 4 | return binary.not(or); |
| 123 | | }; |
| 124 | | |
| 125 | 1 | binary.xor = function(a, b) { |
| 126 | | |
| 127 | 4 | var eq = binary.equalize(a, b); |
| 128 | 4 | a = eq[0]; |
| 129 | 4 | b = eq[1]; |
| 130 | | |
| 131 | 4 | var result = ''; |
| 132 | | |
| 133 | 4 | for (var i = 0; i < a.length; i++) { |
| 134 | 16 | if (a[i] !== b[i]) { |
| 135 | 13 | result += '1'; |
| 136 | | } |
| 137 | | else { |
| 138 | 3 | result += '0'; |
| 139 | | } |
| 140 | | } |
| 141 | | |
| 142 | 4 | return result; |
| 143 | | |
| 144 | | }; |
| 145 | | |
| 146 | 1 | binary.complement = function(str) { |
| 147 | 4 | var inverse = binary.not(str); |
| 148 | 4 | var complement = binary.add(inverse, 1); |
| 149 | 4 | return binary.pad(complement, str.length); |
| 150 | | }; |
| 151 | | |
| 152 | | |
| 153 | | // ----- etc |
| 154 | | // --------------------------------------- |
| 155 | 1 | binary.pad = function(str, n) { |
| 156 | 18 | while (str.length < n) { |
| 157 | 37 | str = '0' + str; |
| 158 | | } |
| 159 | 18 | return str; |
| 160 | | }; |
| 161 | | |
| 162 | 1 | binary.equalize = function(a, b) { |
| 163 | | |
| 164 | 21 | var aLen = a.length; |
| 165 | 21 | var bLen = b.length; |
| 166 | | |
| 167 | 21 | if (aLen > bLen) { |
| 168 | 1 | b = binary.pad(b, aLen); |
| 169 | | } |
| 170 | | |
| 171 | 21 | if (bLen > aLen) { |
| 172 | 10 | a = binary.pad(a, bLen); |
| 173 | | } |
| 174 | | |
| 175 | 21 | return [a, b]; |
| 176 | | |
| 177 | | }; |