qualia_core_db/research/
dynamics.rs1use std::collections::BTreeMap;
4
5#[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)>, }
13
14#[derive(Debug, Clone)]
16pub struct EconomicDynamics {
17 pub id: String,
18 pub variables: Vec<String>,
19 pub relationships: Vec<(String, String, f64)>, }
21
22#[derive(Debug, Clone)]
24pub struct SpatiotemporalDynamics {
25 pub id: String,
26 pub spatial_extent: [f64; 4], pub temporal_extent: [f64; 2], pub diffusion_rate: f64,
29}
30
31pub 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
73pub 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 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
120pub 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 assert!(history[10][2] < history[0][2]);
190 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}