Memory allocation on every step?

[mazaja]

Hello,

Assuming that I understand correctly what is happening here, then every time the residuals and the jacobian need to be calculated a new array is allocated and returned. Is this true? Is there any optimisation that is happening that avoids allocation?

Assuming this is true, would it be possible to expose a second trait that accepts preallocated arrays? So for example, instead of having

fn residuals(&self) -> Option<OVector<f64, U4>>

to have

fn residuals(&self, residual: &mut OVector<f64, U4>) -> bool

or

fn residuals(&self) -> &mut Option<OVector<f64, U4>>

In the former case the array can be preallocated by the solver and in the latter it can be preallocated by the problem. Similarly of course for the Jacobian.

[geo-ant]

not a maintainer of this crate, just a very active and happy user. First of all, the second suggested signature is problematic (a shared borrow to self and returning an exclusive mut borrow of the vector, presumably inside self). I can see that the first signature might work. However, this doesn't necessarily work well with the current API of this crate. In an ideal world, the following would be possible:

• inside your implementor of LeastSquaresProblem you keep an owned vector of residuals and you write to it e.g. on call to set_params.
• Make your ParameterStorage a ViewStorage

However, this won't work since ParameterStorage is restricted on RawStorageMut, which is needed deep in the guts of the implementation. Changing this is highly non-trivial and might even mean that you end up with the same amount of allocations that you're trying to avoid.

So maybe your second signature would help. But to make things more complicated note that it is sometimes very advantageous to pre-calculate the residuals in the set_params function to make use of them in the call to jacobian to speed up those calculations. In this case the proposed API offers no advantage...