Struct EdModel 

pub struct EdModel<B> { /* private fields */ }

One owned basis and operator specification reusable across frontend calls.

Implementations

impl<B> EdModel<B>

where B: Basis + Clone, B::State: Hash + Ord + 'static,

pub fn new( basis: impl Into<B>, terms: impl IntoIterator<Item = OperatorSpec>, ) -> Self

pub fn with_checks(self, checks: AssemblyChecks) -> Self

pub fn with_components( self, components: impl IntoIterator<Item = PackedTermComponent>, ) -> Result<Self>

Add named local-term components to this basis-owned model.

Names and defaults are validated before any operator assembly. The components may be non-Hermitian individually; Hermiticity is checked after evaluating a concrete parameter set.

pub fn with_site_permutation(self, permutation: &[usize]) -> Result<Self>

pub const fn basis(&self) -> &B

pub fn terms(&self) -> &[OperatorSpec]

pub fn components(&self) -> &[PackedTermComponent]

pub fn component_names(&self) -> impl Iterator<Item = &str>

pub fn dimension(&self) -> usize

pub fn states(&self) -> Result<Vec<B::State>>

pub fn scatter_state_vector( &self, values: &[Complex64], full_dimension: usize, ) -> Result<Vec<Complex64>>

where usize: TryFrom<B::State>,

Scatter a basis-ordered vector into packed-state index order.

Explicit tensor-product parents may expose a frontend-compatible row ordering rather than ascending packed states. Subsystem kernels use the packed state itself as the mixed-radix row index, so this method makes that conversion explicit and reusable.

pub fn scatter_density( &self, values: &[Complex64], full_dimension: usize, ) -> Result<Vec<Complex64>>

where usize: TryFrom<B::State>,

Scatter both axes of a row-major density matrix by packed state.

pub fn reduction_images( &self, states: &[B::State], ) -> Result<Vec<Option<ReductionImage<B::State>>>>

Query canonical representatives and normalized orbit coefficients.

This works for both explicit and symmetry-reduced bases and does not materialize an operator or projector.

pub fn projector_to(&self, parent: &Self) -> Result<BasisProjector>

Build the sparse isometry from this model’s basis into an explicit parent model’s basis.

The parent is deliberately explicit: frontends may choose either a particle-conserving parent or the unrestricted physical Hilbert space without encoding either policy in the Rust core.

pub fn embedding_to(&self, parent: &Self) -> Result<BasisProjector>

Build a one-hot embedding when this basis is an explicitly selected subset of a parent that uses the same physical state identifiers.

Unlike PackedEdModel::projector_to, this does not apply symmetry orbit amplitudes. Frontends use it for filters such as a fixed total excitation inside an otherwise identical product basis.

pub fn lift_to_batch( &self, parent: &Self, vectors: &[Vec<Complex64>], ) -> Result<Vec<Vec<Complex64>>>

Lift a batch of reduced-space vectors into an explicit parent model.

pub fn project_from_batch( &self, parent: &Self, vectors: &[Vec<Complex64>], ) -> Result<Vec<Vec<Complex64>>>

Project a batch of parent-space vectors into this model’s basis.

pub fn apply_terms_from_batch( &self, source: &Self, terms: impl IntoIterator<Item = OperatorSpec>, inputs: &[Vec<Complex64>], ) -> Result<Vec<Vec<Complex64>>>

Apply temporary terms directly from a source model into this target model without materializing either physical parent space.

pub fn apply_terms_between_subspaces_batch( source: &Self, source_projector: Option<&BasisProjector>, target: &Self, target_projector: Option<&BasisProjector>, terms: impl IntoIterator<Item = OperatorSpec>, inputs: &[Vec<Complex64>], ) -> Result<Vec<Vec<Complex64>>>

Apply temporary local terms between arbitrary isometric subspaces.

source and target own the physical local algebras. Optional projectors describe reduced coordinates inside those explicit parent bases. Omitting a projector selects the entire corresponding parent basis, so this one operation covers ordinary sector shifts, reduced-to-full, full-to-reduced, and reduced-to-reduced actions:

output = P_target† O P_source input.

The local operator is streamed through PackedEdModel::apply_terms_from_batch; neither a square parent-space operator nor a dense projector product is materialized.

pub fn materialized(&self, format: MatrixFormat) -> Result<Arc<Operator>>

Return the assembled operator shared by all calls using this model.

Assembly is performed at most once per storage format. Clones of an unchanged model share the same cache; model-transforming builders reset it before changing checks or site labels.

