holodeck 0.1.0

Modern NGS read simulator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! Deterministic seed computation for reproducible simulations.
//!
//! When no explicit `--seed` is provided, a seed is derived from the
//! simulation parameters so that identical inputs always produce identical
//! output across runs and processes.

/// Compute a deterministic seed by hashing a string description of the
/// simulation parameters.
///
/// Uses FNV-1a hashing which is deterministic across runs (unlike `ahash`
/// which uses per-process random keys). The same input always produces the
/// same seed.
#[must_use]
pub fn compute_seed(description: &str) -> u64 {
    // FNV-1a hash — deterministic, fast, no external dependencies.
    let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
    for byte in description.bytes() {
        hash ^= u64::from(byte);
        hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
    }
    hash
}

/// Resolve the effective seed: use the explicit seed if provided, otherwise
/// derive one from the given parameter description string.
#[must_use]
pub fn resolve_seed(explicit: Option<u64>, description: &str) -> u64 {
    explicit.unwrap_or_else(|| compute_seed(description))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_compute_seed_deterministic() {
        let a = compute_seed("hello:42:3.14");
        let b = compute_seed("hello:42:3.14");
        assert_eq!(a, b);
    }

    #[test]
    fn test_compute_seed_known_value() {
        // Pin a known value so we detect if the hash implementation changes.
        let seed = compute_seed("test");
        assert_eq!(seed, 0xf9e6_e6ef_197c_2b25);
    }

    #[test]
    fn test_compute_seed_different_inputs() {
        let a = compute_seed("hello");
        let b = compute_seed("world");
        assert_ne!(a, b);
    }

    #[test]
    fn test_resolve_seed_explicit() {
        let seed = resolve_seed(Some(42), "ignored");
        assert_eq!(seed, 42);
    }

    #[test]
    fn test_resolve_seed_derived() {
        let seed = resolve_seed(None, "hello");
        let expected = compute_seed("hello");
        assert_eq!(seed, expected);
    }
}