ChainRules.jl VS ForwardDiff.jl

The Julia ecosystem provides has a library that includes the differentiation rules hinted at at the end.

https://github.com/JuliaDiff/ChainRules.jl is used by (almost all) automatic differentiation engines and provides an extensive list of such rules.

If the example used sin|cos the auto diff implementations in Julia would have called native cos|-sin and not encurred such a "truncation error". However the post illustrates the idea in a good way.

Good post oxinabox

You seem somewhat obsessed with the idea that reverse-mode autodiff is not the same technique as forward-mode autodiff. It makes you,,, angry? Seems like such a trivial thing to act a complete fool over.

What's up with that?

Anyway, here's a forward differentiation package with a file that might interest you

https://github.com/JuliaDiff/ForwardDiff.jl/blob/master/src/...

Just so you know, v1.9 doesn't solve the load problems. What it does it gives package authors the tools to solve the problems, specifically precompilation as binaries and package extensions. It won't actually solve the load problems until the packages are updated to effectively make use of these features. This is already underway, https://sciml.ai/news/2022/09/21/compile_time/ with things like and https://github.com/JuliaDiff/ForwardDiff.jl/pull/625, but it is a fairly heavy lift to ensure things aren't invalidating and that everything that's necessary is precompiling.

As a quick way to do it, you can use ForwardDiff.jl to determine the partial with respect to h. Then use a Newton-Raphson algorithm to solve for the value of h. I'm not familiar with the actual problem you're solving so there may be more appropriate ways to solve this based on the shape of your function, but this is my knee-jerk reaction to a problem like this. You could also calculate the partial derivative analytically if that is something that you want.

In these discussions, which are the only ones I could find that are the most pertinent and similar to what I'm talking about, https://github.com/JuliaDiff/ForwardDiff.jl/issues/390 and https://discourse.julialang.org/t/differentiation-without-explicit-function-np-gradient/57784 , nobody suggested or answered FiniteDiff.jl's finite differencing gradient for getting the numerical derivatives/gradients of an array of values. The answer is either the diff() function or Interpolations.jl, which I already explained in the post why I would want an alternative to those two options to exist, without having to call NumPy's gradient function.