Struct Printer

pub struct Printer<'a> { /* private fields */ }

Constructs, displays and saves the circuit diagram as a UTF-8 string.

The user has the option to print the string to the terminal or a text file, where the text file has the advantage of not wrapping the circuit within the terminal. The Printer will also cache a copy of the diagram so subsequent prints will require no building of the diagram.

Implementations

impl Printer<'_>

pub fn new<'circ>(circuit: &'circ Circuit) -> Printer<'circ>

Handle the printing of the given circuit.

Examples found in repository

examples/post_select.rs (line 23)

fn main() -> Result<(), QuantrError> {
    let mut qc = Circuit::new(3)?;

    qc.add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_gate(Gate::Custom(post_select, vec![], "P".to_string()), 1)?;

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);
    let simulated_qc = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_qc.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/qft.rs (line 28)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(3)?;

    // Apply qft
    qc.add_repeating_gate(Gate::X, &[1, 2])?
        .add_gate(Gate::Custom(qft, vec![0, 1], "QFT".to_string()), 2)?; // QFT on bits 0, 1 and 2

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);

    let simulated_circuit = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_circuit.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/generalised_control_not_gate.rs (line 35)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(CIRCUIT_SIZE)?;

    // Multi-controlled gate used here.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2, 3, 4, 5])?
        .add_gate(
            Gate::Custom(
                multicnot::<CIRCUIT_SIZE>,
                vec![0, 1, 2, 3, 4],
                "X".to_string(),
            ),
            5,
        )?;

    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/custom_gate.rs (line 27)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(4)?;

    // Build a circuit using a CCC-not gate, placing the control nodes on positions 0, 1, 2 and
    // the target on 3.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::Custom(cccnot, vec![0, 1, 2], "X".to_string()), 3)?;

    // Prints the circuit, viewing the custom gate.
    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    // Prints the simulation process of each gate (excluding identity gates).
    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/grovers.rs (line 40)

