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 time evolution under a Hamiltonian (QubitOperator object).  | 
    |
| 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 | 
      
       | 
    |
| 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: *  | 
    |