Refactor IronsTuckGrand for cleaner control flow

- Add finalize_output() to consolidate coefficient copy and return
- Add project_and_check() to combine projection with convergence check
- Remove conv_len parameter from methods; compute via projector internally
- Use local bindings for convergence state to avoid repetition
- Align method signatures to consistently take projector first
- Rename acceleration_step to acceleration_step_check

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: schroedk

src/demean_accelerated/accelerator.rs

@@ -154,62 +154,66 @@ impl IronsTuckGrand {
             projector.coef_len()
         );
 
-        let conv_len = projector.convergence_len();
-
         // Initial projection and convergence check
-        projector.project(coef, &mut self.buffers.gx);
-        if self.check_coef_convergence(coef, conv_len) == ConvergenceState::Converged {
-            coef.copy_from_slice(&self.buffers.gx);
-            return (0, ConvergenceState::Converged);
+        let conv = self.project_and_check(projector, coef);
+        if conv == ConvergenceState::Converged {
+            return self.finalize_output(coef, 0, conv);
         }
 
         let mut grand_phase = GrandPhase::default();
         let mut ssr = 0.0;
 
         for iter in 1..=max_iter {
             // Core acceleration step
-            if self.acceleration_step(projector, coef, conv_len, iter) == ConvergenceState::Converged
-            {
-                coef.copy_from_slice(&self.buffers.gx);
-                return (iter, ConvergenceState::Converged);
+            let conv = self.acceleration_step_check(projector, coef, iter);
+            if conv == ConvergenceState::Converged {
+                return self.finalize_output(coef, iter, conv);
             }
 
             // Grand acceleration (every iter_grand_acc iterations)
             if iter % self.config.iter_grand_acc == 0 {
-                if self.grand_acceleration_check(&mut grand_phase, projector, conv_len)
-                    == ConvergenceState::Converged
-                {
-                    coef.copy_from_slice(&self.buffers.gx);
-                    return (iter, ConvergenceState::Converged);
+                let conv = self.grand_acceleration_check(projector, &mut grand_phase);
+                if conv == ConvergenceState::Converged {
+                    return self.finalize_output(coef, iter, conv);
                 }
             }
 
             // SSR convergence check (every ssr_check_interval iterations)
             if iter % self.config.ssr_check_interval == 0 {
-                if self.ssr_convergence_check(projector, iter, &mut ssr)
-                    == ConvergenceState::Converged
-                {
-                    coef.copy_from_slice(&self.buffers.gx);
-                    return (iter, ConvergenceState::Converged);
+                let conv = self.ssr_convergence_check(projector, iter, &mut ssr);
+                if conv == ConvergenceState::Converged {
+                    return self.finalize_output(coef, iter, conv);
                 }
             }
         }
+        self.finalize_output(coef, max_iter, ConvergenceState::NotConverged)
+    }
 
+    /// Copy converged coefficients to the output buffer.
+    ///
+    /// This method should be called after `run()` has completed to retrieve
+    /// the final coefficients from the internal `gx` buffer.
+    #[inline]
+    fn finalize_output(&self, coef: &mut [f64],
+                           iter: usize,
+                           convergence: ConvergenceState,) -> (usize, ConvergenceState) {
         coef.copy_from_slice(&self.buffers.gx);
-        (max_iter, ConvergenceState::NotConverged)
+        (iter, convergence)
+
     }
 
     /// Perform the core Irons-Tuck acceleration step.
     ///
     /// Returns `Converged` if convergence detected, `NotConverged` to continue.
     #[inline]
-    fn acceleration_step<P: Projector>(
+    fn acceleration_step_check<P: Projector>(
         &mut self,
         projector: &mut P,
         coef: &mut [f64],
-        conv_len: usize,
         iter: usize,
     ) -> ConvergenceState {
+        let conv_len = projector.convergence_len();
+
         // Double projection for Irons-Tuck: G(G(x))
         projector.project(&self.buffers.gx, &mut self.buffers.ggx);
 
@@ -230,19 +234,17 @@ impl IronsTuckGrand {
         }
 
         // Update gx and check coefficient convergence
-        projector.project(coef, &mut self.buffers.gx);
-        self.check_coef_convergence(coef, conv_len)
+        self.project_and_check(projector, coef)
     }
 
     /// Perform grand acceleration and check for convergence.
     #[inline]
     fn grand_acceleration_check<P: Projector>(
         &mut self,
-        grand_phase: &mut GrandPhase,
         projector: &mut P,
-        conv_len: usize,
+        grand_phase: &mut GrandPhase,
     ) -> ConvergenceState {
-        match self.grand_acceleration_step(*grand_phase, projector, conv_len) {
+        match self.grand_acceleration_step(projector, *grand_phase) {
             GrandStepResult::Continue(next) => {
                 *grand_phase = next;
                 ConvergenceState::NotConverged
@@ -270,9 +272,15 @@ impl IronsTuckGrand {
         }
     }
 
-    /// Check if coefficients have converged.
+    /// Project coefficients and check for convergence.
     #[inline]
-    fn check_coef_convergence(&self, coef: &[f64], conv_len: usize) -> ConvergenceState {
+    fn project_and_check<P: Projector>(
+        &mut self,
+        projector: &mut P,
+        coef: &[f64],
+    ) -> ConvergenceState {
+        projector.project(coef, &mut self.buffers.gx);
+        let conv_len = projector.convergence_len();
         if Self::should_continue(
             &coef[..conv_len],
             &self.buffers.gx[..conv_len],
@@ -340,10 +348,10 @@ impl IronsTuckGrand {
     #[inline]
     fn grand_acceleration_step<P: Projector>(
         &mut self,
-        phase: GrandPhase,
         projector: &mut P,
-        conv_len: usize,
+        phase: GrandPhase,
     ) -> GrandStepResult {
+        let conv_len = projector.convergence_len();
         match phase {
             GrandPhase::Collect1st => {
                 self.buffers.y[..conv_len].copy_from_slice(&self.buffers.gx[..conv_len]);