Update CHANGELOG

Author: basvanwesting

CHANGELOG.md

@@ -7,8 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.25.0] - 2025-11-12
 
 ### Changed
-* (naming only) Refactor `MutationType::ScaledSteps(Vec<T>)` to `MutationType::StepScaled(Vec<T>)` for naming consistency
-* (naming only) Refactor `MutationType::RelativeRange(T)` to `MutationType::Range(T)` as `MutationType::Step(T)` is also relative.
+* (naming only) Refactor `MutationType::ScaledSteps(Vec<T>)` to
+  `MutationType::StepScaled(Vec<T>)` for naming consistency
+* (naming only) Refactor `MutationType::RelativeRange(T)` to
+  `MutationType::Range(T)` as `MutationType::Step(T)` is also relative.
 * Refactor `MutationType::Transition(usize, usize, T)` to `MutationType::RangeScaled(Vec<T>)`:
   * Drop the generation based transition configuration params
   * Replace params with bandwidth per scale (just like step-size per scale StepScaled)
@@ -21,13 +23,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   * Ending condition for current scale, go to next scale and restart counting generations
   * Final ending condition if no scales left (or no scaling at all)
 * Support unsigned integers for `MutationType::Range` and `MutationType::Step` as well (and scaled versions)
-* Allow for zero bandwidth in `MutationType::Range` (and scaled), which lets the mutation die out
+* Allow for zero bandwidth/step in `MutationType::Range` and
+  `MutationType::Step` (and scaled versions), which lets the mutation die out
 * Add `examples/visualize_evolve_mutation_types` and `examples/visualize_permutate_mutation_types`, which
   generate visualizations showing exploration patterns of different mutation strategies
 
 ### Remove
 * Remove `increment_generation()` and `reset_generation()` from `Genotype` and remove hook
-  in Strategies, as all is not scale based.
+  in Strategies, as all scaled MutationTypes now work in the same manner
 * Remove unused `Vec<Chromosome<T>>` into `Population<T>` implementation
 
 ## [0.24.0] - 2025-11-05

src/genotype/mutation_type.rs

@@ -109,6 +109,10 @@ use crate::allele::Allele;
 /// same bandwidth value. You could also alternate between exploration and exploitation several
 /// times (provide alternating high & low bandwidths in the scales)
 ///
+/// It is a good idea to use a prolonged period of full Random sampling (exploration phase, so
+/// several 100% bandwidth scales), which then transitions quite fast to the smaller bandwidths
+/// (exploitation phase, a few smaller bandwidth scales).
+///
 /// ## `StepScaled(Vec<T>)`
 /// Multi-phase step mutation with strategy-controlled progression. Like `RangeScaled`
 /// but uses fixed step sizes instead of uniform ranges. Mutations apply the step
@@ -216,12 +220,13 @@ use crate::allele::Allele;
 ///
 /// All bandwidth and step values use the same type `T` as the genotype's allele type.
 /// This ensures type safety and intuitive behavior:
+/// - For `RangeGenotype<u32>`: Use integer bandwidths like `Range(10)` or `Step(5)`
 /// - For `RangeGenotype<i32>`: Use integer bandwidths like `Range(10)` or `Step(5)`
 /// - For `RangeGenotype<f64>`: Use float bandwidths like `Range(10.0)` or `Step(0.5)`
 ///
 /// # Compatibility
 ///
-/// * [RangeGenotype](crate::genotype::RangeGenotype): All variants except Discrete
+/// * [RangeGenotype](crate::genotype::RangeGenotype): All variants
 /// * [MultiRangeGenotype](crate::genotype::MultiRangeGenotype): All variants
 /// * Other genotypes use fixed mutation strategies (always Random)
 ///

src/lib.rs

@@ -139,7 +139,7 @@
 //! - **StepScaled**: Grid-like exploration with progressively finer resolution
 //! - **Discrete**: ListGenotype behaviour, for categories in heterogeneous genotypes
 //!
-//! Run the example with `cargo run --example visualize_mutation_types --release` to generate the visualization.
+//! Run the example with `cargo run --example visualize_evolve_mutation_types --release` to generate the visualization.
 //!
 //! ### Permutate Strategy (and HillClimb)
 //!

tests/genotype/range_test.rs

@@ -162,6 +162,46 @@ fn float_mutate_chromosome_single_range_scaled_on_edge_and_zero_bandwidth() {
     ));
 }
 
+#[test]
+fn float_mutate_chromosome_single_step_scaled_on_edge_and_zero_bandwidth() {
+    let mut rng = SmallRng::seed_from_u64(1);
+    let mut genotype = RangeGenotype::builder()
+        .with_genes_size(3)
+        .with_allele_range(0.0..=1.0)
+        .with_mutation_type(MutationType::StepScaled(vec![1.0, 0.1, 0.0, 0.0]))
+        .build()
+        .unwrap();
+
+    let mut chromosome = build::chromosome(vec![1.0, 0.0, 1.0]);
+
+    assert!(genotype.increment_scale_index());
+    assert_eq!(genotype.current_scale_index, 1);
+    genotype.mutate_chromosome_genes(3, false, &mut chromosome, &mut rng);
+    assert!(relative_chromosome_eq(
+        inspect::chromosome(&chromosome),
+        vec![0.9, 0.1, 0.9],
+        0.001,
+    ));
+
+    assert!(genotype.increment_scale_index());
+    assert_eq!(genotype.current_scale_index, 2);
+    genotype.mutate_chromosome_genes(3, false, &mut chromosome, &mut rng);
+    assert!(relative_chromosome_eq(
+        inspect::chromosome(&chromosome),
+        vec![0.9, 0.1, 0.9],
+        0.001,
+    ));
+
+    assert!(genotype.increment_scale_index());
+    assert_eq!(genotype.current_scale_index, 3);
+    genotype.mutate_chromosome_genes(3, false, &mut chromosome, &mut rng);
+    assert!(relative_chromosome_eq(
+        inspect::chromosome(&chromosome),
+        vec![0.9, 0.1, 0.9],
+        0.001,
+    ));
+}
+
 #[test]
 fn float_mutate_chromosome_single_step() {
     let mut rng = SmallRng::seed_from_u64(0);