Struct GaussianState 

pub struct GaussianState {
    pub num_modes: usize,
    pub mean_vector: Vec<f64>,
    pub covariancematrix: Vec<Vec<f64>>,
    /* private fields */
}

Gaussian state representation using covariance matrix formalism

Fields

num_modes: usize

Number of modes

mean_vector: Vec<f64>

Mean vector (displacement amplitudes) - [x1, p1, x2, p2, …]

covariancematrix: Vec<Vec<f64>>

Covariance matrix (2N x 2N where N is number of modes)

Implementations

impl GaussianState

pub fn vacuum_state(num_modes: usize) -> Self

Create vacuum state for N modes

pub fn coherent_state( num_modes: usize, displacements: Vec<Complex>, ) -> DeviceResult<Self>

Create coherent state with given displacement

pub fn squeezed_vacuum_state( num_modes: usize, squeezing_params: Vec<f64>, squeezing_phases: Vec<f64>, ) -> DeviceResult<Self>

Create squeezed vacuum state

pub fn apply_displacement( &mut self, mode: usize, displacement: Complex, ) -> DeviceResult<()>

Apply displacement operation to a mode

pub fn apply_squeezing( &mut self, mode: usize, r: f64, phi: f64, ) -> DeviceResult<()>

Apply squeezing operation to a mode

pub fn apply_two_mode_squeezing( &mut self, mode1: usize, mode2: usize, r: f64, phi: f64, ) -> DeviceResult<()>

Apply two-mode squeezing operation

pub fn apply_beamsplitter( &mut self, mode1: usize, mode2: usize, transmittance: f64, phase: f64, ) -> DeviceResult<()>

Apply beamsplitter operation

pub fn apply_phase_rotation( &mut self, mode: usize, phi: f64, ) -> DeviceResult<()>

Apply phase rotation

pub fn homodyne_measurement( &mut self, mode: usize, phase: f64, config: &CVDeviceConfig, ) -> DeviceResult<f64>

Perform homodyne measurement

pub fn heterodyne_measurement( &mut self, mode: usize, config: &CVDeviceConfig, ) -> DeviceResult<Complex>

Perform heterodyne measurement

pub fn condition_on_homodyne_measurement( &mut self, mode: usize, phase: f64, result: f64, ) -> DeviceResult<()>

Condition state on homodyne measurement result

pub fn condition_on_heterodyne_measurement( &mut self, mode: usize, _result: Complex, ) -> DeviceResult<()>

Condition state on heterodyne measurement result

pub fn reset_mode_to_vacuum(&mut self, mode: usize) -> DeviceResult<()>

Reset a mode to vacuum state

pub fn get_mode_state(&self, mode: usize) -> DeviceResult<CVModeState>

Get mode state information

pub fn calculate_average_squeezing(&self) -> f64

Calculate average squeezing across all modes

pub fn calculate_purity(&self) -> f64

Calculate system purity

pub fn calculate_entanglement_entropy(&self) -> f64

Calculate entanglement entropy

pub fn calculate_entanglement_measures(&self) -> CVEntanglementMeasures

Calculate entanglement measures

Trait Implementations

impl Clone for GaussianState

fn clone(&self) -> GaussianState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GaussianState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GaussianState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GaussianState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.