Is there a way to make $g$ changeable independently of $f$ in this code?

Question

My problem is that in the below code, every time I want to change $g$ I also have to change $f$.

Let's say we have three functions: $f$, $h$, and $g$ ($h$ is not really relevant for the question, but its there).

Now let's say that we don't specify what $g$ is yet, because we don't want to restrict it to one particular form. But we define $f$ as follows:

f[x_]:=h[x]+NIntegrate[g[y],{y,0,x}]

Now let's say we want to plot $f[5]$ as a function of a parameterization of $g$:

g[y_]:=a*y^b
(*I am tempted to write the following:*)
Plot3D[f[5],{a,0,1},{b,0,1}]

But the above code obviously doesn't do anything. In order for the approach to work, we would have to instead define

f[x_,a_,b_]:=h[x]+NIntegrate[g[y,a,b],{y,0,x}]
g[y_,a_,b_]:=a*y^b
Plot3D[f[5,a,b],{a,0,1},{b,0,1}]

There are two problems with this approach:

1. It is kind of clumsy

2. It is not versatile. If we want a specification of $g$ that has 3 parameters, then we need to redefine $f$ as well.

3. If we have higher levels of nesting of functions, this becomes even more of a hassle.

Is there a way to do this in a cleaner way without passing parameters from function to function, or at least in a way that if we want to change the parameter specification of $g$, we don't have to change all the others as well?

Is there a Canonical way to do this?

Answer 1

Whenever I see an equation with an integral, I always think about trying to convert it into an ODE. Your question falls into this category. So, let's differentiate your equation:

eqn = f[x] == h[x] + Inactive[NIntegrate][g[y], {y, 0, x}];
D[eqn, x]

f'[x] == g[x] + h'[x]

Now, let's solve this ODE and plot the solution:

g[x_] := a x^b
h[x_] := x^2

f = ParametricNDSolveValue[
    {u'[x] == h'[x] + g[x], u[0] == h[0]},
    u[5],
    {x, 0, 5},
    {a, b}
];

Plot3D[f[a, b], {a, 0, 1}, {b, 0, 1}]

Addendum

You can include g in the definition of f as follows:

f[g_, p_] := ParametricNDSolveValue[
    {u'[x] == h'[x] + g, u[0] == h[0]}, 
    u[5], 
    {x, 0, 5}, 
    p
]

Then, we can use different g functions:

f1 = f[a x^b, {a, b}];

Plot3D[f1[a, b], {a, 0, 1}, {b, 0, 1}]

f2 = f[a Cos[b x], {a, b}];

Plot3D[f2[a, b], {a, 0, 1}, {b, 0, 1}]

Answer 2

There are probably half a dozen ways to do what OP wants. Below are given two relatively simple ones.

args___

I would say the simplest way is to have arbitrary arguments passed from f to g.

ClearAll[f, g, h]    
h[x_] := x^2    
f[x_, args___] := h[x] + NIntegrate[g[y, args], {y, 0, x}]

Using f with a definition of g:

g[y_, a_, b_] := a*y^b    
f[6, 0, 1]

(* 36. )

Using f with another definition of g:

g[y_, a_, b_, c_, d_] := a + b*y + c*y^2 + d*y^3
f[6, 1, 2, 3, 4]

(* 1590. *)

A version of this approach is to use OptionsPattern; another version is to use Association. (For the latter see this answer.)

Using SubValues

Here the definition of f takes the functions h and g as arguments (instead of the parameters of g as done above.)

ClearAll[f, g, g1, g2, h]
f[h_, g_][x_?NumberQ] := h[x] + NIntegrate[g[y], {y, 0, x}]
h[x_] := x^2

Here is a couple of definitions of g:

g1[y_, a_, b_] := a*y^b

g2[y_, a_, b_, c_, d_] := a + b*y + c*y^2 + d*y^3

Here is how we invoke them:

f[h, g1[#, 0, 1] &][6]

(* 36. *)

f[h, g2[#, 1, 2, 3, 4] &][6]

(* 1590. *)

The convenience of this approach is that we can specify g "on the spot." For example,

f[h, (#^2 + 3*#) &][6]

(* 162. *)

Note that with the approach in the previous section we do enforce the use of a definition of g (which might be desired in some cases.)