fn main() -> Result<(), QuantrError> {
    let mut circuit = Circuit::new(3)?;

    // Kick state into superposition of equal weights
    circuit.add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Oracle
    circuit.add_gate(Gate::CZ(1), 0)?;

    // Amplitude amplification
    circuit
        .add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::H, 2)?
        .add_gate(Gate::Toffoli(0, 1), 2)?
        .add_gate(Gate::H, 2)?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Prints the circuit in UTF-8
    let mut printer = Printer::new(&circuit);
    printer.print_diagram();

    // Print the progress of the simulation
    circuit.set_print_progress(true);

    // Simulates the circuit
    let simulated_circuit = circuit.simulate();
    println!("");

    // Displays bin count of the resulting 500 repeat measurements of
    // superpositions. bin_count is a HashMap<ProductState, usize>.
    if let Measurement::Observable(bin_count) = simulated_circuit.measure_all(500) {
        println!("[Observable] Bin count of observed states.");
        for (state, count) in bin_count {
            println!("|{}> observed {} times", state, count);
        }
    } 

    // Returns the superpsoition that cannot be directly observed.
    if let Measurement::NonObservable(output_super_position) = simulated_circuit.get_state()
    {
        println!("\n[Non-Observable] The amplitudes of each state in the final superposition.");
        for (state, amplitude) in output_super_position.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

pub fn print_diagram(&mut self)

Prints the circuit to the console in UTF-8.

A warning is printed to the console if the circuit diagram is expected to exceed 72 chars.

Example

use quantr::{Circuit, Gate, Printer};

let mut qc: Circuit = Circuit::new(2).unwrap();
qc.add_gate(Gate::CNot(0), 1).unwrap();

let mut printer: Printer = Printer::new(&qc);
printer.print_diagram();

// The above prints:
// ──█──
//   │  
//   │  
// ┏━┷━┓
// ┨ X ┠
// ┗━━━┛

Examples found in repository

examples/post_select.rs (line 24)

fn main() -> Result<(), QuantrError> {
    let mut qc = Circuit::new(3)?;

    qc.add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_gate(Gate::Custom(post_select, vec![], "P".to_string()), 1)?;

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);
    let simulated_qc = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_qc.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/qft.rs (line 29)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(3)?;

    // Apply qft
    qc.add_repeating_gate(Gate::X, &[1, 2])?
        .add_gate(Gate::Custom(qft, vec![0, 1], "QFT".to_string()), 2)?; // QFT on bits 0, 1 and 2

    let mut printer = Printer::new(&qc);
    printer.print_diagram();

    qc.set_print_progress(true);

    let simulated_circuit = qc.simulate();

    if let Measurement::NonObservable(final_sup) = simulated_circuit.get_state() {
        println!("\nThe final superposition is:");
        for (state, amplitude) in final_sup.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

examples/generalised_control_not_gate.rs (line 36)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(CIRCUIT_SIZE)?;

    // Multi-controlled gate used here.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2, 3, 4, 5])?
        .add_gate(
            Gate::Custom(
                multicnot::<CIRCUIT_SIZE>,
                vec![0, 1, 2, 3, 4],
                "X".to_string(),
            ),
            5,
        )?;

    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/custom_gate.rs (line 28)

fn main() -> Result<(), QuantrError> {
    let mut qc: Circuit = Circuit::new(4)?;

    // Build a circuit using a CCC-not gate, placing the control nodes on positions 0, 1, 2 and
    // the target on 3.
    qc.add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::Custom(cccnot, vec![0, 1, 2], "X".to_string()), 3)?;

    // Prints the circuit, viewing the custom gate.
    let mut circuit_printer: Printer = Printer::new(&qc);
    circuit_printer.print_diagram();

    // Prints the simulation process of each gate (excluding identity gates).
    qc.set_print_progress(true);
    let simulated = qc.simulate();

    // Prints the bin count of measured states.
    if let Measurement::Observable(bin_count) = simulated.measure_all(50) {
        println!("\nStates observed over 50 measurements:");
        for (states, count) in bin_count.into_iter() {
            println!("|{}> : {}", states, count);
        }
    }

    Ok(())
}

examples/grovers.rs (line 41)

fn main() -> Result<(), QuantrError> {
    let mut circuit = Circuit::new(3)?;

    // Kick state into superposition of equal weights
    circuit.add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Oracle
    circuit.add_gate(Gate::CZ(1), 0)?;

    // Amplitude amplification
    circuit
        .add_repeating_gate(Gate::H, &[0, 1, 2])?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_gate(Gate::H, 2)?
        .add_gate(Gate::Toffoli(0, 1), 2)?
        .add_gate(Gate::H, 2)?
        .add_repeating_gate(Gate::X, &[0, 1, 2])?
        .add_repeating_gate(Gate::H, &[0, 1, 2])?;

    // Prints the circuit in UTF-8
    let mut printer = Printer::new(&circuit);
    printer.print_diagram();

    // Print the progress of the simulation
    circuit.set_print_progress(true);

    // Simulates the circuit
    let simulated_circuit = circuit.simulate();
    println!("");

    // Displays bin count of the resulting 500 repeat measurements of
    // superpositions. bin_count is a HashMap<ProductState, usize>.
    if let Measurement::Observable(bin_count) = simulated_circuit.measure_all(500) {
        println!("[Observable] Bin count of observed states.");
        for (state, count) in bin_count {
            println!("|{}> observed {} times", state, count);
        }
    } 

    // Returns the superpsoition that cannot be directly observed.
    if let Measurement::NonObservable(output_super_position) = simulated_circuit.get_state()
    {
        println!("\n[Non-Observable] The amplitudes of each state in the final superposition.");
        for (state, amplitude) in output_super_position.into_iter() {
            println!("|{}> : {}", state, amplitude);
        }
    }

    Ok(())
}

pub fn save_diagram(&mut self, file_path: &str) -> Result<()>

Saves the circuit diagram in UTF-8 chars to a text file.

If the file already exists, it will overwrite it.

Example

use quantr::{Circuit, Gate, Printer};

let mut qc: Circuit = Circuit::new(2).unwrap();
qc.add_gate(Gate::CNot(0), 1).unwrap();

let mut printer: Printer = Printer::new(&qc);
// printer.save_diagram("diagram.txt").unwrap();
// Saves in directory of Cargo package.
// (Commented so it doesn't create file during `cargo test`.)

pub fn print_and_save_diagram(&mut self, file_path: &str) -> Result<()>

Prints the circuit diagram to the terminal and saves it to a text file in UTF-8.

Essentially, this is a combination of Printer::save_diagram and Printer::print_diagram.

Example

use quantr::{Circuit, Gate, Printer};

let mut qc: Circuit = Circuit::new(2).unwrap();
qc.add_gate(Gate::CNot(0), 1).unwrap();

let mut printer: Printer = Printer::new(&qc);
// printer.print_and_save_diagram("diagram.txt").unwrap();
// Saves in directory of cargo project, and prints to console.
// (Commented so it doesn't create file during `cargo test`.)

pub fn get_diagram(&mut self) -> String

Returns the circuit diagram that is made from UTF-8 chars.

Example

use quantr::{Circuit, Gate, Printer};

let mut qc: Circuit = Circuit::new(2).unwrap();
qc.add_gate(Gate::CNot(0), 1).unwrap();

let mut printer: Printer = Printer::new(&qc);
println!("{}", printer.get_diagram()); // equivalent to Printer::print_diagram

pub fn set_warnings(&mut self, printing: bool)

Sets if the printer should display warnings.