Skip to main content

qualia_core_db/specialized_libs/statistical_computing/
computation.rs

1use super::*;
2
3/// Statistical computation engine
4pub struct StatisticalComputationEngine {
5    computation_units: Vec<StatisticalComputationUnit>,
6    operation_queue: Vec<StatisticalOperation>,
7    scheduler: StatisticalScheduler,
8    accelerator: StatisticalAccelerator,
9}
10
11/// Statistical computation unit
12#[derive(Debug, Clone)]
13pub struct StatisticalComputationUnit {
14    pub unit_id: String,
15    pub unit_type: ComputationUnitType,
16    pub capabilities: ComputationCapabilities,
17    pub current_load: f64,
18}
19
20/// Computation unit types
21#[derive(Debug, Clone, PartialEq)]
22pub enum ComputationUnitType {
23    CPU,
24    GPU,
25    CSD,
26    TPU,
27    FPGA,
28}
29
30/// Computation capabilities
31#[derive(Debug, Clone)]
32pub struct ComputationCapabilities {
33    pub max_sample_size: usize,
34    pub supported_operations: Vec<StatisticalOperation>,
35    pub data_types: Vec<DataType>,
36    pub memory_bandwidth: f64,
37    pub compute_throughput: f64,
38}
39
40/// Statistical operations
41#[derive(Debug, Clone)]
42pub enum StatisticalOperation {
43    /// Descriptive statistics
44    Mean {
45        dataset: String,
46        column: String,
47        result: String,
48    },
49    Median {
50        dataset: String,
51        column: String,
52        result: String,
53    },
54    Mode {
55        dataset: String,
56        column: String,
57        result: String,
58    },
59    Variance {
60        dataset: String,
61        column: String,
62        result: String,
63        sample: bool,
64    },
65    StandardDeviation {
66        dataset: String,
67        column: String,
68        result: String,
69        sample: bool,
70    },
71    Skewness {
72        dataset: String,
73        column: String,
74        result: String,
75    },
76    Kurtosis {
77        dataset: String,
78        column: String,
79        result: String,
80    },
81    /// Distribution analysis
82    Histogram {
83        dataset: String,
84        column: String,
85        bins: usize,
86        result: String,
87    },
88    Quantile {
89        dataset: String,
90        column: String,
91        quantile: f64,
92        result: String,
93    },
94    Percentile {
95        dataset: String,
96        column: String,
97        percentile: f64,
98        result: String,
99    },
100    /// Correlation analysis
101    Correlation {
102        dataset: String,
103        column1: String,
104        column2: String,
105        method: CorrelationMethod,
106        result: String,
107    },
108    Covariance {
109        dataset: String,
110        column1: String,
111        column2: String,
112        sample: bool,
113        result: String,
114    },
115    /// Regression analysis
116    LinearRegression {
117        dataset: String,
118        dependent: String,
119        independent: Vec<String>,
120        result: String,
121    },
122    LogisticRegression {
123        dataset: String,
124        dependent: String,
125        independent: Vec<String>,
126        result: String,
127    },
128    PolynomialRegression {
129        dataset: String,
130        dependent: String,
131        independent: Vec<String>,
132        degree: u32,
133        result: String,
134    },
135    /// Hypothesis testing
136    TTest {
137        dataset: String,
138        column: String,
139        hypothesis_type: HypothesisType,
140        result: String,
141    },
142    ChiSquareTest {
143        dataset: String,
144        column1: String,
145        column2: String,
146        result: String,
147    },
148    ANOVA {
149        dataset: String,
150        columns: Vec<String>,
151        result: String,
152    },
153    /// Time series analysis
154    AutoCorrelation {
155        dataset: String,
156        column: String,
157        lag: usize,
158        result: String,
159    },
160    MovingAverage {
161        dataset: String,
162        column: String,
163        window: usize,
164        result: String,
165    },
166    ExponentialSmoothing {
167        dataset: String,
168        column: String,
169        alpha: f64,
170        result: String,
171    },
172    /// Machine learning
173    KMeans {
174        dataset: String,
175        columns: Vec<String>,
176        k: usize,
177        result: String,
178    },
179    LinearSVM {
180        dataset: String,
181        features: Vec<String>,
182        target: String,
183        result: String,
184    },
185    RandomForest {
186        dataset: String,
187        features: Vec<String>,
188        target: String,
189        trees: usize,
190        result: String,
191    },
192}
193
194/// Correlation methods
195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
196pub enum CorrelationMethod {
197    Pearson,
198    Spearman,
199    Kendall,
200    PointBiserial,
201}
202
203/// Hypothesis types
204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
205pub enum HypothesisType {
206    OneSample,
207    TwoSample,
208    Paired,
209    Independent,
210}
211
212impl StatisticalComputationEngine {
213    /// Creates a default `StatisticalComputationEngine`.
214    pub fn new() -> Self {
215        Self {
216            computation_units: Vec::new(),
217            operation_queue: Vec::new(),
218            scheduler: StatisticalScheduler::new(),
219            accelerator: StatisticalAccelerator::new(),
220        }
221    }
222
223    /// Initializes the component; error propagates.
224    pub fn initialize(&mut self) -> Result<(), StatisticalError> {
225        self.scheduler.initialize()?;
226        self.accelerator.initialize()?;
227        Ok(())
228    }
229
230    /// Register a computation unit that can execute statistical operations.
231    pub fn add_computation_unit(&mut self, unit: StatisticalComputationUnit) {
232        self.computation_units.push(unit);
233    }
234
235    /// Returns the list of registered computation units.
236    pub fn computation_units(&self) -> &[StatisticalComputationUnit] {
237        &self.computation_units
238    }
239
240    /// Look up a computation unit by id.
241    pub fn get_computation_unit(&self, unit_id: &str) -> Option<&StatisticalComputationUnit> {
242        self.computation_units.iter().find(|u| u.unit_id == unit_id)
243    }
244
245    /// Returns the number of registered computation units.
246    pub fn computation_unit_count(&self) -> usize {
247        self.computation_units.len()
248    }
249
250    /// Enqueue a statistical operation for later execution.
251    pub fn enqueue_operation(&mut self, operation: StatisticalOperation) {
252        self.operation_queue.push(operation);
253    }
254
255    /// Returns the operations currently waiting in the queue.
256    pub fn operation_queue(&self) -> &[StatisticalOperation] {
257        &self.operation_queue
258    }
259
260    /// Drain all queued operations, returning them in submission order.
261    pub fn drain_operation_queue(&mut self) -> Vec<StatisticalOperation> {
262        std::mem::take(&mut self.operation_queue)
263    }
264
265    /// Returns the number of operations currently in the queue.
266    pub fn queued_operation_count(&self) -> usize {
267        self.operation_queue.len()
268    }
269
270    /// Returns a reference to the scheduler.
271    pub fn scheduler(&self) -> &StatisticalScheduler {
272        &self.scheduler
273    }
274
275    /// Returns a mutable reference to the scheduler.
276    pub fn scheduler_mut(&mut self) -> &mut StatisticalScheduler {
277        &mut self.scheduler
278    }
279}