Skip to main content

qualia_core_db/research/
dynamics.rs

1//! Dynamics analysis — social, economic, spatiotemporal dynamics.
2
3use std::collections::BTreeMap;
4
5/// Social dynamics configuration.
6#[derive(Debug, Clone)]
7pub struct SocialDynamics {
8    pub id: String,
9    pub network_type: String,
10    pub agents: Vec<String>,
11    pub interactions: Vec<(String, String, f64)>, // (agent_a, agent_b, strength)
12}
13
14/// Economic dynamics configuration.
15#[derive(Debug, Clone)]
16pub struct EconomicDynamics {
17    pub id: String,
18    pub variables: Vec<String>,
19    pub relationships: Vec<(String, String, f64)>, // (cause, effect, coefficient)
20}
21
22/// Spatiotemporal dynamics configuration.
23#[derive(Debug, Clone)]
24pub struct SpatiotemporalDynamics {
25    pub id: String,
26    pub spatial_extent: [f64; 4],  // min_x, min_y, max_x, max_y
27    pub temporal_extent: [f64; 2], // start, end
28    pub diffusion_rate: f64,
29}
30
31/// Analyse a social network — compute centrality measures.
32pub fn analyse_social_network(
33    agents: &[String],
34    interactions: &[(String, String, f64)],
35) -> NetworkAnalysis {
36    let mut degree: BTreeMap<String, usize> = BTreeMap::new();
37    for agent in agents {
38        degree.insert(agent.clone(), 0);
39    }
40    for (a, b, _) in interactions {
41        *degree.entry(a.clone()).or_insert(0) += 1;
42        *degree.entry(b.clone()).or_insert(0) += 1;
43    }
44    let max_degree = degree.values().copied().max().unwrap_or(0);
45    let avg_degree = if agents.is_empty() {
46        0.0
47    } else {
48        degree.values().sum::<usize>() as f64 / agents.len() as f64
49    };
50    let most_central = degree
51        .iter()
52        .max_by_key(|(_, &v)| v)
53        .map(|(k, _)| k.clone())
54        .unwrap_or_default();
55    NetworkAnalysis {
56        agent_count: agents.len(),
57        interaction_count: interactions.len(),
58        max_degree,
59        avg_degree,
60        most_central_agent: most_central,
61    }
62}
63
64#[derive(Debug, Clone)]
65pub struct NetworkAnalysis {
66    pub agent_count: usize,
67    pub interaction_count: usize,
68    pub max_degree: usize,
69    pub avg_degree: f64,
70    pub most_central_agent: String,
71}
72
73/// Analyse inequality — compute Gini coefficient from values.
74pub fn analyse_inequality(values: &[f64]) -> InequalityAnalysis {
75    if values.is_empty() {
76        return InequalityAnalysis {
77            gini: 0.0,
78            mean: 0.0,
79            min: 0.0,
80            max: 0.0,
81        };
82    }
83    let mut sorted = values.to_vec();
84    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
85    let n = sorted.len() as f64;
86    let sum: f64 = sorted.iter().sum();
87    let mean = sum / n;
88    let min = sorted[0];
89    let max = sorted[sorted.len() - 1];
90
91    // Gini coefficient: (sum of |xi - xj|) / (2 * n * mean)
92    let mut abs_diff_sum = 0.0;
93    for i in 0..sorted.len() {
94        for j in 0..sorted.len() {
95            abs_diff_sum += (sorted[i] - sorted[j]).abs();
96        }
97    }
98    let gini = if mean > 0.0 {
99        abs_diff_sum / (2.0 * n * mean)
100    } else {
101        0.0
102    };
103
104    InequalityAnalysis {
105        gini,
106        mean,
107        min,
108        max,
109    }
110}
111
112#[derive(Debug, Clone)]
113pub struct InequalityAnalysis {
114    pub gini: f64,
115    pub mean: f64,
116    pub min: f64,
117    pub max: f64,
118}
119
120/// Analyse diffusion — simulate simple diffusion over time steps.
121pub fn analyse_diffusion(
122    initial_values: &[f64],
123    diffusion_rate: f64,
124    steps: usize,
125) -> Vec<Vec<f64>> {
126    if initial_values.is_empty() {
127        return Vec::new();
128    }
129    let mut history = Vec::with_capacity(steps + 1);
130    let mut current = initial_values.to_vec();
131    history.push(current.clone());
132    let n = current.len();
133    for _ in 0..steps {
134        let mut next = current.clone();
135        for i in 0..n {
136            let left = if i > 0 { current[i - 1] } else { current[0] };
137            let right = if i < n - 1 {
138                current[i + 1]
139            } else {
140                current[n - 1]
141            };
142            let laplacian = left - 2.0 * current[i] + right;
143            next[i] = current[i] + diffusion_rate * laplacian;
144        }
145        current = next;
146        history.push(current.clone());
147    }
148    history
149}
150
151#[cfg(test)]
152mod tests {
153    use super::*;
154
155    #[test]
156    fn analyse_social_network_basic() {
157        let agents = vec!["a".to_string(), "b".to_string(), "c".to_string()];
158        let interactions = vec![
159            ("a".to_string(), "b".to_string(), 1.0),
160            ("b".to_string(), "c".to_string(), 0.5),
161            ("a".to_string(), "c".to_string(), 0.3),
162        ];
163        let analysis = analyse_social_network(&agents, &interactions);
164        assert_eq!(analysis.agent_count, 3);
165        assert_eq!(analysis.interaction_count, 3);
166        assert_eq!(analysis.max_degree, 2);
167    }
168
169    #[test]
170    fn analyse_inequality_equal() {
171        let values = vec![100.0; 5];
172        let analysis = analyse_inequality(&values);
173        assert!((analysis.gini).abs() < 0.01);
174    }
175
176    #[test]
177    fn analyse_inequality_unequal() {
178        let values = vec![0.0, 0.0, 0.0, 0.0, 100.0];
179        let analysis = analyse_inequality(&values);
180        assert!(analysis.gini > 0.5);
181    }
182
183    #[test]
184    fn analyse_diffusion_spreads() {
185        let initial = vec![0.0, 0.0, 1.0, 0.0, 0.0];
186        let history = analyse_diffusion(&initial, 0.1, 10);
187        assert_eq!(history.len(), 11);
188        // The peak should have spread — center value should decrease.
189        assert!(history[10][2] < history[0][2]);
190        // Neighbors should have increased.
191        assert!(history[10][1] > history[0][1]);
192        assert!(history[10][3] > history[0][3]);
193    }
194
195    #[test]
196    fn analyse_diffusion_empty() {
197        let history = analyse_diffusion(&[], 0.1, 5);
198        assert!(history.is_empty());
199    }
200
201    #[test]
202    fn analyse_inequality_empty() {
203        let analysis = analyse_inequality(&[]);
204        assert_eq!(analysis.gini, 0.0);
205    }
206}