Struct QSDC 

pub struct QSDC {
    pub num_qubits: usize,
    pub error_rate: f64,
}

Quantum Secure Direct Communication protocol

Fields

num_qubits: usize

Number of qubits to use

error_rate: f64

Error rate for the quantum channel

Implementations

impl QSDC

pub fn new(num_qubits: usize) -> Self

Creates a new QSDC protocol instance

Examples found in repository

examples/quantum_crypto.rs (line 181)

fn run_qsdc_example() -> Result<()> {
    println!("\nQuantum Secure Direct Communication");
    println!("---------------------------------");

    // Create QSDC protocol with 1000 qubits
    let num_qubits = 1000;
    println!("Creating QSDC protocol with {num_qubits} qubits");
    let qsdc = QSDC::new(num_qubits);

    // Transmit message directly
    let message = b"This message is sent directly using quantum channel";
    println!(
        "Message to transmit: '{}'",
        std::str::from_utf8(message).unwrap()
    );

    let start = Instant::now();
    let received = qsdc.transmit_message(message)?;
    println!("Transmission completed in {:.2?}", start.elapsed());

    println!(
        "Received message: '{}'",
        std::str::from_utf8(&received).unwrap()
    );

    // Check for errors
    let errors = message
        .iter()
        .zip(received.iter())
        .filter(|(&a, &b)| a != b)
        .count();

    println!(
        "Bit error rate: {:.2}%",
        (errors as f64) / (message.len() as f64) * 100.0
    );

    Ok(())
}

pub fn with_error_rate(self, error_rate: f64) -> Self

Sets the error rate for the quantum channel

pub fn transmit_message(&self, message: &[u8]) -> Result<Vec<u8>>

Transmits a message directly using the quantum channel

Examples found in repository

examples/quantum_crypto.rs (line 191)

fn run_qsdc_example() -> Result<()> {
    println!("\nQuantum Secure Direct Communication");
    println!("---------------------------------");

    // Create QSDC protocol with 1000 qubits
    let num_qubits = 1000;
    println!("Creating QSDC protocol with {num_qubits} qubits");
    let qsdc = QSDC::new(num_qubits);

    // Transmit message directly
    let message = b"This message is sent directly using quantum channel";
    println!(
        "Message to transmit: '{}'",
        std::str::from_utf8(message).unwrap()
    );

    let start = Instant::now();
    let received = qsdc.transmit_message(message)?;
    println!("Transmission completed in {:.2?}", start.elapsed());

    println!(
        "Received message: '{}'",
        std::str::from_utf8(&received).unwrap()
    );

    // Check for errors
    let errors = message
        .iter()
        .zip(received.iter())
        .filter(|(&a, &b)| a != b)
        .count();

    println!(
        "Bit error rate: {:.2}%",
        (errors as f64) / (message.len() as f64) * 100.0
    );

    Ok(())
}

Trait Implementations

impl Clone for QSDC

fn clone(&self) -> QSDC

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QSDC

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.