vanaspati 1.0.0

Vanaspati — botany and plant behavior engine for growth, photosynthesis, seasonal cycles, and ecosystems
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum PollinationMethod {
    Wind,
    Insect,
    Bird,
    Water,
    SelfPollinating,
}

/// Pollination success probability based on distance and method.
///
/// Returns 1.0 for self-pollinating. For other methods, probability
/// decreases linearly from 1.0 at distance 0 to 0.0 at max range.
///
/// - `distance_m` — distance between plants (meters)
///
/// Max ranges: Wind 1000m, Insect 500m, Bird 2000m, Water 100m.
#[must_use]
pub fn pollination_probability(method: PollinationMethod, distance_m: f32) -> f32 {
    if matches!(method, PollinationMethod::SelfPollinating) {
        return 1.0;
    }
    let max_range = match method {
        PollinationMethod::Wind => 1000.0,         // meters
        PollinationMethod::Insect => 500.0,        // meters
        PollinationMethod::Bird => 2000.0,         // meters
        PollinationMethod::Water => 100.0,         // meters
        PollinationMethod::SelfPollinating => 0.0, // handled above
    };
    if distance_m >= max_range || distance_m < 0.0 {
        return 0.0;
    }
    let prob = 1.0 - distance_m / max_range;
    tracing::trace!(
        ?method,
        distance_m,
        max_range,
        prob,
        "pollination_probability"
    );
    prob
}

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

    #[test]
    fn self_pollinating_always_succeeds() {
        assert_eq!(
            pollination_probability(PollinationMethod::SelfPollinating, 0.0),
            1.0
        );
    }

    #[test]
    fn probability_decreases_with_distance() {
        let near = pollination_probability(PollinationMethod::Insect, 10.0);
        let far = pollination_probability(PollinationMethod::Insect, 400.0);
        assert!(near > far);
    }

    #[test]
    fn beyond_range_zero() {
        assert_eq!(
            pollination_probability(PollinationMethod::Wind, 2000.0),
            0.0
        );
    }

    #[test]
    fn at_zero_distance_full_probability() {
        assert_eq!(pollination_probability(PollinationMethod::Wind, 0.0), 1.0);
    }

    #[test]
    fn negative_distance_returns_zero() {
        assert_eq!(
            pollination_probability(PollinationMethod::Insect, -10.0),
            0.0
        );
    }

    #[test]
    fn at_exact_max_range_returns_zero() {
        assert_eq!(
            pollination_probability(PollinationMethod::Wind, 1000.0),
            0.0
        );
    }

    #[test]
    fn bird_has_longest_range() {
        let bird = pollination_probability(PollinationMethod::Bird, 1500.0);
        let wind = pollination_probability(PollinationMethod::Wind, 1500.0);
        assert!(bird > 0.0);
        assert_eq!(wind, 0.0);
    }

    #[test]
    fn self_pollinating_ignores_distance() {
        assert_eq!(
            pollination_probability(PollinationMethod::SelfPollinating, 9999.0),
            1.0
        );
    }
}