I hope this is actually linear regression

linear_regression.rs

#[derive(Debug)]
pub struct LinearRegressionResult {
    pub slope: f64,
    pub intercept: f64,
    pub r2: f64,
}
impl LinearRegressionResult {
    pub fn predict(&self, x: f64) -> f64 { 
        self.intercept + (self.slope * x)
    }
    pub fn findX(&self, y: f64) -> f64 {
        (y - self.intercept) / self.slope
    }
}

pub fn linear_regression(x: &[f64], y: &[f64]) -> LinearRegressionResult {
    let n = x.len().min(y.len());
    let mut mean = (0.0, 0.0);
    let mut i = 0;
    while i < n {
        mean.0 += x[i];
        mean.1 += y[i];
        i+=1;
    }
    mean.0 = mean.0 / (n as f64);
    mean.1 = mean.1 / (n as f64);
    println!("Means {} {}", mean.0, mean.1);

    let mut stddev = (0.0, 0.0);
    i = 0;
    while i < n {
        stddev.0 += (x[i] - mean.0) * (y[i] - mean.1);
        stddev.1 += (x[i] - mean.0) * (x[i] - mean.1);
        i += 1;
    }
    println!("{:?}", stddev);
    let slope = stddev.0 / stddev.1;
    let intercept = mean.1 - (slope * mean.0);

    let mut ssr = 0.0;
    let mut sst = 0.0;

    i = 0;
    while i < n {
        ssr += (intercept + (slope * x[i]) - mean.1).powi(2);
        sst += (y[i] - mean.1).powi(2);
        i += 1;
    }
    return LinearRegressionResult {
        slope: slope,
        intercept: intercept,
        r2: ssr/sst
    }
}