Skip to main content

qualia_core_db/specialized_libs/computational_economics/
econometrics.rs

1//! Econometrics: OLS, WLS, 2SLS, logistic MLE, GMM, and calibration records.
2//!
3//! Allocation class: **HotZeroHeap**. All scratch uses fixed-capacity stack
4//! arrays. No `Vec`/`String`/`Box` in any kernel.
5//!
6//! Assumptions:
7//! - OLS assumes exogeneity (E[ε|X] = 0), iid errors, no perfect
8//!   multicollinearity. Standard errors are not yet computed (future work).
9//! - WLS assumes known weights proportional to inverse error variance.
10//! - 2SLS assumes instrument relevance (n_instr >= n_reg) and exogeneity.
11//!   Underidentified models (n_instr < n_reg) are refused.
12//! - Logistic MLE assumes iid Bernoulli outcomes with logit link; uses
13//!   Newton-Raphson (IRLS).
14
15use super::error::EconConvergence;
16
17/// Maximum regressors (including constant) in a bounded regression.
18pub const MAX_REGRESSORS: usize = 16;
19/// Maximum observations in a bounded regression.
20pub 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/// A `repr(C)` calibration record linking a fitted model to its data and
34/// diagnostics.
35#[derive(Debug, Clone, Copy)]
36#[repr(C)]
37pub struct CalibrationRecord {
38    /// Static model name (e.g. "ols_v1", "logistic_irls").
39    pub model_name: &'static str,
40    /// FNV-1a or caller-supplied hash of the calibration dataset.
41    pub data_hash: u64,
42    /// Number of fitted parameters.
43    pub n_params: u32,
44    /// Final loss (RSS for OLS, negative log-likelihood for MLE).
45    pub loss: f64,
46    /// Iterations executed (0 for closed-form OLS).
47    pub iterations: u32,
48    /// Caller-supplied epoch seconds for provenance.
49    pub epoch_seconds: u64,
50}
51
52impl CalibrationRecord {
53    /// Creates `CalibrationRecord` with the given state.
54    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
73/// Solve a linear system `A * x = b` in place using Gaussian elimination with
74/// partial pivoting. `a` is `n x n` row-major (destroyed), `b` is length `n`
75/// (overwritten with solution). Returns `SingularSystem` if a zero pivot is
76/// encountered.
77fn gaussian_solve(a: &mut [f64], b: &mut [f64], n: usize) -> Result<(), EconometricsError> {
78    for col in 0..n {
79        // Find pivot.
80        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        // Eliminate below.
103        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    // Back-substitution.
117    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
130/// Ordinary Least Squares via normal equations `X'X b = X'y`.
131///
132/// `x` is `n_obs x n_reg` row-major. `y` is length `n_obs`. Writes
133/// coefficients into `coef_out[..n_reg]` and residuals into
134/// `resid_out[..n_obs]`. Returns R-squared.
135pub 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    // X'X
172    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    // X'y
182    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    // Residuals and R-squared.
197    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
221/// Weighted Least Squares: `(X'WX) b = X'Wy`.
222///
223/// `weights` is length `n_obs`. Writes coefficients and residuals.
224pub 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
309/// Two-Stage Least Squares (2SLS).
310///
311/// First stage: regress endogenous `X` on instruments `Z`, get `X-hat`.
312/// Second stage: OLS of `y` on `X-hat`. Refuses if `n_instr < n_reg`
313/// (underidentified).
314pub 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    // First stage: for each regressor, regress on instruments → x_hat.
338    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        // Z'Z
345        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        // Z'x_col
355        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        // Solve Z'Z * gamma = Z'x_col
363        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        // x_hat[k, col] = Z[k] · gamma
370        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    // Second stage: OLS of y on x_hat.
380    let mut resid = [0.0f64; MAX_OBSERVATIONS];
381    ols_into(&x_hat, y, n_obs, n_reg, coef_out, &mut resid)
382}
383
384/// Logistic regression via Newton-Raphson (IRLS).
385///
386/// `x` is `n_obs x n_reg` row-major. `y_binary` in {0, 1}. Writes
387/// coefficients into `coef_out[..n_reg]`. Returns convergence report.
388pub 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    // Initialize coef = 0.
416    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        // Compute p_k = sigmoid(X_k · coef) and score_k = y_k - p_k.
425        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        // Gradient = X' (y - p)
434        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        // Hessian = -X' W X where W = diag(p(1-p))
442        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        // Solve Hessian * delta = gradient (Newton step).
458        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                    // Newton-Raphson maximizing the log-likelihood: β_new = β − H⁻¹∇L.
465                    // `g_copy` is H⁻¹∇L (H = ∇²L = −X'WX, negative definite), so the
466                    // ascent step subtracts it. (Adding it, as before, descended away
467                    // from the MLE — coefficients moved the wrong direction.)
468                    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
500/// Evaluate GMM moment conditions: `g(theta) = (1/n) sum m_i(theta)`.
501///
502/// `moments` is a caller-supplied closure-free precomputed table:
503/// `moments[i * n_moments + j]` = m_j(observation_i, params). Actually this
504/// function computes the sample average of the supplied moment values.
505/// `out` receives `n_moments` averaged moment conditions.
506pub 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        // y = 2 + 3x, x = [1, 2, 3, 4, 5]
545        // Design matrix with constant: [[1, 1], [1, 2], [1, 3], [1, 4], [1, 5]]
546        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        // Two identical columns → singular X'X
572        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        // Simple: y = x, weights all 1 → same as OLS
583        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]; // 1 instrument for 2 regressors
598        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        // Perfectly separable: y=1 when x>0, y=0 when x<0
607        // Design: [[1, -5], [1, -3], [1, -1], [1, 1], [1, 3], [1, 5]]
608        // y = [0, 0, 0, 1, 1, 1]
609        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        // For separable data, coef[1] should be large positive.
616        assert!(coef[1] > 1.0, "coef[1] = {}", coef[1]);
617        let _ = conv;
618    }
619
620    #[test]
621    fn logistic_mle_rejects_non_binary() {
622        // 4 observations × 2 regressors → the design needs 8 values. (The prior
623        // test passed only 4, so it tripped the BufferTooSmall guard before ever
624        // reaching the binary-y check it meant to exercise.) With a correctly
625        // sized design, the non-binary y=0.5 is what triggers InvalidInput.
626        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        // 3 observations, 2 moments: m = [[1, 2], [3, 4], [5, 6]]
636        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)); // (1+3+5)/3
640        assert!(approx(out[1], 4.0)); // (2+4+6)/3
641    }
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]; // too small
657        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}