added Gompertz

Author: hexqnt

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "curve-fit"
-version = "0.1.5"
+version = "0.1.6"
 edition = "2024"
 authors = ["hexqnt <hexqntlab@gmail.com>"]
 license = "Apache-2.0 OR MIT"

Cargo.toml

@@ -210,6 +210,7 @@ enum ModelChoice {
     Arrhenius,
     Inverse,
     Logistic,
+    Gompertz,
     Lorentzian,
     NaturalLog,
     FourPl,
@@ -231,11 +232,12 @@ enum ModelChoice {
 }
 
 impl ModelChoice {
-    const ALL: [Self; 22] = [
+    const ALL: [Self; 23] = [
         Self::Polynomial,
         Self::Arrhenius,
         Self::Inverse,
         Self::Logistic,
+        Self::Gompertz,
         Self::Lorentzian,
         Self::NaturalLog,
         Self::FourPl,
@@ -277,6 +279,7 @@ impl ResolvedModel {
             ModelChoice::Arrhenius => Self::Parametric(CurveFamily::Arrhenius),
             ModelChoice::Inverse => Self::Parametric(CurveFamily::Inverse),
             ModelChoice::Logistic => Self::Parametric(CurveFamily::Logistic),
+            ModelChoice::Gompertz => Self::Parametric(CurveFamily::Gompertz),
             ModelChoice::Lorentzian => Self::Parametric(CurveFamily::Lorentzian),
             ModelChoice::NaturalLog => Self::Parametric(CurveFamily::NaturalLog),
             ModelChoice::FourPl => Self::Parametric(CurveFamily::FourPl),
@@ -351,6 +354,7 @@ fn model_group(model: ModelChoice) -> ModelGroup {
     match model {
         ModelChoice::Polynomial => ModelGroup::Polynomial,
         ModelChoice::Logistic
+        | ModelChoice::Gompertz
         | ModelChoice::FourPl
         | ModelChoice::FivePl
         | ModelChoice::HyperbolicTangent

src/app.rs

@@ -10,6 +10,7 @@ fn model_formula_full(model: ModelChoice, polynomial_degree: usize) -> String {
         ModelChoice::Arrhenius => r"y = A·exp(\frac{B}{x})".to_string(),
         ModelChoice::Inverse => r"y = A + \frac{B}{x}".to_string(),
         ModelChoice::Logistic => r"y = \frac{A}{1 + exp(-B·(x - C))}".to_string(),
+        ModelChoice::Gompertz => r"y = A·exp(-exp(-B·(x - C)))".to_string(),
         ModelChoice::Lorentzian => r"y = C + \frac{A}{1 + (\frac{x - x_0}{gamma})^{2}}".to_string(),
         ModelChoice::NaturalLog => r"y = A·ln(\frac{x}{B})".to_string(),
         ModelChoice::FourPl => r"y = d + \frac{a - d}{1 + (\frac{x}{c})^{b}}".to_string(),
@@ -106,6 +107,9 @@ fn model_ml_note(language: UiLanguage, model: ModelChoice) -> &'static str {
         (UiLanguage::English, ModelChoice::Logistic) => {
             "Sigmoid response model for bounded transitions."
         }
+        (UiLanguage::English, ModelChoice::Gompertz) => {
+            "Asymmetric sigmoid growth model with a long lower tail."
+        }
         (UiLanguage::English, ModelChoice::Lorentzian) => "Peak-shaped model with heavy tails.",
         (UiLanguage::English, ModelChoice::NaturalLog) => {
             "Log transform response, useful for diminishing returns."
@@ -147,6 +151,9 @@ fn model_ml_note(language: UiLanguage, model: ModelChoice) -> &'static str {
         (UiLanguage::Russian, ModelChoice::Logistic) => {
             "Сигмоидальная модель ограниченного перехода."
         }
+        (UiLanguage::Russian, ModelChoice::Gompertz) => {
+            "Асимметричная сигмоида с длинным нижним хвостом."
+        }
         (UiLanguage::Russian, ModelChoice::Lorentzian) => {
             "Пиковая модель с более тяжёлыми хвостами."
         }

src/app/formula.rs

@@ -190,17 +190,17 @@ pub(super) fn param_init_method_disabled_label(
 ) -> &'static str {
     match (language, method) {
         (UiLanguage::English, ParamInitMethod::DataBased) => {
-            "Data-based (Polynomial/Logistic/Gaussian/Exponential (Basic)/Power only)"
+            "Data-based (Polynomial/Logistic/Gompertz/Gaussian/Exponential (Basic)/Power only)"
         }
         (UiLanguage::English, ParamInitMethod::Randomized) => {
-            "Randomized (Polynomial/Logistic/Gaussian/Exponential (Basic)/Power only)"
+            "Randomized (Polynomial/Logistic/Gompertz/Gaussian/Exponential (Basic)/Power only)"
         }
         (UiLanguage::English, ParamInitMethod::Default) => "Default",
         (UiLanguage::Russian, ParamInitMethod::DataBased) => {
-            "По данным (только Polynomial/Logistic/Gaussian/Exponential (Basic)/Power)"
+            "По данным (только Polynomial/Logistic/Gompertz/Gaussian/Exponential (Basic)/Power)"
         }
         (UiLanguage::Russian, ParamInitMethod::Randomized) => {
-            "Случайно (только Polynomial/Logistic/Gaussian/Exponential (Basic)/Power)"
+            "Случайно (только Polynomial/Logistic/Gompertz/Gaussian/Exponential (Basic)/Power)"
         }
         (UiLanguage::Russian, ParamInitMethod::Default) => "По умолчанию",
     }
@@ -212,6 +212,7 @@ pub(super) fn model_choice_label(language: UiLanguage, model: ModelChoice) -> &'
         (UiLanguage::English, ModelChoice::Arrhenius) => "Arrhenius",
         (UiLanguage::English, ModelChoice::Inverse) => "Inverse",
         (UiLanguage::English, ModelChoice::Logistic) => "Logistic",
+        (UiLanguage::English, ModelChoice::Gompertz) => "Gompertz",
         (UiLanguage::English, ModelChoice::Lorentzian) => "Lorentzian",
         (UiLanguage::English, ModelChoice::NaturalLog) => "Natural Log",
         (UiLanguage::English, ModelChoice::FourPl) => "4PL",
@@ -234,6 +235,7 @@ pub(super) fn model_choice_label(language: UiLanguage, model: ModelChoice) -> &'
         (UiLanguage::Russian, ModelChoice::Arrhenius) => "Аррениус",
         (UiLanguage::Russian, ModelChoice::Inverse) => "Обратная",
         (UiLanguage::Russian, ModelChoice::Logistic) => "Логистическая",
+        (UiLanguage::Russian, ModelChoice::Gompertz) => "Гомпертц",
         (UiLanguage::Russian, ModelChoice::Lorentzian) => "Лоренциан",
         (UiLanguage::Russian, ModelChoice::NaturalLog) => "Натуральный логарифм",
         (UiLanguage::Russian, ModelChoice::FourPl) => "4PL",
@@ -269,6 +271,7 @@ pub(super) fn family_label(language: UiLanguage, family: CurveFamily) -> &'stati
         (UiLanguage::English, CurveFamily::Arrhenius) => "Arrhenius",
         (UiLanguage::English, CurveFamily::Inverse) => "Inverse",
         (UiLanguage::English, CurveFamily::Logistic) => "Logistic",
+        (UiLanguage::English, CurveFamily::Gompertz) => "Gompertz",
         (UiLanguage::English, CurveFamily::Lorentzian) => "Lorentzian",
         (UiLanguage::English, CurveFamily::NaturalLog) => "Natural Log",
         (UiLanguage::English, CurveFamily::FourPl) => "4PL",
@@ -295,6 +298,7 @@ pub(super) fn family_label(language: UiLanguage, family: CurveFamily) -> &'stati
         (UiLanguage::Russian, CurveFamily::Arrhenius) => "Аррениус",
         (UiLanguage::Russian, CurveFamily::Inverse) => "Обратная",
         (UiLanguage::Russian, CurveFamily::Logistic) => "Логистическая",
+        (UiLanguage::Russian, CurveFamily::Gompertz) => "Гомпертц",
         (UiLanguage::Russian, CurveFamily::Lorentzian) => "Лоренциан",
         (UiLanguage::Russian, CurveFamily::NaturalLog) => "Натуральный логарифм",
         (UiLanguage::Russian, CurveFamily::FourPl) => "4PL",

src/app/i18n.rs

@@ -16,21 +16,6 @@ pub(super) struct ParametricNormalization {
     y_scale: f64,
 }
 
-fn is_polynomial_family(family: CurveFamily) -> bool {
-    matches!(
-        family,
-        CurveFamily::Linear
-            | CurveFamily::Quadratic
-            | CurveFamily::Cubic
-            | CurveFamily::Quartic
-            | CurveFamily::Quintic
-            | CurveFamily::Sextic
-            | CurveFamily::Septic
-            | CurveFamily::Octic
-            | CurveFamily::Nonic
-    )
-}
-
 impl ParametricNormalization {
     /// Строит коэффициенты нормализации по максимальным абсолютным значениям `x` и `y`.
     pub(super) fn try_from_points(points: &Points) -> Result<Self, String> {
@@ -85,7 +70,7 @@ impl ParametricNormalization {
         let x_scale = self.x_scale;
         let y_scale = self.y_scale;
 
-        if is_polynomial_family(family) {
+        if family.is_polynomial() {
             let degree = values.len().saturating_sub(1);
             for (index, value) in values.iter_mut().enumerate() {
                 let power = (degree - index) as i32;
@@ -127,6 +112,17 @@ impl ParametricNormalization {
                         values[2] *= x_scale;
                     }
                 }
+                CurveFamily::Gompertz => {
+                    if to_normalized {
+                        values[0] /= y_scale;
+                        values[1] *= x_scale;
+                        values[2] /= x_scale;
+                    } else {
+                        values[0] *= y_scale;
+                        values[1] /= x_scale;
+                        values[2] *= x_scale;
+                    }
+                }
                 CurveFamily::Lorentzian => {
                     if to_normalized {
                         values[0] /= y_scale;

src/app/normalization.rs

@@ -16,26 +16,12 @@ pub(super) fn polynomial_family(degree: usize) -> CurveFamily {
     }
 }
 
-fn is_polynomial_family(family: CurveFamily) -> bool {
-    matches!(
-        family,
-        CurveFamily::Linear
-            | CurveFamily::Quadratic
-            | CurveFamily::Cubic
-            | CurveFamily::Quartic
-            | CurveFamily::Quintic
-            | CurveFamily::Sextic
-            | CurveFamily::Septic
-            | CurveFamily::Octic
-            | CurveFamily::Nonic
-    )
-}
-
 pub(super) fn is_advanced_param_init_supported(family: CurveFamily) -> bool {
-    is_polynomial_family(family)
+    family.is_polynomial()
         || matches!(
             family,
             CurveFamily::Logistic
+                | CurveFamily::Gompertz
                 | CurveFamily::Gaussian
                 | CurveFamily::ExponentialBasic
                 | CurveFamily::Power
@@ -49,12 +35,13 @@ pub(super) fn data_based_params_for_family(
     family: CurveFamily,
     points: &Points,
 ) -> Result<CurveParams, String> {
-    if is_polynomial_family(family) {
+    if family.is_polynomial() {
         return data_based_polynomial_params(family, points);
     }
 
     match family {
         CurveFamily::Logistic => data_based_logistic_params(points),
+        CurveFamily::Gompertz => data_based_gompertz_params(points),
         CurveFamily::Gaussian => data_based_gaussian_params(points),
         CurveFamily::ExponentialBasic => data_based_exponential_basic_params(points),
         CurveFamily::Power => data_based_power_params(points),
@@ -77,13 +64,15 @@ fn data_based_polynomial_params(
 }
 
 fn data_based_logistic_params(points: &Points) -> Result<CurveParams, String> {
-    let (x_min, x_max, _, y_max, _) = point_extrema(points);
-    let x_span = (x_max - x_min).max(PARAM_INIT_SPAN_EPS);
-    CurveParams::try_from_values(
-        CurveFamily::Logistic,
-        vec![y_max, 4.0 / x_span, (x_min + x_max) * 0.5],
-    )
-    .map_err(|error| error.to_string())
+    let (a, b, c) = data_based_sigmoid_abc(points);
+    CurveParams::try_from_values(CurveFamily::Logistic, vec![a, b, c])
+        .map_err(|error| error.to_string())
+}
+
+fn data_based_gompertz_params(points: &Points) -> Result<CurveParams, String> {
+    let (a, b, c) = data_based_sigmoid_abc(points);
+    CurveParams::try_from_values(CurveFamily::Gompertz, vec![a, b, c])
+        .map_err(|error| error.to_string())
 }
 
 fn data_based_gaussian_params(points: &Points) -> Result<CurveParams, String> {
@@ -141,6 +130,12 @@ fn data_based_power_params(points: &Points) -> Result<CurveParams, String> {
         .map_err(|error| error.to_string())
 }
 
+fn data_based_sigmoid_abc(points: &Points) -> (f64, f64, f64) {
+    let (x_min, x_max, _, y_max, _) = point_extrema(points);
+    let x_span = (x_max - x_min).max(PARAM_INIT_SPAN_EPS);
+    (y_max, 4.0 / x_span, (x_min + x_max) * 0.5)
+}
+
 fn linear_regression(points: &Points) -> Result<(f64, f64), String> {
     if points.len() < 2 {
         return Err("Linear regression requires at least two points".to_string());