1use super::error::EconConvergence;
16
17pub const MAX_REGRESSORS: usize = 16;
19pub const MAX_OBSERVATIONS: usize = 1024;
21
22#[derive(Debug, Clone, Copy, PartialEq, Eq)]
23pub enum EconometricsError {
24 InvalidInput,
25 InsufficientData,
26 SingularSystem,
27 BufferTooSmall,
28 NonFinite,
29 NonConverged,
30 Underidentified,
31}
32
33#[derive(Debug, Clone, Copy)]
36#[repr(C)]
37pub struct CalibrationRecord {
38 pub model_name: &'static str,
40 pub data_hash: u64,
42 pub n_params: u32,
44 pub loss: f64,
46 pub iterations: u32,
48 pub epoch_seconds: u64,
50}
51
52impl CalibrationRecord {
53 pub const fn new(
55 model_name: &'static str,
56 data_hash: u64,
57 n_params: u32,
58 loss: f64,
59 iterations: u32,
60 epoch_seconds: u64,
61 ) -> Self {
62 Self {
63 model_name,
64 data_hash,
65 n_params,
66 loss,
67 iterations,
68 epoch_seconds,
69 }
70 }
71}
72
73fn gaussian_solve(a: &mut [f64], b: &mut [f64], n: usize) -> Result<(), EconometricsError> {
78 for col in 0..n {
79 let mut max_row = col;
81 let mut max_val = a[col * n + col].abs();
82 for row in (col + 1)..n {
83 let val = a[row * n + col].abs();
84 if val > max_val {
85 max_val = val;
86 max_row = row;
87 }
88 }
89 if max_val < 1e-14 {
90 return Err(EconometricsError::SingularSystem);
91 }
92 if max_row != col {
93 for j in 0..n {
94 let tmp = a[col * n + j];
95 a[col * n + j] = a[max_row * n + j];
96 a[max_row * n + j] = tmp;
97 }
98 let tmp = b[col];
99 b[col] = b[max_row];
100 b[max_row] = tmp;
101 }
102 let pivot = a[col * n + col];
104 for row in (col + 1)..n {
105 let factor = a[row * n + col] / pivot;
106 if !factor.is_finite() {
107 return Err(EconometricsError::NonFinite);
108 }
109 a[row * n + col] = 0.0;
110 for j in (col + 1)..n {
111 a[row * n + j] -= factor * a[col * n + j];
112 }
113 b[row] -= factor * b[col];
114 }
115 }
116 for row in (0..n).rev() {
118 let mut acc = b[row];
119 for j in (row + 1)..n {
120 acc -= a[row * n + j] * b[j];
121 }
122 b[row] = acc / a[row * n + row];
123 if !b[row].is_finite() {
124 return Err(EconometricsError::NonFinite);
125 }
126 }
127 Ok(())
128}
129
130pub fn ols_into(
136 x: &[f64],
137 y: &[f64],
138 n_obs: usize,
139 n_reg: usize,
140 coef_out: &mut [f64],
141 resid_out: &mut [f64],
142) -> Result<f64, EconometricsError> {
143 if n_obs == 0
144 || n_reg == 0
145 || n_obs < n_reg
146 || n_obs > MAX_OBSERVATIONS
147 || n_reg > MAX_REGRESSORS
148 {
149 return Err(EconometricsError::InsufficientData);
150 }
151 if x.len() < n_obs * n_reg
152 || y.len() < n_obs
153 || coef_out.len() < n_reg
154 || resid_out.len() < n_obs
155 {
156 return Err(EconometricsError::BufferTooSmall);
157 }
158 for v in x.iter().take(n_obs * n_reg) {
159 if !v.is_finite() {
160 return Err(EconometricsError::NonFinite);
161 }
162 }
163 for v in y.iter().take(n_obs) {
164 if !v.is_finite() {
165 return Err(EconometricsError::NonFinite);
166 }
167 }
168
169 let mut xtx = [0.0f64; MAX_REGRESSORS * MAX_REGRESSORS];
170 let mut xty = [0.0f64; MAX_REGRESSORS];
171 for i in 0..n_reg {
173 for j in 0..n_reg {
174 let mut acc = 0.0;
175 for k in 0..n_obs {
176 acc += x[k * n_reg + i] * x[k * n_reg + j];
177 }
178 xtx[i * n_reg + j] = acc;
179 }
180 }
181 for i in 0..n_reg {
183 let mut acc = 0.0;
184 for k in 0..n_obs {
185 acc += x[k * n_reg + i] * y[k];
186 }
187 xty[i] = acc;
188 }
189
190 gaussian_solve(&mut xtx, &mut xty, n_reg)?;
191
192 for i in 0..n_reg {
193 coef_out[i] = xty[i];
194 }
195
196 let y_mean = {
198 let mut sum = 0.0;
199 for k in 0..n_obs {
200 sum += y[k];
201 }
202 sum / n_obs as f64
203 };
204 let mut tss = 0.0;
205 let mut rss = 0.0;
206 for k in 0..n_obs {
207 let mut fitted = 0.0;
208 for i in 0..n_reg {
209 fitted += coef_out[i] * x[k * n_reg + i];
210 }
211 let resid = y[k] - fitted;
212 resid_out[k] = resid;
213 rss += resid * resid;
214 let dev = y[k] - y_mean;
215 tss += dev * dev;
216 }
217 let r_sq = if tss > 0.0 { 1.0 - rss / tss } else { 0.0 };
218 Ok(r_sq)
219}
220
221pub fn wls_into(
225 x: &[f64],
226 y: &[f64],
227 weights: &[f64],
228 n_obs: usize,
229 n_reg: usize,
230 coef_out: &mut [f64],
231 resid_out: &mut [f64],
232) -> Result<f64, EconometricsError> {
233 if n_obs == 0
234 || n_reg == 0
235 || n_obs < n_reg
236 || n_obs > MAX_OBSERVATIONS
237 || n_reg > MAX_REGRESSORS
238 {
239 return Err(EconometricsError::InsufficientData);
240 }
241 if x.len() < n_obs * n_reg
242 || y.len() < n_obs
243 || weights.len() < n_obs
244 || coef_out.len() < n_reg
245 || resid_out.len() < n_obs
246 {
247 return Err(EconometricsError::BufferTooSmall);
248 }
249 for v in weights.iter().take(n_obs) {
250 if !v.is_finite() || *v < 0.0 {
251 return Err(EconometricsError::NonFinite);
252 }
253 }
254
255 let mut xtwx = [0.0f64; MAX_REGRESSORS * MAX_REGRESSORS];
256 let mut xtwy = [0.0f64; MAX_REGRESSORS];
257 for i in 0..n_reg {
258 for j in 0..n_reg {
259 let mut acc = 0.0;
260 for k in 0..n_obs {
261 acc += x[k * n_reg + i] * weights[k] * x[k * n_reg + j];
262 }
263 xtwx[i * n_reg + j] = acc;
264 }
265 }
266 for i in 0..n_reg {
267 let mut acc = 0.0;
268 for k in 0..n_obs {
269 acc += x[k * n_reg + i] * weights[k] * y[k];
270 }
271 xtwy[i] = acc;
272 }
273
274 gaussian_solve(&mut xtwx, &mut xtwy, n_reg)?;
275 for i in 0..n_reg {
276 coef_out[i] = xtwy[i];
277 }
278
279 let mut rss = 0.0;
280 let mut wss = 0.0;
281 let y_wmean = {
282 let mut sw = 0.0;
283 let mut swy = 0.0;
284 for k in 0..n_obs {
285 sw += weights[k];
286 swy += weights[k] * y[k];
287 }
288 if sw > 0.0 {
289 swy / sw
290 } else {
291 0.0
292 }
293 };
294 for k in 0..n_obs {
295 let mut fitted = 0.0;
296 for i in 0..n_reg {
297 fitted += coef_out[i] * x[k * n_reg + i];
298 }
299 let resid = y[k] - fitted;
300 resid_out[k] = resid;
301 rss += weights[k] * resid * resid;
302 let dev = y[k] - y_wmean;
303 wss += weights[k] * dev * dev;
304 }
305 let r_sq = if wss > 0.0 { 1.0 - rss / wss } else { 0.0 };
306 Ok(r_sq)
307}
308
309pub fn iv_2sls_into(
315 x_endogenous: &[f64],
316 z_instruments: &[f64],
317 y: &[f64],
318 n_obs: usize,
319 n_reg: usize,
320 n_instr: usize,
321 coef_out: &mut [f64],
322) -> Result<f64, EconometricsError> {
323 if n_instr < n_reg {
324 return Err(EconometricsError::Underidentified);
325 }
326 if n_obs == 0 || n_obs < n_reg || n_obs > MAX_OBSERVATIONS || n_reg > MAX_REGRESSORS {
327 return Err(EconometricsError::InsufficientData);
328 }
329 if x_endogenous.len() < n_obs * n_reg
330 || z_instruments.len() < n_obs * n_instr
331 || y.len() < n_obs
332 || coef_out.len() < n_reg
333 {
334 return Err(EconometricsError::BufferTooSmall);
335 }
336
337 let mut x_hat = [0.0f64; MAX_OBSERVATIONS * MAX_REGRESSORS];
339 let mut ztz = [0.0f64; MAX_REGRESSORS * MAX_REGRESSORS];
340 let mut ztx_col = [0.0f64; MAX_REGRESSORS];
341 let mut first_stage_coef = [0.0f64; MAX_REGRESSORS];
342
343 for col in 0..n_reg {
344 for i in 0..n_instr {
346 for j in 0..n_instr {
347 let mut acc = 0.0;
348 for k in 0..n_obs {
349 acc += z_instruments[k * n_instr + i] * z_instruments[k * n_instr + j];
350 }
351 ztz[i * n_instr + j] = acc;
352 }
353 }
354 for i in 0..n_instr {
356 let mut acc = 0.0;
357 for k in 0..n_obs {
358 acc += z_instruments[k * n_instr + i] * x_endogenous[k * n_reg + col];
359 }
360 ztx_col[i] = acc;
361 }
362 let mut ztz_copy = ztz;
364 let mut ztx_copy = ztx_col;
365 gaussian_solve(&mut ztz_copy[..n_instr * n_instr], &mut ztx_copy, n_instr)?;
366 for i in 0..n_instr {
367 first_stage_coef[i] = ztx_copy[i];
368 }
369 for k in 0..n_obs {
371 let mut acc = 0.0;
372 for i in 0..n_instr {
373 acc += z_instruments[k * n_instr + i] * first_stage_coef[i];
374 }
375 x_hat[k * n_reg + col] = acc;
376 }
377 }
378
379 let mut resid = [0.0f64; MAX_OBSERVATIONS];
381 ols_into(&x_hat, y, n_obs, n_reg, coef_out, &mut resid)
382}
383
384pub fn logistic_mle_into(
389 x: &[f64],
390 y_binary: &[f64],
391 n_obs: usize,
392 n_reg: usize,
393 max_iter: u32,
394 tolerance: f64,
395 coef_out: &mut [f64],
396) -> Result<EconConvergence, EconometricsError> {
397 use super::error::EconStatus;
398 if n_obs == 0
399 || n_reg == 0
400 || n_obs < n_reg
401 || n_obs > MAX_OBSERVATIONS
402 || n_reg > MAX_REGRESSORS
403 {
404 return Err(EconometricsError::InsufficientData);
405 }
406 if x.len() < n_obs * n_reg || y_binary.len() < n_obs || coef_out.len() < n_reg {
407 return Err(EconometricsError::BufferTooSmall);
408 }
409 for v in y_binary.iter().take(n_obs) {
410 if !v.is_finite() || (*v != 0.0 && *v != 1.0) {
411 return Err(EconometricsError::InvalidInput);
412 }
413 }
414
415 for i in 0..n_reg {
417 coef_out[i] = 0.0;
418 }
419 let mut hessian = [0.0f64; MAX_REGRESSORS * MAX_REGRESSORS];
420 let mut gradient = [0.0f64; MAX_REGRESSORS];
421 let mut score = [0.0f64; MAX_OBSERVATIONS];
422
423 for iter in 0..max_iter {
424 for k in 0..n_obs {
426 let mut eta = 0.0;
427 for i in 0..n_reg {
428 eta += x[k * n_reg + i] * coef_out[i];
429 }
430 let p = 1.0 / (1.0 + (-eta).exp());
431 score[k] = y_binary[k] - p;
432 }
433 for i in 0..n_reg {
435 let mut acc = 0.0;
436 for k in 0..n_obs {
437 acc += x[k * n_reg + i] * score[k];
438 }
439 gradient[i] = acc;
440 }
441 for i in 0..n_reg {
443 for j in 0..n_reg {
444 let mut acc = 0.0;
445 for k in 0..n_obs {
446 let mut eta = 0.0;
447 for r in 0..n_reg {
448 eta += x[k * n_reg + r] * coef_out[r];
449 }
450 let p = 1.0 / (1.0 + (-eta).exp());
451 let w = p * (1.0 - p);
452 acc += x[k * n_reg + i] * w * x[k * n_reg + j];
453 }
454 hessian[i * n_reg + j] = -acc;
455 }
456 }
457 let mut h_copy = hessian;
459 let mut g_copy = gradient;
460 match gaussian_solve(&mut h_copy[..n_reg * n_reg], &mut g_copy, n_reg) {
461 Ok(()) => {
462 let mut delta_norm = 0.0;
463 for i in 0..n_reg {
464 coef_out[i] -= g_copy[i];
469 delta_norm += g_copy[i] * g_copy[i];
470 }
471 let delta_norm = delta_norm.sqrt();
472 if !delta_norm.is_finite() {
473 return Ok(EconConvergence::stalled(
474 EconStatus::NonFinite,
475 iter + 1,
476 delta_norm,
477 ));
478 }
479 if delta_norm < tolerance {
480 return Ok(EconConvergence::converged(iter + 1, delta_norm));
481 }
482 }
483 Err(EconometricsError::SingularSystem) => {
484 return Ok(EconConvergence::stalled(
485 EconStatus::Singular,
486 iter + 1,
487 0.0,
488 ));
489 }
490 Err(e) => return Err(e),
491 }
492 }
493 Ok(EconConvergence::stalled(
494 EconStatus::MaxIterations,
495 max_iter,
496 0.0,
497 ))
498}
499
500pub fn gmm_moment_eval(
507 moment_values: &[f64],
508 n_obs: usize,
509 n_moments: usize,
510 out: &mut [f64],
511) -> Result<usize, EconometricsError> {
512 if n_obs == 0
513 || n_moments == 0
514 || moment_values.len() < n_obs * n_moments
515 || out.len() < n_moments
516 {
517 return Err(EconometricsError::InvalidInput);
518 }
519 for v in moment_values.iter().take(n_obs * n_moments) {
520 if !v.is_finite() {
521 return Err(EconometricsError::NonFinite);
522 }
523 }
524 for j in 0..n_moments {
525 let mut acc = 0.0;
526 for i in 0..n_obs {
527 acc += moment_values[i * n_moments + j];
528 }
529 out[j] = acc / n_obs as f64;
530 }
531 Ok(n_moments)
532}
533
534#[cfg(test)]
535mod tests {
536 use super::*;
537
538 fn approx(a: f64, b: f64) -> bool {
539 (a - b).abs() < 1e-6
540 }
541
542 #[test]
543 fn ols_recovers_exact_linear() {
544 let x = [1.0, 1.0, 1.0, 2.0, 1.0, 3.0, 1.0, 4.0, 1.0, 5.0];
547 let y = [5.0, 8.0, 11.0, 14.0, 17.0];
548 let mut coef = [0.0f64; 2];
549 let mut resid = [0.0f64; 5];
550 let r_sq = ols_into(&x, &y, 5, 2, &mut coef, &mut resid).unwrap();
551 assert!(approx(coef[0], 2.0));
552 assert!(approx(coef[1], 3.0));
553 assert!(approx(r_sq, 1.0));
554 for r in resid.iter() {
555 assert!(approx(*r, 0.0));
556 }
557 }
558
559 #[test]
560 fn ols_insufficient_data() {
561 let x = [1.0, 1.0];
562 let y = [1.0];
563 let mut coef = [0.0f64; 2];
564 let mut resid = [0.0f64];
565 let err = ols_into(&x, &y, 1, 2, &mut coef, &mut resid).unwrap_err();
566 assert_eq!(err, EconometricsError::InsufficientData);
567 }
568
569 #[test]
570 fn ols_singular_system_multicollinearity() {
571 let x = [1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0];
573 let y = [1.0, 2.0, 3.0, 4.0];
574 let mut coef = [0.0f64; 2];
575 let mut resid = [0.0f64; 4];
576 let err = ols_into(&x, &y, 4, 2, &mut coef, &mut resid).unwrap_err();
577 assert_eq!(err, EconometricsError::SingularSystem);
578 }
579
580 #[test]
581 fn wls_recovers_weighted_fit() {
582 let x = [1.0, 1.0, 1.0, 2.0, 1.0, 3.0];
584 let y = [1.0, 2.0, 3.0];
585 let w = [1.0, 1.0, 1.0];
586 let mut coef = [0.0f64; 2];
587 let mut resid = [0.0f64; 3];
588 let r_sq = wls_into(&x, &y, &w, 3, 2, &mut coef, &mut resid).unwrap();
589 assert!(approx(coef[0], 0.0));
590 assert!(approx(coef[1], 1.0));
591 assert!(approx(r_sq, 1.0));
592 }
593
594 #[test]
595 fn iv_2sls_underidentified() {
596 let x = [1.0, 1.0, 1.0, 1.0];
597 let z = [1.0, 1.0]; let y = [1.0, 2.0];
599 let mut coef = [0.0f64; 2];
600 let err = iv_2sls_into(&x, &z, &y, 2, 2, 1, &mut coef).unwrap_err();
601 assert_eq!(err, EconometricsError::Underidentified);
602 }
603
604 #[test]
605 fn logistic_mle_separable() {
606 let x = [
610 1.0, -5.0, 1.0, -3.0, 1.0, -1.0, 1.0, 1.0, 1.0, 3.0, 1.0, 5.0,
611 ];
612 let y = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0];
613 let mut coef = [0.0f64; 2];
614 let conv = logistic_mle_into(&x, &y, 6, 2, 100, 1e-8, &mut coef).unwrap();
615 assert!(coef[1] > 1.0, "coef[1] = {}", coef[1]);
617 let _ = conv;
618 }
619
620 #[test]
621 fn logistic_mle_rejects_non_binary() {
622 let x = [1.0, 0.0, 1.0, 1.0, 1.0, 2.0, 1.0, 3.0];
627 let y = [0.0, 0.5, 1.0, 1.0];
628 let mut coef = [0.0f64; 2];
629 let err = logistic_mle_into(&x, &y, 4, 2, 100, 1e-8, &mut coef).unwrap_err();
630 assert_eq!(err, EconometricsError::InvalidInput);
631 }
632
633 #[test]
634 fn gmm_moment_eval_averages() {
635 let m = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
637 let mut out = [0.0f64; 2];
638 gmm_moment_eval(&m, 3, 2, &mut out).unwrap();
639 assert!(approx(out[0], 3.0)); assert!(approx(out[1], 4.0)); }
642
643 #[test]
644 fn calibration_record_construction() {
645 let rec = CalibrationRecord::new("ols_v1", 0xDEAD_BEEF, 3, 0.05, 0, 12345);
646 assert_eq!(rec.model_name, "ols_v1");
647 assert_eq!(rec.data_hash, 0xDEAD_BEEF);
648 assert_eq!(rec.n_params, 3);
649 assert!(approx(rec.loss, 0.05));
650 }
651
652 #[test]
653 fn buffer_too_small_errors() {
654 let x = [1.0, 1.0, 1.0, 2.0];
655 let y = [1.0, 2.0];
656 let mut coef = [0.0f64; 1]; let mut resid = [0.0f64; 2];
658 let err = ols_into(&x, &y, 2, 2, &mut coef, &mut resid).unwrap_err();
659 assert_eq!(err, EconometricsError::BufferTooSmall);
660 }
661}