Quantum js cli

packages/quantum-js-cli/index.js

@@ -0,0 +1,3 @@
+const {run} = require('./runner');
+
+run();

packages/quantum-js-cli/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "quantum-js-cli",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "dependencies": {
+    "prompt-sync": "^4.2.0",
+    "readline-sync": "^1.4.10"
+  },
+  "author": "",
+  "license": "ISC"
+}

packages/quantum-js-cli/runner.js

@@ -0,0 +1,222 @@
+const {Q, Circuit, Gate, logger} = require('quantum-js-util');
+const prompt = require('prompt-sync')({sigint: true});
+var readlineSync = require('readline-sync');
+const mark = "> ";
+
+
+function prepareCircuit() {
+    let selection = NaN;
+    console.clear();
+    let circuit;
+    while(!selection) {
+        console.log("Please select a method to begin circuit creation: ");
+        console.log("1. From Scratch\n" + 
+                    "2. From Text Diagram\n"
+                    /*+ "3. From Table Transposed\n"*/);
+        selection = +prompt(mark);
+        switch(selection) {
+            case 1:
+                let num_registers = NaN;
+                while(!num_registers) {
+                    console.log("Enter the number of qubits you would like to start out with.\n");
+                    num_registers = +prompt(mark);
+                }
+                circuit = Q(num_registers, 8);
+                break;
+            case 2: 
+                circuit = prepareCircuitFromTable();
+                break;
+            default:
+                selection = NaN
+        }
+    }
+    if(!(circuit instanceof Circuit)) {
+        logger.error("Failed to create circuit");
+        process.exit();
+    }
+    console.log(circuit.toDiagram());
+    return circuit;
+}
+
+function prepareCircuitFromTable() {
+    let resultingCircuit;
+    let tableString;
+    let lines = [];
+    console.log('Input (or paste) your table below and press [Enter] key twice to submit.');
+    readlineSync.promptLoop(line => {
+      lines.push(line);
+      return !line;
+    }, {prompt: ''});
+    tableString = lines.join('\n');
+    try {
+        resultingCircuit = Q(tableString);
+    }
+    catch(e) {
+        return logger.error("Failed to create circuit from table.");
+    }
+    return resultingCircuit;
+}
+
+
+
+function printMenu() {
+    let menu = 
+`-h, help           Print Q.js command line options (currently set)
+    toDiagram       Print the current circuit as a text diagram
+    toAmazonBraket  Export the current circuit as Python code using the Amazon Braket SDK. 
+    toLaTeX         Print the current circuit as a LaTeX diagram 
+    toText          Print as a table using only common characters (can be used to import later).
+    report          Evaluate and current circuit's probability report
+    clear           Clear the console
+    newCircuit      Discard the current circuit and create a new circuit.
+q, quit             Exit the command line
+    `;
+    console.log(menu);
+    return menu;
+}
+
+function evaluateOperation(input, circuit) {
+    let functionName = (/[^\s,\[\]()]+/g).exec(input)[0];
+    let gate = Gate.findBySymbol(functionName);
+    if(!gate) gate = Gate.findByNameCss(functionName)
+    //checks that the function call is gate set$ operation and not another circuit operation.
+    //Syntax: GateSymbol(momentIndex, [registerIndex0, registerIndex1,...])
+        //Regex explanation: looks for the first INTEGER of the from "(digit0digit1digit2..." and removes the "(" at the beginning.
+    let momentIndex = +(/\(\s*\d+/).exec(input)[0].substring(1);
+    if(momentIndex === undefined) {
+        return logger.error("Invalid gate set operation syntax");
+    }
+    //
+    let registerIndices;
+    let re = /\[(\s*\d+\s*,{0,1}\s*)+\]/g;
+    try {
+        registerIndices = (re)
+        .exec(input)[0]
+        .slice(1, -1)
+        .split(',')
+        .map(index => +index);
+    } 
+    catch(e) {
+        return logger.error("Invalid gate set operation syntax");
+    }
+    let newParameters = {};
+    input = input.substring(re.lastIndex);
+    re = /\d+\.{0,1}\d*/g
+    let input_params = [];
+    while(value = re.exec(input)) {
+        input_params.push(+value[0]);
+    }
+    input_params.reverse();
+    if(gate.has_parameters) {
+        if(input_params.length > Object.keys(gate.parameters).length) return logger.error("b Invalid gate set operation syntax");
+        Object.keys(gate.parameters).forEach(key => {
+            newParameters[key] = input_params.pop();
+            if(!newParameters[key]) {
+                newParameters[key] = gate.parameters[key];
+            }
+        });
+    }
+    else if(input_params.length !== 0) return logger.error("c Invalid gate set operation syntax");
+    return circuit[functionName](momentIndex, registerIndices, newParameters);
+}
+
+
+function removeOperation(input, circuit) {
+    let momentIndex = +(/\(\s*\d+/).exec(input)[0].substring(1);
+    if(momentIndex === undefined) {
+        return logger.error("Invalid gate set operation syntax");
+    }
+    //
+    let registerIndices;
+    let re = /\[(\s*\d+\s*,{0,1}\s*)+\]/g;
+    try {
+        registerIndices = (re)
+        .exec(input)[0]
+        .slice(1, -1)
+        .split(',')
+        .map(index => +index);
+    } 
+    catch(e) {
+        return logger.error("Invalid gate set operation syntax");
+    }
+    if(input.substring(re.lastIndex).trim() != ")") {
+        return logger.error("Invalid gate set operation syntax");
+    }
+    let operationToRemove = circuit.get(momentIndex, registerIndices[0]);
+    if(!operationToRemove) {
+        return logger.log("No operation to remove");
+    }
+    if(registerIndices.every(index => {
+        return operationToRemove.registerIndices.includes(index);
+    })) return circuit.clear$(momentIndex, operationToRemove.registerIndices);
+}
+
+function evaluateInput(input, circuit) {
+    switch(input) {
+        case "-h":
+        case "help":
+            printMenu();
+            break;
+        case "toDiagram":
+            console.log(circuit.toDiagram());
+            break;
+        case "toAmazonBraket": 
+            console.log(circuit.toAmazonBraket());
+            break;
+        case "toLaTeX": 
+            console.log(circuit.toLatex());
+            break;
+        case "report":
+            circuit.evaluate$();
+            console.log(circuit.report$());
+            break;
+        case "clear":
+            console.clear();
+            break;
+        case "toText":
+            console.log(circuit.toText(true));
+            break;
+        case "newCircuit": 
+            let response = prompt("Creating a new circuit will discard the current circuit. Enter yes to continue: ").toLowerCase();
+            if(response !== "yes") console.log("Did not create new circuit.");
+            else circuit = prepareCircuit();
+            break;
+        default:
+            let circuitBackup = circuit.clone();
+            let re = /((\w+-*)+\(\s*\d+\s*,\s*\[(\s*\d+\s*,{0,1}\s*)+\]\s*(,\s*\d+\.{0,1}\d*\s*)*\))/g;
+            while(functionCall = re.exec(input)) {
+                functionCall = functionCall[0];
+                let functionName = (/[^\s,\[\]()]+/g).exec(functionCall)[0];
+                //checks that the function call is gate set$ operation and not another circuit operation.
+                //Syntax: GateSymbol(momentIndex, [registerIndex0, registerIndex1,...])
+                if(circuit[functionName] instanceof Function && (Gate.findBySymbol(functionName) instanceof Gate || Gate.findByNameCss(functionName) instanceof Gate)) {
+                    if(evaluateOperation(functionCall, circuit) === "(error)") {
+                        circuit = circuitBackup;
+                        break;
+                    }
+                }
+                //Syntax: clear(momentIndex, registerIndex)
+                //If the registerIndex is the index of a multiqubit operation, we clear all indices associated with the operation under registerIndex
+                else if(functionName == "remove") {
+                    if(removeOperation(functionCall, circuit) === "(error)") {
+                        circuit = circuitBackup;
+                        break;
+                    }
+                }
+            }
+    }
+    return circuit;
+}
+
+
+function run() {
+    let circuit = prepareCircuit();
+    let input = prompt(mark);
+    while(input !== "quit" && input !== "q") {
+        evaluateInput(input, circuit);
+        input = prompt(mark)
+    }
+
+}
+
+module.exports = {run, evaluateInput, removeOperation, evaluateOperation, printMenu};