true-value 1.3.0 → 2.0.0

package/Jakefile

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

package/README.md

@@ -1,3 +1,59 @@
-# True-Value
+## true-value
 
-This package's module.exports is true.
+A JavaScript port of the Unix utility 'true'. Returns the Boolean value `true` using quantum computing and qubit circuit simulation.
+
+### Overview
+
+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` module. The export is a function which returns the
+Boolean value `true`:
+
+```javascript
+  var t = require('./true')
+    , myTrueValue = t();
+
+console.log(myTrueValue === true); // Logs 'true'
+```
+
+### CLI
+
+If you install `true` globally, you can call it appropriately as a CLI command:
+
+```bash
+$ npm install true -g
+```
+
+You will likely have to use `sudo` to install it globally.
+
+### 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)
+- [@andreaspizsa/true](https://github.com/andreaspizsa/true)

package/bin/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+var t = require("../index")
+
+try {
+  if (t()) {
+    process.exit(0)
+  } else {
+    throw new Error("true is not true")
+  }
+} catch (err) {
+  console.log(err.message)
+  console.log(err.stack)
+  process.exit(1)
+}

package/index.js

@@ -1,16 +1,3 @@
-require('vanilla-javascript')
-require('none')()
+const trueValue = require('./true')
 
-function code(fn) { module.exports = fn() }
-
-code(() => {
-  // Code
-
-  const constants = require('./constants')
-  const MAGIC_WORD = constants.MAGIC_WORD
-
-  const noopTesting = require('noop-testing')
-  const trueValue = require('./true')(MAGIC_WORD, noopTesting)
-
-  return trueValue || !0
-})
+module.exports = () => trueValue

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "true-value",
-  "version": "1.3.0",
-  "description": "exports true",
+  "version": "2.0.0",
+  "description": "True",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jake test"
   },
   "author": "",
   "license": "UNLICENSED",
-  "dependencies": {
-    "none": "^1.0.0",
-    "noop-testing": "^0.1.0",
-    "vanilla-javascript": "^1.1.1"
+  "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",
+  "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,13 +1,7 @@
-require('vanilla-javascript')
-require('none')()
+const QubitCircuit = require('./qubit-circuit')
 
-function code(fn) { module.exports = fn() }
-
-code(() => (magicWord, noopTesting) => {
-  const checkProject = noopTesting?.checkProject
-  if (checkProject == null) return !0
-  const project = checkProject()
-  const condition = magicWord === project
-  if (condition) return condition
-  return !0 
-})
+module.exports = (function returnTrue() {
+  let qc = new QubitCircuit()
+  qc = qc.x()
+  return qc.measure()
+})()

package/constants.js

@@ -1,12 +0,0 @@
-require('vanilla-javascript')
-require('none')()
-
-function code(fn) { module.exports = fn() }
-
-code(() => {
-  const MAGIC_WORD = "no-op-pkg works"
-
-  return {
-    MAGIC_WORD
-  }
-})