Struct TQMultiPhaseEncoder 

pub struct TQMultiPhaseEncoder {
    pub funcs: Vec<String>,
    pub wires: Option<Vec<usize>>,
    /* private fields */
}

Multi-phase encoder - applies multiple rotation gates to each qubit Each feature is encoded with a sequence of gates (e.g., RX, RY, RZ)

Fields

funcs: Vec<String>

Gate functions to apply (e.g., [“rx”, “ry”, “rz”])

wires: Option<Vec<usize>>

Wire mapping (if None, uses wires 0, 1, 2, …)

Implementations

impl TQMultiPhaseEncoder

pub fn new(funcs: Vec<&str>) -> Self

pub fn with_wires(funcs: Vec<&str>, wires: Vec<usize>) -> Self

Create with specific wire mapping

pub fn rxyz() -> Self

Create RX, RY, RZ encoder

pub fn ryrz() -> Self

Create RY, RZ encoder (common for VQE)

Trait Implementations

impl Clone for TQMultiPhaseEncoder

fn clone(&self) -> TQMultiPhaseEncoder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TQMultiPhaseEncoder

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

Formats the value using the given formatter.

impl TQEncoder for TQMultiPhaseEncoder

fn encode(&mut self, qdev: &mut TQDevice, x: &Array2<f64>) -> Result<()>

Encode classical data into quantum state

impl TQModule for TQMultiPhaseEncoder

fn forward(&mut self, _qdev: &mut TQDevice) -> Result<()>

Execute the forward pass on the quantum device

fn forward_with_input( &mut self, qdev: &mut TQDevice, x: Option<&Array2<f64>>, ) -> Result<()>

Execute forward pass with optional input data (for encoders)

fn parameters(&self) -> Vec<TQParameter>

Get all trainable parameters

fn n_wires(&self) -> Option<usize>

Get number of wires this module operates on

fn set_n_wires(&mut self, n_wires: usize)

Set number of wires

fn is_static_mode(&self) -> bool

Check if module is in static mode

fn static_on(&mut self)

Enable static mode for graph optimization

fn static_off(&mut self)

Disable static mode

fn name(&self) -> &str

Module name for debugging

fn get_unitary(&self) -> Option<Array2<CType>>

Get the unitary matrix representation (if available)

fn zero_grad(&mut self)

Zero gradients of all parameters

fn train(&mut self, _mode: bool)

Set training mode

fn training(&self) -> bool

Check if in training mode