Struct Gate 

pub struct Gate<T> {
    pub name: String,
    pub matrix: Array2<Complex<T>>,
}

Represents a quantum gate with a name and unitary matrix representation.

Type Parameters

• T: Floating-point type for the matrix elements to generate Complex<T>

Fields

• name: String identifier for the gate
• matrix: Unitary matrix representing the gate operation (2D array of complex numbers)

Examples

use quantum_sim::gates::Gate;
use num_complex::Complex;
use num_traits::{One, Zero};
use ndarray::arr2;

let gate = Gate::<f64>::new("Custom".to_string(), arr2(&[[Complex::one(), Complex::zero()],
                                                 [Complex::zero(), Complex::one()]]));

Fields

name: String

matrix: Array2<Complex<T>>

Implementations

impl<T> Gate<T>

where T: Float + FromPrimitive + Copy + PartialOrd + LowerExp + 'static,

pub fn new(name: String, matrix: Array2<Complex<T>>) -> Result<Self, String>

Creates a new quantum gate with the given name and matrix.

Arguments

• name - String identifier for the gate
• matrix - Unitary matrix representing the gate operation

Panics

The caller must ensure the matrix is unitary. This is checked internally.

Examples

use quantum_sim::gates::Gate;
use ndarray::arr2;
use num_complex::Complex;
use num_traits::{One, Zero};

let matrix = arr2(&[[Complex::one(), Complex::zero()],
                    [Complex::zero(), Complex::one()]]);
let identity = Gate::<f64>::new("Identity".to_string(), matrix);

pub fn i() -> Self

Creates an Identity gate (I).

Examples

use quantum_sim::gates::Gate;

let i_gate = Gate::<f64>::i();

pub fn x() -> Self

Creates a Pauli-X gate (NOT gate).

Examples

use quantum_sim::gates::Gate;

let x_gate = Gate::<f64>::x();
assert_eq!(x_gate.name, "X");

pub fn y() -> Self

Creates a Pauli-Y gate.

Examples

use quantum_sim::gates::Gate;

let y_gate = Gate::<f64>::y();
assert_eq!(y_gate.name, "Y");

pub fn z() -> Self

Creates a Pauli-Z gate.

Examples

use quantum_sim::gates::Gate;

let z_gate = Gate::<f64>::z();
assert_eq!(z_gate.name, "Z");

pub fn h() -> Self

Creates a Hadamard gate (H).

The Hadamard gate creates superposition states. Matrix representation:

[1/sqrt(2)  1/sqrt(2)]
[1/sqrt(2) -1/sqrt(2)]

Examples

use quantum_sim::gates::Gate;

let h_gate = Gate::<f64>::h();
assert_eq!(h_gate.name, "H");

pub fn s() -> Self

Creates a Phase gate (S gate).

The Phase gate introduces a π/2 phase shift. Matrix representation:

[1 0]
[0 i]

Examples

use quantum_sim::gates::Gate;

let s_gate = Gate::<f64>::s();
assert_eq!(s_gate.name, "S");

pub fn t() -> Self

Creates a T gate (π/8 gate).

The T gate introduces a π/4 phase shift. Matrix representation:

[1 0]
[0 e^(iπ/4)]

Examples

use quantum_sim::gates::Gate;

let t_gate = Gate::<f64>::t();
assert_eq!(t_gate.name, "T");

pub fn cnot() -> Self

Creates a Controlled-NOT gate (CNOT).

The CNOT gate flips the target qubit if the control qubit is |1⟩. Matrix representation:

[1 0 0 0]
[0 1 0 0]
[0 0 0 1]
[0 0 1 0]

Examples

use quantum_sim::gates::Gate;

let cnot_gate = Gate::<f64>::cnot();
assert_eq!(cnot_gate.name, "CNOT");

Trait Implementations

impl<T: Clone> Clone for Gate<T>

fn clone(&self) -> Gate<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Gate<T>

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

Formats the value using the given formatter.