Struct CBatchExecution 

#[repr(C)]
pub struct CBatchExecution {
    pub sample: fn(gates_json: *const c_char, qubits_to_sample: *const usize, qubits_to_sample_len: usize, shots: usize, sample_json: &mut *const c_char) -> i32,
    pub exp_value: fn(gates_json: *const c_char, hamiltonian_list_json: *const c_char, result: *mut f64) -> i32,
    pub sample_native: fn(gates_json: *const c_char, qubits_to_sample: *const usize, qubits_to_sample_len: usize, shots: usize, sample_json: &mut *const c_char) -> i32,
    pub exp_value_native: fn(gates_json: *const c_char, hamiltonian_list_json: *const c_char, result: *mut f64) -> i32,
    pub gradient: fn(gates_json: *const c_char, hamiltonian_list_json: *const c_char, exp_result: &mut f64, grad_json: &mut *const c_char) -> i32,
}

FFI-compatible function-pointer table for a batch execution backend.

In batch mode the entire compiled circuit is serialized and handed to the backend in a single call when ket_process_execute is invoked, rather than dispatching gate-by-gate.

Construct a CBatchExecution value on the C side, fill in all function pointers, then call ket_quantum_execution_batch to create the corresponding QuantumExecution variant.

All callbacks must return 0 on success or a non-zero libket error code on failure.

Fields

sample: fn(gates_json: *const c_char, qubits_to_sample: *const usize, qubits_to_sample_len: usize, shots: usize, sample_json: &mut *const c_char) -> i32

exp_value: fn(gates_json: *const c_char, hamiltonian_list_json: *const c_char, result: *mut f64) -> i32

sample_native: fn(gates_json: *const c_char, qubits_to_sample: *const usize, qubits_to_sample_len: usize, shots: usize, sample_json: &mut *const c_char) -> i32

exp_value_native: fn(gates_json: *const c_char, hamiltonian_list_json: *const c_char, result: *mut f64) -> i32

gradient: fn(gates_json: *const c_char, hamiltonian_list_json: *const c_char, exp_result: &mut f64, grad_json: &mut *const c_char) -> i32

Trait Implementations

impl BatchExecution for CBatchExecution

fn sample( &self, gates: &[GateInstruction], qubits_to_sample: &[usize], shots: usize, ) -> Result<SampleData, KetError>

Executes gates and samples the state of qubits_to_sample over shots shots, receiving gates in the Libket IR format.

fn exp_value( &self, gates: &[GateInstruction], hamiltonian_list: &[Hamiltonian], ) -> Result<Vec<f64>, KetError>

Executes gates and computes the expectation value of each Hamiltonian in hamiltonian_list, receiving gates in the Libket IR format.

fn sample_native( &self, gates: &[NativeGate], qubits_to_sample: &[usize], shots: usize, ) -> Result<SampleData, KetError>

Executes gates and samples the state of qubits_to_sample over shots shots, receiving pre-translated native gates.

fn exp_value_native( &self, gates: &[NativeGate], hamiltonian_list: &[Hamiltonian], ) -> Result<Vec<f64>, KetError>

Executes gates and computes the expectation value of each Hamiltonian in hamiltonian_list, receiving pre-translated native gates.

fn gradient( &self, gates: &[GateInstruction], hamiltonian: &Hamiltonian, ) -> Result<(f64, Vec<f64>), KetError>

Computes the expectation value and its gradient with respect to all circuit parameters in a single backend call.

impl Clone for CBatchExecution

fn clone(&self) -> CBatchExecution

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CBatchExecution

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

Formats the value using the given formatter.