remove unused MutationType helper methods

Author: basvanwesting

src/genotype/mutation_type.rs

@@ -1,5 +1,4 @@
 use crate::allele::Allele;
-use std::ops::RangeInclusive;
 
 /// Controls mutation behavior for numeric genotypes (Range and MultiRange).
 ///
@@ -304,107 +303,3 @@ pub enum MutationType<T: Allele> {
     StepScaled(Vec<T>),
     Discrete,
 }
-
-impl<T: Allele> MutationType<T> {
-    /// Returns the current range bandwidth for Range-based mutations.
-    /// For scaled variants, returns the bandwidth at the given scale.
-    /// Returns None for non-Range mutations.
-    pub fn current_bandwidth(&self, current_scale_index: usize) -> Option<&T> {
-        match self {
-            Self::Range(bandwidth) => Some(bandwidth),
-            Self::RangeScaled(bandwidths) => {
-                bandwidths.get(current_scale_index.min(bandwidths.len().saturating_sub(1)))
-            }
-            _ => None,
-        }
-    }
-
-    /// Returns the current step size for Step-based mutations.
-    /// For scaled variants, returns the step at the given scale.
-    /// Returns None for non-Step mutations.
-    pub fn current_step(&self, current_scale_index: usize) -> Option<&T> {
-        match self {
-            Self::Step(step) => Some(step),
-            Self::StepScaled(steps) => {
-                steps.get(current_scale_index.min(steps.len().saturating_sub(1)))
-            }
-            _ => None,
-        }
-    }
-
-    /// Returns true if this mutation type uses scaling
-    pub fn is_scaled(&self) -> bool {
-        matches!(self, Self::RangeScaled(_) | Self::StepScaled(_))
-    }
-
-    /// Returns the maximum number of scales/phases for scaled mutations
-    pub fn num_scales(&self) -> usize {
-        match self {
-            Self::RangeScaled(bandwidths) => bandwidths.len(),
-            Self::StepScaled(steps) => steps.len(),
-            _ => 1,
-        }
-    }
-
-    /// Determines if the current scale should use post-clamping for Range mutations.
-    /// - Static Range: always post-clamp (for local search)
-    /// - RangeScaled: only post-clamp the final scale
-    /// - Step mutations: always clamp
-    /// - Others: not applicable
-    pub fn should_post_clamp(&self, current_scale_index: usize) -> bool {
-        match self {
-            Self::Range(_) => true, // Always post-clamp for static Range
-            Self::RangeScaled(bandwidths) => {
-                current_scale_index >= bandwidths.len().saturating_sub(1) // Final scale only
-            }
-            Self::Step(_) | Self::StepScaled(_) => true, // Always clamp steps
-            _ => false,
-        }
-    }
-
-    /// Returns true if this is the final scale for scaled mutations
-    pub fn is_final_scale(&self, current_scale_index: usize) -> bool {
-        match self {
-            Self::RangeScaled(v) => current_scale_index >= v.len().saturating_sub(1),
-            Self::StepScaled(v) => current_scale_index >= v.len().saturating_sub(1),
-            _ => true, // Static mutations are always "final"
-        }
-    }
-
-    /// Checks if this mutation is equivalent to Random behavior for the given allele range.
-    /// Useful for optimization - Random mutations can use more efficient sampling.
-    pub fn is_full_range(
-        &self,
-        allele_range: &RangeInclusive<T>,
-        current_scale_index: usize,
-    ) -> bool
-    where
-        T: PartialOrd + std::ops::Sub<Output = T> + Copy,
-    {
-        match self {
-            Self::Random | Self::Discrete => true,
-            Self::Range(bandwidth) => {
-                let range_width = *allele_range.end() - *allele_range.start();
-                *bandwidth >= range_width
-            }
-            Self::RangeScaled(bandwidths) => {
-                let bandwidth = bandwidths
-                    .get(current_scale_index.min(bandwidths.len().saturating_sub(1)))
-                    .unwrap();
-                let range_width = *allele_range.end() - *allele_range.start();
-                *bandwidth >= range_width
-            }
-            _ => false,
-        }
-    }
-
-    /// Returns true if this is a Range-type mutation (uniform sampling within bandwidth)
-    pub fn is_range_based(&self) -> bool {
-        matches!(self, Self::Range(_) | Self::RangeScaled(_))
-    }
-
-    /// Returns true if this is a Step-type mutation (discrete steps up or down)
-    pub fn is_step_based(&self) -> bool {
-        matches!(self, Self::Step(_) | Self::StepScaled(_))
-    }
-}