added auto-refit

Author: hexqnt

src/app.rs

@@ -669,6 +669,32 @@ impl ActiveOptimizerViewMut<'_> {
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+enum ActiveOptimizerSnapshot {
+    Lbfgs(LbfgsInputState),
+    NelderMead(NelderMeadInputState),
+    SteepestDescent(SteepestDescentInputState),
+    NewtonCg(NewtonCgInputState),
+    Sgd(SgdInputState),
+    Adam(AdamInputState),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+struct RightPanelFitSnapshot {
+    selected_model: ModelChoice,
+    polynomial_degree: usize,
+    parameter_inputs: Vec<String>,
+    spline_knots: usize,
+    spline_knot_strategy: SplineKnotStrategy,
+    spline_extrapolation: SplineExtrapolation,
+    spline_duplicate_x_policy: SplineDuplicateXPolicy,
+    spline_initial_knot_y_inputs: Vec<String>,
+    optimization_loss_metric: OptimizationLossMetric,
+    metric_quantization_enabled: bool,
+    metric_quantization_decimal_places: u8,
+    optimizer: ActiveOptimizerSnapshot,
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 #[derive(Debug)]
 enum FitWorkerMessage {
@@ -760,6 +786,9 @@ pub struct CurveFitApp {
     spline_extrapolation: SplineExtrapolation,
     spline_duplicate_x_policy: SplineDuplicateXPolicy,
     spline_initial_knot_y_inputs: Vec<String>,
+    auto_refit_enabled: bool,
+    auto_refit_pending_rerun: bool,
+    last_right_panel_fit_snapshot: Option<RightPanelFitSnapshot>,
     fit_in_progress: bool,
     fit_loss_metric: OptimizationLossMetric,
     fit_metric_quantization: MetricQuantization,
@@ -876,6 +905,79 @@ impl CurveFitApp {
         self.active_optimizer_view().config()
     }
 
+    fn capture_active_optimizer_snapshot(&self) -> ActiveOptimizerSnapshot {
+        match self.optimizer_method {
+            OptimizerMethod::Lbfgs => ActiveOptimizerSnapshot::Lbfgs(self.lbfgs_inputs.clone()),
+            OptimizerMethod::NelderMead => {
+                ActiveOptimizerSnapshot::NelderMead(self.nelder_mead_inputs.clone())
+            }
+            OptimizerMethod::SteepestDescent => {
+                ActiveOptimizerSnapshot::SteepestDescent(self.steepest_descent_inputs.clone())
+            }
+            OptimizerMethod::NewtonCg => {
+                ActiveOptimizerSnapshot::NewtonCg(self.newton_cg_inputs.clone())
+            }
+            OptimizerMethod::Sgd => ActiveOptimizerSnapshot::Sgd(self.sgd_inputs.clone()),
+            OptimizerMethod::Adam => ActiveOptimizerSnapshot::Adam(self.adam_inputs.clone()),
+        }
+    }
+
+    fn capture_right_panel_fit_snapshot(&self) -> RightPanelFitSnapshot {
+        RightPanelFitSnapshot {
+            selected_model: self.selected_model,
+            polynomial_degree: self.polynomial_degree,
+            parameter_inputs: self.parameter_inputs.clone(),
+            spline_knots: self.spline_knots,
+            spline_knot_strategy: self.spline_knot_strategy,
+            spline_extrapolation: self.spline_extrapolation,
+            spline_duplicate_x_policy: self.spline_duplicate_x_policy,
+            spline_initial_knot_y_inputs: self.spline_initial_knot_y_inputs.clone(),
+            optimization_loss_metric: self.optimization_loss_metric,
+            metric_quantization_enabled: self.metric_quantization_enabled,
+            metric_quantization_decimal_places: self.metric_quantization_decimal_places,
+            optimizer: self.capture_active_optimizer_snapshot(),
+        }
+    }
+
+    fn track_right_panel_fit_changes_and_maybe_refit(&mut self) {
+        let snapshot = self.capture_right_panel_fit_snapshot();
+        let Some(last_snapshot) = self.last_right_panel_fit_snapshot.as_mut() else {
+            self.last_right_panel_fit_snapshot = Some(snapshot);
+            return;
+        };
+
+        if *last_snapshot == snapshot {
+            return;
+        }
+
+        *last_snapshot = snapshot;
+
+        if !self.auto_refit_enabled {
+            return;
+        }
+
+        if self.fit_in_progress {
+            self.auto_refit_pending_rerun = true;
+            return;
+        }
+
+        self.run_fit();
+    }
+
+    fn maybe_run_pending_auto_refit(&mut self) {
+        if !self.auto_refit_enabled {
+            self.auto_refit_pending_rerun = false;
+            return;
+        }
+
+        if !self.auto_refit_pending_rerun || self.fit_in_progress {
+            return;
+        }
+
+        self.auto_refit_pending_rerun = false;
+        self.run_fit();
+    }
+
     fn auto_spline_samples(points_len: usize, knots: usize) -> usize {
         // На больших датасетах используем более плотную дискретизацию,
         // но ограничиваем верхний порог ради отзывчивости UI.
@@ -1384,6 +1486,9 @@ impl Default for CurveFitApp {
             spline_extrapolation: SplineExtrapolation::default(),
             spline_duplicate_x_policy: SplineDuplicateXPolicy::default(),
             spline_initial_knot_y_inputs: Vec::new(),
+            auto_refit_enabled: false,
+            auto_refit_pending_rerun: false,
+            last_right_panel_fit_snapshot: None,
             replay: ReplayState::default(),
             fit_in_progress: false,
             fit_loss_metric: OptimizationLossMetric::default(),
@@ -1419,6 +1524,7 @@ impl eframe::App for CurveFitApp {
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         Self::apply_visual_style(ctx);
         self.poll_fit_worker(ctx);
+        self.maybe_run_pending_auto_refit();
         self.tick_replay(ctx);
         self.poll_points_clipboard_import(ctx);
         self.maybe_refresh_points_cache_after_debounce();
@@ -1529,6 +1635,7 @@ impl eframe::App for CurveFitApp {
                         },
                     );
                 });
+            self.track_right_panel_fit_changes_and_maybe_refit();
         }
 
         self.ui_formula_window(&ctx);

src/app/fit_worker.rs

@@ -634,6 +634,9 @@ impl CurveFitApp {
             return;
         }
 
+        self.last_right_panel_fit_snapshot = Some(self.capture_right_panel_fit_snapshot());
+        self.auto_refit_pending_rerun = false;
+
         let points = match self.parse_points_strict() {
             Ok(points) => points,
             Err(error) => {

src/app/tests.rs

@@ -148,6 +148,9 @@ fn optimization_metric_defaults_to_mse() {
     assert_eq!(app.optimization_loss_metric, OptimizationLossMetric::Mse);
     assert_eq!(app.fit_loss_metric, OptimizationLossMetric::Mse);
     assert!(!app.metric_quantization_enabled);
+    assert!(!app.auto_refit_enabled);
+    assert!(!app.auto_refit_pending_rerun);
+    assert!(app.last_right_panel_fit_snapshot.is_none());
     assert_eq!(
         app.metric_quantization_decimal_places,
         super::DEFAULT_METRIC_QUANTIZATION_DECIMAL_PLACES
@@ -1041,6 +1044,102 @@ fn wait_fit_completion(app: &mut CurveFitApp) {
     panic!("fit did not complete in time");
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn auto_refit_first_snapshot_only_initializes_baseline() {
+    let mut app = make_linear_fit_app();
+    app.auto_refit_enabled = true;
+
+    assert!(app.last_right_panel_fit_snapshot.is_none());
+    app.track_right_panel_fit_changes_and_maybe_refit();
+    assert!(app.last_right_panel_fit_snapshot.is_some());
+    assert!(!app.fit_in_progress);
+    assert!(!app.auto_refit_pending_rerun);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn auto_refit_runs_fit_when_right_panel_settings_change_in_idle() {
+    let mut app = make_linear_fit_app();
+    app.auto_refit_enabled = true;
+    app.track_right_panel_fit_changes_and_maybe_refit();
+
+    app.optimization_loss_metric = OptimizationLossMetric::Mae;
+    app.track_right_panel_fit_changes_and_maybe_refit();
+
+    assert!(app.fit_in_progress);
+    wait_fit_completion(&mut app);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn auto_refit_queues_rerun_when_settings_change_during_fit() {
+    let mut app = make_linear_fit_app();
+    app.auto_refit_enabled = true;
+    app.track_right_panel_fit_changes_and_maybe_refit();
+    app.run_fit();
+    assert!(app.fit_in_progress);
+
+    app.metric_quantization_enabled = true;
+    app.metric_quantization_decimal_places = 2;
+    app.track_right_panel_fit_changes_and_maybe_refit();
+
+    assert!(app.fit_in_progress);
+    assert!(app.auto_refit_pending_rerun);
+    assert!(!matches!(app.status, Some(StatusMessage::FittingStopping)));
+    wait_fit_completion(&mut app);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn auto_refit_pending_rerun_starts_after_fit_transitions_to_idle() {
+    let mut app = make_linear_fit_app();
+    app.auto_refit_enabled = true;
+    app.track_right_panel_fit_changes_and_maybe_refit();
+    app.run_fit();
+    assert!(app.fit_in_progress);
+
+    app.parameter_inputs[0] = "0.1".to_string();
+    app.track_right_panel_fit_changes_and_maybe_refit();
+    assert!(app.auto_refit_pending_rerun);
+
+    wait_fit_completion(&mut app);
+    assert!(!app.fit_in_progress);
+    assert!(app.auto_refit_pending_rerun);
+
+    app.maybe_run_pending_auto_refit();
+    assert!(app.fit_in_progress);
+    assert!(!app.auto_refit_pending_rerun);
+    wait_fit_completion(&mut app);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn disabling_auto_refit_clears_pending_rerun_without_starting_fit() {
+    let mut app = make_linear_fit_app();
+    app.auto_refit_enabled = true;
+    app.auto_refit_pending_rerun = true;
+
+    app.auto_refit_enabled = false;
+    app.maybe_run_pending_auto_refit();
+
+    assert!(!app.auto_refit_pending_rerun);
+    assert!(!app.fit_in_progress);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn run_fit_clears_pending_auto_refit_rerun_flag() {
+    let mut app = make_linear_fit_app();
+    app.auto_refit_pending_rerun = true;
+
+    app.run_fit();
+
+    assert!(app.fit_in_progress);
+    assert!(!app.auto_refit_pending_rerun);
+    wait_fit_completion(&mut app);
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 #[test]
 fn run_fit_snapshots_metric_quantization_at_start() {

src/app/ui/optimizer_panel.rs

@@ -376,7 +376,7 @@ pub(super) fn ui_optimizer(app: &mut CurveFitApp, ui: &mut egui::Ui) {
     }
 
     ui.separator();
-    ui_fit_action_button(app, ui, false);
+    ui_fit_action_button(app, ui, false, true);
     if app.fit_in_progress
         && let Some(iteration) = app.fit_preview_iteration
     {
@@ -388,10 +388,15 @@ pub(super) fn ui_optimizer(app: &mut CurveFitApp, ui: &mut egui::Ui) {
 }
 
 pub(super) fn ui_optimizer_action_button_compact(app: &mut CurveFitApp, ui: &mut egui::Ui) {
-    ui_fit_action_button(app, ui, true);
+    ui_fit_action_button(app, ui, true, false);
 }
 
-fn ui_fit_action_button(app: &mut CurveFitApp, ui: &mut egui::Ui, compact: bool) {
+fn ui_fit_action_button(
+    app: &mut CurveFitApp,
+    ui: &mut egui::Ui,
+    compact: bool,
+    show_auto_refit_toggle: bool,
+) {
     let (fill, stroke, text_color) = CurveFitApp::action_button_style(ui, app.fit_in_progress);
     let (icon, text) = if app.fit_in_progress {
         (
@@ -405,24 +410,40 @@ fn ui_fit_action_button(app: &mut CurveFitApp, ui: &mut egui::Ui, compact: bool)
         )
     };
 
-    let min_size = if compact {
-        egui::vec2(COMPACT_FIT_BUTTON_WIDTH, COMPACT_FIT_BUTTON_HEIGHT)
-    } else {
-        egui::vec2(ui.available_width(), FULL_FIT_BUTTON_HEIGHT)
-    };
-    let action_button =
-        egui::Button::image_and_text(icon, egui::RichText::new(text).strong().color(text_color))
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if show_auto_refit_toggle {
+                let auto_refit_response = CurveFitApp::toggle_switch_labeled(
+                    ui,
+                    &mut app.auto_refit_enabled,
+                    tr(app.ui_language, "Auto-refit", "Авто-рефит"),
+                );
+                let _ =
+                    CurveFitApp::info_hover(auto_refit_response, auto_refit_hint(app.ui_language));
+            }
+
+            let min_size = if compact {
+                egui::vec2(COMPACT_FIT_BUTTON_WIDTH, COMPACT_FIT_BUTTON_HEIGHT)
+            } else {
+                egui::vec2(ui.available_width(), FULL_FIT_BUTTON_HEIGHT)
+            };
+            let action_button = egui::Button::image_and_text(
+                icon,
+                egui::RichText::new(text).strong().color(text_color),
+            )
             .min_size(min_size)
             .fill(fill)
             .stroke(stroke)
             .corner_radius(egui::CornerRadius::same(UI_CORNER_RADIUS + 1));
-    if ui.add(action_button).clicked() {
-        if app.fit_in_progress {
-            app.request_stop_fit();
-        } else {
-            app.run_fit();
-        }
-    }
+            if ui.add(action_button).clicked() {
+                if app.fit_in_progress {
+                    app.request_stop_fit();
+                } else {
+                    app.run_fit();
+                }
+            }
+        });
+    });
 }
 
 fn optimizer_mode_hint(language: UiLanguage, mode: OptimizerUiMode) -> &'static str {
@@ -439,3 +460,11 @@ fn optimizer_mode_hint(language: UiLanguage, mode: OptimizerUiMode) -> &'static
         ),
     }
 }
+
+fn auto_refit_hint(language: UiLanguage) -> &'static str {
+    tr(
+        language,
+        "Auto-refit\n- Re-runs fit when right-panel fit settings change\n- If fit is already running, one rerun is queued after completion\n- Applies to model/initial parameters, optimization metric, and optimizer settings",
+        "Авто-рефит\n- Повторно запускает фит при изменении fit-настроек в правой панели\n- Если фит уже выполняется, один перезапуск ставится в очередь после завершения\n- Применяется к модели/начальным параметрам, метрике оптимизации и настройкам оптимизатора",
+    )
+}