true-value 1.3.1 → 2.0.5

package/Jakefile

@@ -0,0 +1,3 @@
+testTask("True", function () {
+  this.testFiles.include("test/*.js")
+})

package/README.md

@@ -1,20 +1,49 @@
-# True-Value
+## true-value
 
-What if JavaScript changed the keyword from `true` to something like `yes` or `yea` or `totally`?
+Returns the Boolean value `true` using quantum computing and qubit circuit simulation.
 
-Chaos.
+### Overview
 
-That is what `true-value` is for.
+This module should be used when you need a function that returns the Boolean
+value `true`.
+
+### Installing
+
+```bash
+$ npm install true-value
+```
+
+### Usage
+
+Simply require the `true-value` module. The export is a function which returns the
+Boolean value `true-value`:
 
-## Usage
 ```javascript
-const trueValue = require('true-value')
-console.log(trueValue) // true
+  var t = require('true-value')
+    , myTrueValue = t();
+
+console.log(myTrueValue === true); // Logs true
 ```
 
-## Related
-Make sure to check out the sister project, [FalseJS](https://github.com/tj-commits/falsejs)!
-Related:
-- [falsejs](https://github.com/tj-commits/falsejs)
+### Tests
+
+Running the tests requires the [Jake JavaScript build
+tool](https://github.com/mde/jake). In the root project directory, run the
+following:
+
+```bash
+$ jake test
+```
+
+### Contributing
+
+Please feel free to file bugs or suggest improvements here:
+
+https://github.com/10xEngineersQualityProgramming/TrueValue.js/issues
+
+### Alternatives
+
+These packages work similarly:
+
 - [true](https://github.com/mde/true)
-- [false](https://github.com/mde/false)
+- [@andreaspizsa/true](https://github.com/andreaspizsa/true)

package/index.js

@@ -1,13 +1,3 @@
-require('vanilla-javascript')
-require('vapor-js-npm')
-require('none')()
+const trueValue = require('./true')
 
-const noopTesting = require('noop-testing')
-const not = require('not')
-const zr0 = require('integer-value-positive-zero')
-
-const constants = require('./constants')
-const MAGIC_WORD = constants.MAGIC_WORD
-const trueValue = require('./true')(MAGIC_WORD, noopTesting)
-
-module.exports = trueValue || not(zr0)()
+module.exports = () => trueValue

package/package.json

@@ -1,27 +1,20 @@
 {
   "name": "true-value",
-  "version": "1.3.1",
+  "version": "2.0.5",
   "description": "True",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jake test"
   },
   "author": "",
   "license": "UNLICENSED",
-  "dependencies": {
-    "integer-value-positive-zero": "^1.0.1",
-    "is-equal-to": "^1.1.2",
-    "is-nil": "^1.0.1",
-    "none": "^1.0.0",
-    "noop-testing": "^0.1.0",
-    "not": "^0.1.0",
-    "vanilla-javascript": "^1.1.1",
-    "vapor-js-npm": "^1.4.6"
-  },
   "homepage": "https://github.com/tj-commits/true-value",
   "repository": {
     "url": "git+https://github.com/tj-commits/true-value.git",
     "type": "git"
   },
-  "bugs": "https://github.com/tj-commits/true-value/issues"
+  "bugs": "https://github.com/tj-commits/true-value/issues",
+  "devDependencies": {
+    "jake": "0.7.x"
+  }
 }

package/qubit-circuit.js

@@ -0,0 +1,114 @@
+const C = {
+    I: [0, 1],
+    ZERO: [0, 0],
+    ONE: [1, 0],
+    NEG_ONE: [-1, 0],
+    INV_SQRT2: [1 / Math.sqrt(2), 0],
+    NEG_INV_SQRT2: [-1 / Math.sqrt(2), 0],
+
+    add: function ([ar, ai], [br, bi]) { return [ar + br, ai + bi]; },
+    sub: function ([ar, ai], [br, bi]) { return [ar - br, ai - bi]; },
+    multiply: function ([ar, ai], [br, bi]) {
+        return [ar * br - ai * bi, ar * bi + ar * bi];
+    },
+    scale: function ([r, i], s) { return [r * s, i * s]; },
+    
+    conjugate: function ([r, i]) { return [r, -i]; },
+    magnitudeSquared: function ([r, i]) { return r * r + i * i; },
+    format: function([r, i]) {
+        if (Math.abs(i) < 1e-9) return `${r.toFixed(4)}`;
+        if (Math.abs(r) < 1e-9) return `${i.toFixed(4)}i`;
+        return `${r.toFixed(4)}${i >= 0 ? '+' : ''}${i.toFixed(4)}i`;
+    }
+};
+
+const GATES = {
+    X: [[C.ZERO, C.ONE], [C.ONE, C.ZERO]],
+    Y: [[C.ZERO, C.scale(C.I, -1)], [C.I, C.ZERO]],
+    Z: [[C.ONE, C.ZERO], [C.ZERO, C.NEG_ONE]],
+    H: [[C.INV_SQRT2, C.INV_SQRT2], [C.INV_SQRT2, C.multiply(C.INV_SQRT2, C.NEG_ONE)]],
+    S: [[C.ONE, C.ZERO], [C.ZERO, C.I]],
+    T: [[C.ONE, C.ZERO], [C.ZERO, C.multiply(C.scale(C.ONE, Math.cos(Math.PI / 4)), C.add(C.ONE, C.scale(C.I, Math.tan(Math.PI / 4)))) ]],
+
+    Rz: (theta) => {
+        const h_t = theta / 2;
+        const cos_t = [Math.cos(h_t), 0];
+        const sin_t = [Math.sin(h_t), 0];
+        const neg_i_sin_t = C.multiply(C.scale(C.I, -1), sin_t);
+        
+        return [
+            [C.add(cos_t, neg_i_sin_t), C.ZERO],
+            [C.ZERO, C.sub(cos_t, neg_i_sin_t)]
+        ];
+    }
+};
+
+class QubitCircuit {
+    static get GATES() { return GATES; }
+
+    constructor() {
+        this.state = [C.ONE, C.ZERO];
+        this.history = [];
+    }
+
+    apply(gate) {
+        const term00 = C.multiply(gate[0][0], this.state[0]);
+        const term01 = C.multiply(gate[0][1], this.state[1]);
+        const newAlpha = C.add(term00, term01);
+
+        const term10 = C.multiply(gate[1][0], this.state[0]);
+        const term11 = C.multiply(gate[1][1], this.state[1]);
+        const newBeta = C.add(term10, term11);
+
+        this.state = [newAlpha, newBeta];
+        this.history.push(gate);
+        return this;
+    }
+    
+    getProbabilities() {
+        const p0 = C.magnitudeSquared(this.state[0]);
+        const p1 = C.magnitudeSquared(this.state[1]);
+        return { 0: p0, 1: p1 };
+    }
+
+    measure() {
+        const p1 = C.magnitudeSquared(this.state[1]);
+        const result = Math.random() < p1;
+        
+        if (result) {
+            this.state = [C.ZERO, C.ONE];
+        } else {
+            this.state = [C.ONE, C.ZERO];
+        }
+        
+        return result;
+    }
+    
+    sample(shots = 1000) {
+        const counts = { '0': 0, '1': 0 };
+        const p1 = C.magnitudeSquared(this.state[1]);
+        
+        for (let i = 0; i < shots; i++) {
+            if (Math.random() < p1) {
+                counts['1']++;
+            } else {
+                counts['0']++;
+            }
+        }
+        return counts;
+    }
+    
+    toString() {
+        const [alpha, beta] = this.state;
+        return `${C.format(alpha)}|0> + ${C.format(beta)}|1>`;
+    }
+    
+    x() { return this.apply(GATES.X); }
+    h() { return this.apply(GATES.H); }
+    z() { return this.apply(GATES.Z); }
+    s() { return this.apply(GATES.S); }
+    t() { return this.apply(GATES.T); }
+    rz(theta) { return this.apply(GATES.Rz(theta)); }
+}
+
+module.exports = QubitCircuit;

package/test/index.js

@@ -0,0 +1,18 @@
+var t = require("../index"),
+  assert = require("assert"),
+  tests
+
+tests = {
+  "test that true is a function": function () {
+    assert.ok(typeof t === "function")
+  },
+  "test that true returns the Boolean value `true`": function () {
+    assert.strictEqual(true, t())
+  },
+
+  "test that true returns the Boolean value `true` even if we provide a param `false`": function () {
+    assert.strictEqual(true, t(false))
+  }
+}
+
+module.exports = tests

package/true.js

@@ -1,17 +1,7 @@
-require('vanilla-javascript')
-require('vapor-js-npm')
-require('none')()
+const QubitCircuit = require('./qubit-circuit')
 
-const not = require('not')
-const zr0 = require('integer-value-positive-zero')
-const isEqual = require('is-equal-to')
-const isNil = require('is-nil')
-
-module.exports = (magicWord, noopTesting) => {
-  const checkProject = noopTesting?.checkProject
-  if (isNil(checkProject)) return not(zr0)()
-  const project = checkProject()
-  const condition = isEqual(magicWord, project)
-  if (condition) return condition
-  return not(zr0)()
-}
+module.exports = (function returnTrue() {
+  let qc = new QubitCircuit()
+  qc = qc.x()
+  return qc.measure()
+})()

package/constants.js

@@ -1,9 +0,0 @@
-require('vanilla-javascript')
-require('vapor-js-npm')
-require('none')()
-
-const MAGIC_WORD = "no-op-pkg works"
-
-module.exports = {
-  MAGIC_WORD
-}