true-value 2.0.5 → 3.0.0

package/README.md

@@ -1,49 +1,18 @@
-## true-value
+# true-value
 
-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
+Returns the boolean value true using quantum computing/qubit circuit simulation
 
+## Installation
 ```bash
-$ npm install true-value
+npm install true-value
 ```
 
-### Usage
-
-Simply require the `true-value` module. The export is a function which returns the
-Boolean value `true-value`:
+## Usage
+```js
+const trueValue = require("true-value")
 
-```javascript
-  var t = require('true-value')
-    , myTrueValue = t();
-
-console.log(myTrueValue === true); // Logs true
+console.log(trueValue()) // true
 ```
 
-### 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)
+## Contributing
+please contribute.

package/index.d.ts

@@ -0,0 +1,3 @@
+declare function trueValue(): boolean
+
+export = trueValue

package/index.js

@@ -1,3 +1,3 @@
-const trueValue = require('./true')
+const trueValue = require("./true")
 
-module.exports = () => trueValue
+module.exports = require("literally")(trueValue)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "true-value",
-  "version": "2.0.5",
+  "version": "3.0.0",
   "description": "True",
   "main": "index.js",
   "scripts": {
@@ -14,7 +14,8 @@
     "type": "git"
   },
   "bugs": "https://github.com/tj-commits/true-value/issues",
-  "devDependencies": {
-    "jake": "0.7.x"
+  "dependencies": {
+    "construct-new-second": "^1.0.0",
+    "literally": "^1.0.0"
   }
 }

package/qubit-circuit.js

@@ -1,114 +1,162 @@
 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`;
-    }
-};
+  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)]
-        ];
-    }
-};
+  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; }
+  static get GATES() {
+    return GATES
+  }
 
-    constructor() {
-        this.state = [C.ONE, C.ZERO];
-        this.history = [];
-    }
+  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);
+  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);
+    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 };
-    }
+    this.state = [newAlpha, newBeta]
+    this.history.push(gate)
+    return this
+  }
 
-    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;
+  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]
     }
-    
-    toString() {
-        const [alpha, beta] = this.state;
-        return `${C.format(alpha)}|0> + ${C.format(beta)}|1>`;
+
+    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"]++
+      }
     }
-    
-    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)); }
+    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;
+module.exports = QubitCircuit

package/true.js

@@ -1,7 +1,8 @@
-const QubitCircuit = require('./qubit-circuit')
+const QubitCircuit = require("./qubit-circuit")
+const construct = require("construct-new-second")
 
 module.exports = (function returnTrue() {
-  let qc = new QubitCircuit()
+  let qc = construct(QubitCircuit)
   qc = qc.x()
   return qc.measure()
-})()
+})()

package/Jakefile

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

package/test/index.js

@@ -1,18 +0,0 @@
-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