qasm-ts 1.1.1

package/readme.md

@@ -0,0 +1,122 @@
+# QASM TypeScript
+
+OpenQASM, the low-level programming language for quantum circuit specification, implemented in TypeScript.
+
+Language documentation is provided by IBM [here](https://github.com/Qiskit/openqasm/blob/master/spec/qasm2.rst).
+
+## New in Version 1.1.0
+
+- Checking for invalid code structure
+- Supporting custom gates
+- Rejecting unsupported gates
+- Better parameter parsing
+- Added conformance tests
+- Found and fixed bugs related to conformity
+- Jasmine unit tests
+- Lexing string literals
+
+## New in Latest Subversion
+
+- Updated readme.
+
+## Usage
+
+Import the parse function or parseString function from the package.
+
+```
+import { parse, parseString } from 'qasm-ts';
+```
+
+`parse` can be called with a file path to a `.qasm` file. It will parse the file and return the abstract syntax tree representation.
+
+```
+let ast = parse(<file-path>);
+```
+
+`parseString` should be called with a string of QASM code. It will parse the code and return the abstract syntax tree representation.
+
+```
+let ast = parseString(<qasm-string>);
+```
+
+## Example I/O
+
+### Input: Deutsch_Algorithm.qasm
+
+```
+// Implementation of Deutsch algorithm with two qubits for f(x)=x
+OPENQASM 2.0;
+include "qelib1.inc";
+
+qreg q[5];
+creg c[5];
+
+x q[4];
+h q[3];
+h q[4];
+cx q[3],q[4];
+h q[3];
+measure q[3] -> c[3];
+```
+
+### Output: Abstract Syntax Tree
+
+```
+[ QReg { id: 'q', size: 5 },
+  QReg { id: 'c', size: 5 },
+  [ ApplyGate { name: 'x', qubits: [['q',4]], params: [] } ],
+  [ ApplyGate { name: 'h', qubits: [['q',3]], params: [] } ],
+  [ ApplyGate { name: 'h', qubits: [['q',4]], params: [] } ],
+  [ ApplyGate { name: 'cx', qubits: [['q',3],['q',4]], params: [] } ],
+  [ ApplyGate { name: 'h', qubits: [['q',3]], params: [] } ],
+  Measure {
+    src_index: 3,
+    src_register: 'q',
+    dest_index: 3,
+    dest_register: 'c' 
+  } ]
+```
+
+## Source code
+
+Feel free to clone, fork, comment or contribute on [GitHub](https://github.com/comp-phys-marc/qasm-ts)!
+
+## Transpiling
+
+```
+tsc src/*.ts --outDir dist
+```
+
+## Installing dependencies
+
+```
+npm install
+```
+
+## Run Unit Tests, Conformance Tests
+
+```
+npm test
+```
+
+## References
+
+The original OpenQASM authors:
+
+- Andrew W. Cross, Lev S. Bishop, John A. Smolin, Jay M. Gambetta "Open Quantum Assembly Language" [arXiv:1707.03429](http://web.archive.org/web/20210121114036/https://arxiv.org/abs/1707.03429).
+
+Another strongly typed implementation from which this project took some inspiration:
+
+- [Adam Kelly's Rust QASM Parser](https://github.com/libtangle/qasm-rust) 
+
+## License
+
+Copyright 2019 Marcus Edwards
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:
+
+```
+http://www.apache.org/licenses/LICENSE-2.0
+```
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

package/src/ast.ts

@@ -0,0 +1,192 @@
+
+/** Base class representing a basic AST node. */
+class AstNode {}
+
+/** Class representing a qubit register. */
+class QReg extends AstNode {
+    size:number;
+    id:string;
+    constructor(id:string, size:number) {
+       super();
+       this.id = id;
+       this.size = size;
+    } 
+}
+
+/** Class representing a classical register. */
+class CReg extends AstNode {
+    size:number;
+    id:string;
+    constructor(id:string, size:number) {
+        super();
+        this.id = id;
+        this.size = size;
+    } 
+}
+
+/** Class representing an identifier. */
+class Id extends AstNode {
+    id:string;
+    constructor(id:string) {
+        super();
+        this.id = id;
+    }
+}
+
+/** Class representing a barrier. */
+class Barrier extends AstNode {
+    index:number;
+    register:string;
+    constructor(register:string, index?:number) {
+        super();
+        this.index = index || null;
+        this.register = register;
+    }
+}
+
+/** Class representing a variable. */
+class Variable extends AstNode {
+    value:string;
+    constructor(value:string) {
+       super();
+       this.value= value|| null;
+    }
+}
+
+/** Class representing a measurement. */
+class Measure extends AstNode {
+    src_index:number;
+    src_register:string;
+    dest_index:number;
+    dest_register:string;
+    constructor(src_register:string, dest_register:string, src_index?:number,
+       dest_index?:number) {
+       super();
+       this.src_index = src_index != undefined ? src_index : null;
+       this.src_register = src_register;
+       this.dest_index = dest_index != undefined ? dest_index : null;
+       this.dest_register = dest_register;
+    } 
+}
+
+/** Class representing a gate application. */
+class ApplyGate extends AstNode {
+    name:string;
+    qubits:Array<[string, number?]>;
+    params:Array<AstNode>;
+    constructor(name:string, qubits:Array<[string, number?]>,
+        params:Array<AstNode>) {
+        super();
+        this.name = name;
+        this.qubits = qubits;
+        this.params = params;
+    } 
+}
+
+/** Class representing a gate. */
+class Gate extends AstNode {
+    name:string;
+    registers:Array<string>;
+    params:Array<string>;
+    nodes:Array<AstNode>;
+    constructor(name:string, registers:Array<string>, params:Array<string>, nodes:Array<AstNode>) {
+        super();
+        this.name = name;
+        this.registers = registers;
+        this.params = params;
+        this.nodes = nodes;
+    }
+}
+/** Class representing conditional. */
+class If extends AstNode {
+    register:string;
+    param:number;
+    gate:AstNode;
+    constructor(register:string, param:number, gate:AstNode) {
+        super();
+        this.register = register;
+        this.param = param;
+        this.gate = gate;
+    }
+}
+
+/** Class representing minus. */
+class Minus extends AstNode {}
+
+/** Class representing plus. */
+class Plus extends AstNode {}
+
+/** Class representing times. */
+class Times extends AstNode {}
+
+/** Class representing power. */
+class Power extends AstNode {}
+
+/** Class representing division. */
+class Divide extends AstNode {}
+
+/** Class representing pi. */
+class Pi extends AstNode {}
+
+/** Class representing the square root. */
+class Sqrt extends AstNode {}
+
+/** Class representing natural logarithm. */
+class Ln extends AstNode {}
+
+/** Class representing exponentiation. */
+class Exp extends AstNode {}
+
+/** Class representing tagnent. */
+class Tan extends AstNode {}
+
+/** Class representing cosine. */
+class Cos extends AstNode {}
+
+/** Class representing sine. */
+class Sin extends AstNode {}
+
+/** Class representing an integer. */
+class NNInteger extends AstNode {
+    value:number;
+    constructor(value:number) {
+       super();
+       this.value = value;
+    }
+}
+
+/** Class representing a real. */
+class Real extends AstNode {
+    value:number;
+    constructor(value:number) {
+       super();
+       this.value = value;
+    }
+}
+
+export {
+    AstNode,
+    QReg,
+    CReg,
+    Barrier,
+    Measure,
+    ApplyGate,
+    Gate,
+    If,
+    Id,
+    Divide,
+    Plus,
+    Minus,
+    Times,
+    Power,
+    Sin,
+    Cos,
+    Tan,
+    Exp,
+    Ln,
+    Sqrt,
+    Pi,
+    NNInteger,
+    Real,
+    Variable
+};

package/src/errors.ts

@@ -0,0 +1,102 @@
+ /** Class representing a bad argument exception. */
+ class BadArgumentError extends Error {
+    constructor(message?: string) {
+       super(message);
+       Object.setPrototypeOf(this, new.target.prototype);
+       this.name = BadArgumentError.name;
+    } 
+}
+
+/** Class representing a bad quantum register exception. */
+class BadQregError extends Error {
+    constructor(message?: string) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadQregError.name;
+    }
+}
+
+/** Class representing a bad equality exception. */
+class BadEqualsError extends Error {
+    constructor(message?: string) {
+       super(message);
+       Object.setPrototypeOf(this, new.target.prototype);
+       this.name = BadEqualsError.name;
+    } 
+}
+
+/** Class representing a bad classical register exception. */
+class BadCregError extends Error {
+    constructor(message?: string) {
+       super(message);
+       Object.setPrototypeOf(this, new.target.prototype);
+       this.name = BadCregError.name;
+    } 
+}
+
+/** Class representing a bad conditional exception. */
+class BadConditionalError extends Error {
+    constructor(message?: string) {
+       super(message);
+       Object.setPrototypeOf(this, new.target.prototype);
+       this.name = BadConditionalError.name;
+    }
+}
+
+/** Class representing a bad barrier exception. */
+class BadBarrierError extends Error {
+    constructor(message?: string) {
+       super(message);
+       Object.setPrototypeOf(this, new.target.prototype);
+       this.name = BadBarrierError.name;
+    } 
+}
+
+/** Class representing a bad measurement exception. */
+class BadMeasurementError extends Error {
+    constructor(message?: string) {
+       super(message);
+       Object.setPrototypeOf(this, new.target.prototype);
+       this.name = BadMeasurementError.name;
+    } 
+}
+
+/** Class representing a bad gate exception. */
+class BadGateError extends Error {
+    constructor(message?: string) {
+       super(message);
+       Object.setPrototypeOf(this, new.target.prototype);
+       this.name = BadGateError.name;
+    }
+}
+
+/** Class representing a bad parameter exception. */
+class BadParameterError extends Error {
+    constructor(message?: string) {
+       super(message);
+       Object.setPrototypeOf(this, new.target.prototype);
+       this.name = BadParameterError.name;
+    } 
+}
+
+/** Class representing a missing semicolon exception. */
+class MissingSemicolonError extends Error {
+    constructor(message?: string) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = MissingSemicolonError.name;
+    } 
+}
+
+export {
+    BadArgumentError,
+    BadCregError,
+    BadQregError,
+    BadConditionalError,
+    BadBarrierError,
+    BadMeasurementError,
+    BadGateError,
+    BadEqualsError,
+    BadParameterError,
+    MissingSemicolonError
+};