pub fn materialize(&self, format: MatrixFormat) -> Result<Operator>

Materialize an owned operator for callers that do not need reuse.

pub fn materialize_with( &self, parameters: &HashMap<String, Complex64>, format: MatrixFormat, ) -> Result<Operator>

Evaluate this basis-owned fixed/parameterized operator family.

pub fn assemble_terms( &self, terms: impl IntoIterator<Item = OperatorSpec>, checks: AssemblyChecks, format: MatrixFormat, ) -> Result<Operator>

Assemble caller-supplied terms on this model’s already-owned basis.

This is the native narrow waist for low-level basis operations. The terms use the model’s original site convention and are relabeled by the same permutation as its persistent terms.

pub fn apply_terms_batch( &self, terms: impl IntoIterator<Item = OperatorSpec>, inputs: &[Vec<Complex64>], action: OperatorAction, ) -> Result<Vec<Vec<Complex64>>>

Apply one temporary operator to a batch of column vectors.

The operator is assembled once for the whole batch and never converted to a dense matrix.

pub fn apply_batch( &self, inputs: &[Vec<Complex64>], action: OperatorAction, ) -> Result<Vec<Vec<Complex64>>>

Apply the model’s persistent terms without dense materialization.

The matrix-free representation is cached after the first call and reused by subsequent vectors and algebraic views.

pub fn apply_batch_with( &self, parameters: &HashMap<String, Complex64>, inputs: &[Vec<Complex64>], action: OperatorAction, ) -> Result<Vec<Vec<Complex64>>>

Apply one evaluated member of this basis-owned operator family.

pub fn bra_ket_terms( &self, terms: impl IntoIterator<Item = OperatorSpec>, kets: &[B::State], ) -> Result<Vec<Vec<BraKetTransition<B::State>>>>

Return raw local transitions grouped by input ket.

Unlike square operator assembly, this operation intentionally does not reduce destination states into the model’s symmetry sector.

pub fn eigh(&self, options: EighOptions) -> Result<Eigensystem>

pub fn eigh_with( &self, parameters: &HashMap<String, Complex64>, options: EighOptions, ) -> Result<Eigensystem>

pub fn eigsh( &self, format: MatrixFormat, options: EigshOptions, ) -> Result<Eigensystem>

pub fn eigsh_with( &self, parameters: &HashMap<String, Complex64>, format: MatrixFormat, options: EigshOptions, ) -> Result<Eigensystem>

pub fn eigsh_with_initial( &self, format: MatrixFormat, options: EigshOptions, initial: &[Complex64], ) -> Result<Eigensystem>

pub fn eigsh_with_initial_and_parameters( &self, parameters: &HashMap<String, Complex64>, format: MatrixFormat, options: EigshOptions, initial: &[Complex64], ) -> Result<Eigensystem>

pub fn evolve_batch( &self, initial_columns: &[Vec<Complex64>], options: EvolutionOptions, ) -> Result<StateBatchTrajectory>

Evolve independent state columns under this model’s static Hamiltonian.

The matrix-free operator is cached and shared with normal operator applications. Numerical evolution remains a Rust-core capability; the language bindings only convert arrays and time grids.

pub fn evolve_batch_with( &self, parameters: &HashMap<String, Complex64>, initial_columns: &[Vec<Complex64>], options: EvolutionOptions, ) -> Result<StateBatchTrajectory>

pub fn operator_model( &self, format: MatrixFormat, ) -> Result<PackedOperatorModel>

Convert this basis-owned model into a basis-independent operator family without losing named components or their defaults.

pub fn evolve_time_dependent_batch<F>( &self, initial_columns: &[Vec<Complex64>], initial_time: f64, options: EvolutionOptions, coefficients_at: F, ) -> Result<StateBatchTrajectory>

where F: Fn(f64, &mut [Complex64]) -> Result<()> + Send + Sync + 'static,

Evolve this basis-owned parameterized family with coefficients supplied at the integrator’s internal physical times.

pub fn evolve_time_dependent_batch_scaled<F>( &self, initial_columns: &[Vec<Complex64>], initial_time: f64, options: EvolutionOptions, operator_scale: Complex64, coefficients_at: F, ) -> Result<StateBatchTrajectory>

where F: Fn(f64, &mut [Complex64]) -> Result<()> + Send + Sync + 'static,

Trait Implementations

impl<B: Clone> Clone for EdModel<B>

fn clone(&self) -> EdModel<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug> Debug for EdModel<B>

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

Formats the value using the given formatter.