Predicting in a loop makes loads of allocations

[pYtoner]

We could add a version of Predict::predict which would write the output to a buffer instead of allocating the output.

Something like PredictInplace::predict_inplace. With a signature like fn predict_inplace(&self, x: &R, y: &mut T).

Implementation

• implement buffer reuse with predict_inplace
• add error handling for predict_inplace

Update algorithms

• K-Means clustering
• check other algorithms for feasibility

[YuhanLiin]

A back-compatible way of adding this would be to add something like

pub trait Predict<R: Records, T> {
    ...
    fn predict_into(&self, x: R, out: &mut T) {
         *out = self.predict(x);
    }
}

which would be overridden for a more efficient implementation. This isn't really useful if T is a Result, however.

[pYtoner]

Do we want to handle invalid target shapes like:

fn predict_inplace<'a>(&'a self, x: &'a R, y: &mut T) -> Result<(), InvalidTargetShape>

Or with a more generic error? Is it just a shape mismatch that we want to handle like this?

[YuhanLiin]

We should have a PredictError enum that has InvalidTargetShape as a variant. The error type will only contain error variants that makes sense to panic on. For now we only care about shape mismatches.