Struct AdaptiveAlternatingProjectionAuxiliaryState 

pub struct AdaptiveAlternatingProjectionAuxiliaryState {
    pub active_iteration: usize,
    pub current_object_step: f64,
    pub previous_objective: Option<f64>,
    pub objective_sum: f64,
    pub weight_sum: f64,
    pub frames_accumulated: usize,
    pub initial_object_step: f64,
    pub progress_threshold: f64,
    pub reduction_factor: f64,
    pub minimum_object_step: f64,
    pub epsilon: f64,
}

Resumable cycle-level feedback state for adaptive alternating projection.

Objective sums use the same weighted, mask-aware amplitude-MSE convention as the reconstruction trace. Controller parameters are stored so resume cannot silently reinterpret an in-progress feedback cycle.

Fields

active_iteration: usize

Zero-based iteration whose batches are currently accumulated.

current_object_step: f64

Object relaxation used by the active iteration.

previous_objective: Option<f64>

Objective of the pass preceding the active pass, when established.

objective_sum: f64

Frame-weighted objective sum accumulated in the active pass.

weight_sum: f64

Non-negative frame-weight sum accumulated in the active pass.

frames_accumulated: usize

Number of scheduled frames accumulated in the active pass.

initial_object_step: f64

Initial object relaxation that created this controller state.

progress_threshold: f64

Required relative objective decrease that created this state.

reduction_factor: f64

Multiplicative reduction factor that created this state.

minimum_object_step: f64

Positive object-step floor that created this state.

epsilon: f64

Numerical floor used for relative-progress division.

Trait Implementations

impl Clone for AdaptiveAlternatingProjectionAuxiliaryState

fn clone(&self) -> AdaptiveAlternatingProjectionAuxiliaryState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AdaptiveAlternatingProjectionAuxiliaryState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AdaptiveAlternatingProjectionAuxiliaryState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AdaptiveAlternatingProjectionAuxiliaryState

fn eq(&self, other: &AdaptiveAlternatingProjectionAuxiliaryState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AdaptiveAlternatingProjectionAuxiliaryState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AdaptiveAlternatingProjectionAuxiliaryState