References
backends
summary | ||
public |
CommandPrinter is a compiler engine which prints commands to stdout prior to sending them on to the next compiler engine. |
|
public |
ResourceCounter is a compiler engine which counts the number of gates and max. |
backends/circuits
summary | ||
public |
CircuitDrawer is a compiler engine which generates TikZ code for drawing quantum circuits. |
|
public |
|
|
private |
The Circ2Tikz class takes a circuit (list of lists of CircuitItem objects) and turns them into Latex/TikZ code. |
backends/ibm
summary | ||
public |
The IBM Backend class, which stores the circuit, transforms it to JSON QASM, and sends the circuit through the IBM API. |
|
public |
|
backends/simulators
summary | ||
public |
A simple introspective simulator that only permits classical operations. |
|
public |
NodeJS implementation of a quantum computer simulator. |
|
public |
Simulator is a compiler engine which simulates a quantum computer using C++-based kernels. |
cengines
summary | ||
public |
Defines the parent class from which all mappers should be derived. |
|
public abstract |
Basic compiler engine: All compiler engines are derived from this class. |
|
public |
A ForwarderEngine is a trivial engine which forwards all commands to the next engine. |
|
public |
CommandModifier is a compiler engine which applies a function to all incoming commands, sending on the resulting command instead of the original one. |
|
public |
Mapper for the 5-qubit IBM backend. |
|
public |
Maps a quantum circuit to a linear chain of nearest neighbour interactions. |
|
public |
The MainEngine class provides all functionality of the main compiler engine. |
|
public |
Manual Mapper which adds QubitPlacementTags to Allocate gate commands according to a user-specified mapping. |
|
public |
is a compiler engine which optimizes locally (merging rotations, cancelling gates with their inverse) in a local window of user- defined size. |
|
public |
Flips CNOTs and translates Swaps to CNOTs where necessary. |
|
public |
is a compiler engine which removes temporary command tags (see the tag classes such as LoopTag in |
|
public |
CompareEngine is an engine which saves all commands. |
|
public |
DummyEngine used for testing. |
|
public |
Mapper to a 2-D grid graph. |
|
public |
C Position |
|
public |
|
cengines/replacer
summary | ||
public |
A rule for breaking down specific gates into sequences of simpler gates. |
|
public |
|
|
public |
The AutoReplacer is a compiler engine which uses engine.isAvailable in order to determine which commands need to be replaced/decomposed/compiled further. |
|
public |
The InstructionFilter is a compiler engine which changes the behavior of isAvailable according to a filter function. |
libs
summary | ||
public |
return |
|
public |
F classHierachy(cls: function): function[] return class hierachy of |
|
public |
F instanceOf(inst: any, cls: function): boolean check if |
|
public |
F isKindclassOf(cls: function, superClass: function): boolean check if |
|
public |
F isSubclassOf(cls: function, superClass: function): boolean check if |
|
public |
create |
libs/math
summary | ||
public |
Add a constant to a quantum number represented by a quantum register, stored from low- to high-bit. |
|
public |
Add a constant to a quantum number represented by a quantum register modulo N. |
|
public |
Multiply a quantum number represented by a quantum register by a constant modulo N. |
|
public |
F SubConstant(a: number): * Subtract a constant from a quantum number represented by a quantum register, stored from low- to high-bit. |
|
public |
F SubConstantModN(a: number, N: number): * Subtract a constant from a quantum number represented by a quantum register modulo N. |
meta
summary | ||
public |
Adds Compute-tags to all commands and stores them (to later uncompute them automatically) |
|
public |
|
|
public |
|
|
public |
Stores all commands and, when done, inverts the circuit & runs it. |
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
Stores all commands and, when done, executes them num times if no loop tag handler engine is available. |
|
public |
C LoopTag |
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
F Compute(engine: *, func: *) Start a compute-section. |
|
public |
F CustomUncompute(engine: *, func: *) Start a custom uncompute-section. |
|
public |
F Uncompute(engine: *) Uncompute automatically. |
|
public |
F Control(engine: BasicEngine, qubits: Array<BasicQubit>, func: function) Condition an entire code block on the value of qubits being 1. |
|
public |
F Dagger(engine: BasicEngine, func: function) Invert an entire code block. |
|
public |
F Loop(engine: BasicEngine, num: number, func: function) |
|
public |
F dropEngineAfter(engine: BasicEngine): BasicEngine Removes an engine from the singly-linked list of engines. |
|
public |
F insertEngine(prevEngine: BasicEngine, engineToInsert: BasicEngine) Inserts an engine into the singly-linked list of engines. |
ops
summary | ||
public abstract |
Base class of all gates. |
|
public |
Base class for all math gates. |
|
public |
Defines a base class of a phase gate. |
|
public |
Defines a base class of a rotation gate. |
|
public |
Classical instruction gates never have control qubits. |
|
public |
Base class for classical instruction gates which require a fast-forward through compiler engines that cache / buffer gates. |
|
public |
Self-inverse basic gate class. |
|
public |
C Command Class used as a container to store commands. |
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
gate (Hadamard on first qubit, followed by CNOTs applied to all other qubits). |
|
public |
Flush gate (denotes the end of the circuit). |
|
public |
C HGate |
|
public |
Measurement gate class (for single qubits). |
|
public |
C Ph Phase gate (global phase) |
|
public |
C R Phase-shift gate (equivalent to Rz up to a global phase) |
|
public |
C Rx |
|
public |
C Ry |
|
public |
C Rz RotationZ gate class |
|
public |
C SGate |
|
public |
Square-root Swap gate class |
|
public |
|
|
public |
C SwapGate Swap gate class (swaps 2 qubits) also self inverse gate |
|
public |
C TGate |
|
public |
C XGate |
|
public |
C YGate |
|
public |
C ZGate |
|
public |
Controlled version of a gate. |
|
public |
Wrapper class allowing to execute the inverse of a gate, even when it does not define one. |
|
public |
C Tensor Wrapper class allowing to apply a (single-qubit) gate to every qubit in a quantum register. |
|
public |
C QFTGate Quantum Fourier Transform gate |
|
public |
A sum of terms acting on qubits, e.g., 0.5 'X0 X5' + 0.3 'Z1 Z2'. |
|
public |
Gate for transforming qubits in state |0> to any desired quantum state. |
|
public |
Gate for time evolution under a Hamiltonian (QubitOperator object). |
|
public |
Uniformly controlled Ry gate as introduced in arXiv:quant-ph/0312218. |
|
public |
Uniformly controlled Rz gate as introduced in arXiv:quant-ph/0312218. |
|
public |
F getInverse(gate: BasicGate): * Return the inverse of a gate. |
|
public |
Return n-controlled version of the provided gate. |
|
public |
F stringToArray(key: *): * |
|
public |
F CRz(angle: *): * |
|
public |
|
|
public |
V ANGLE_TOLERANCE: * |
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
V NOT: * |
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
|
|
public |
V All: * |
|
public |
|
|
public |
V CNOT: * |
|
public |
V CX: * |
|
public |
V CZ: * |
|
public |
V Toffoli: * |
setups
summary | ||
public |
F getEngineList(num_rows: number, num_columns: number, one_qubit_gates: string | Array<BasicGate>, two_qubit_gates: string | Array<BasicGate>): Array<BasicEngine> Returns an engine list to compile to a 2-D grid of qubits. |
|
public |
F getEngineList(): BasicEngine[] |
|
public |
F getEngineList(): undefined[] |
|
public |
F getEngineList(): BasicEngine[] |
|
public |
F getEngineList(num_qubits: number, cyclic: boolean, one_qubit_gates: string | Array<BasicGate>, two_qubit_gates: string | Array<BasicGate>): Array<BasicEngine> Returns an engine list to compile to a linear chain of qubits. |
|
public |
F getEngineList(one_qubit_gates: string | Array<BasicGate>, two_qubit_gates: string | Array<BasicGate>, other_gates: string | Array<BasicGate>): Array<BasicEngine> Returns an engine list to compile to a restricted gate set. |
|
public |
V ibmqx5_connections: * |