Allow Parameter dependencies to be a callable

[henrikjacobsenfys]

For some of the more advanced diffusion models, I will need to create Lorentzians where the width depends on Q and some Parameters in fairly complex ways. One of the simpler ones that is already impossible is $\Gamma=\frac{6D}{L^2}(1 - \frac{sin(QL/pi)}{QL/pi})$.
I think it would be a lot simpler for me to allow the dependency expression to be a function, or method if that is possible.

This would also simplify my code in other ways:

1. I would only need to implement and test the calculation of $\Gamma$ once for each model, instead of twice (once for calculating it, once for the dependency expression)
2. Each diffusion model would be written the exact same way, with the dependency expression being a different callable
3. It would make it much easier for users to implement their own diffusion models

The questions are:

1. Is this feasible (I assume so)
2. Does it belong in corelib?
3. The hardest part is probably serialisation. How can that be handled?

[damskii9992]

Making the dependency accept methods or functions is actually extremely complex and would add a lot of complexity to our code and by necessity also in our API.

But your use-case is already covered by our current dependency-expression formulation if we simply add the sin function, so I also don't really see the use-case?

[henrikjacobsenfys]

Is it really that complex? My vibes are telling me that it could be handled like this:

if callable(dependency_expression):
    self._dependency_callable = dependency_expression
    self._dependency_map = dependency_map
    self._dependency_string = None
else:
    # current string logic

and in update():

if self._dependency_callable is not None:
    result = self._dependency_callable(**self._dependency_map)
else:
    result = self._dependency_interpreter(...)

[damskii9992]

If you allow callables in the dependency expression, you also need to pass that callable to the dependency_map, including any name used within the callable which isn't standard. And you'd need a check that run the callable and check the output of the callable. Finally you'd need to check that the callable isn't malicious and messes up other part of our code.

In other words, it's actually quite a complex addition.

But I also still don't see the use-case which isn't already covered by adding arithmetic functions to the corelib :)

[henrikjacobsenfys]

Why would the callable need to be passed to the map?

We can and should require that the callable produces a DescriptorNumber (or Parameter), but that shouldn't be an expensive check, I think?

I don't think we need to worry about malicous code.

The use case is

1. more complex dependencies that may stretch over multiple lines
2. simplifying my code as mentioned above
3. making it easier for users to write their own diffusion models

I'm not saying this is something I must have asap. Just had the idea that if this feature existed, my life would be somewhat easier.

Edit: also, *trigonometric :D