       Re: Function-type arguments in function definition

• To: mathgroup at smc.vnet.net
• Subject: [mg44351] Re: Function-type arguments in function definition
• From: Paul Abbott <paul at physics.uwa.edu.au>
• Date: Wed, 5 Nov 2003 10:02:20 -0500 (EST)
• Organization: The University of Western Australia
• References: <bo7o3k\$aep\$1@smc.vnet.net>
• Sender: owner-wri-mathgroup at wolfram.com

```In article <bo7o3k\$aep\$1 at smc.vnet.net>,
"Carsten Reckord" <news at reckord.de> wrote:

> I'm pretty new to Mathematica so please excuse me if this is kind of a silly
> question (though I couldn't find any answer after a full day of searching).
> I'm trying to define functions that take other functions as arguments and
> need those functions' arguments in their own definition. An example would be
> the definition of convolution:
>
> h(x)=f(x)*g(x) is defined as Integral over f(y)g(x-y) with respect to y.
>
> As you can see it is important in the definition of convolution to treat the
> arguments f and g as functions because the definition makes use of their
> arguments.
> I've seen this done in Mathematica as
>
> convolute[f_,g_,x_]:=Integrate[f[y]*g[x-y],{y,-inf,inf}]
>
> but that's not exactly what I'm looking for because I can only use function
> names as arguments to convolute[...], not arbitrary expressions in x. So I
> can't for example use it for the convolution f(s(x))*g(t(x)) without
> defining intermediate functions for f(s(x)) and g(t(x))...
>
> So, my question is if there is any way to define such a function that can
> make use of its arguments being functions and yet supports arbitrary
> expressions as its arguments?

I would do this as follows. Define your convolution operation for pure
functions f and g with variable x as

Star[f_Function, g_Function][x_] :=
Integrate[f[y] g[x - y], {y, -Infinity, Infinity}]

If you now add a rule that converts f and g to pure functions (assumed
to be functions of x),

Star[f_,g_][x_] := Star[Function[x,f], Function[x,g]][x]

then you can compute convolutions of the type you require as

Star[f[s[x]], g[t[x]]][x]

(An aside: Mathematica already has an infix notation suitable for
convolution -- the Star operator. Above I've used the InputForm, Star,
which adds rules to Star, so that you can enter input expressions as

(f[s[x]] \[Star] g[t[x]])[x]

where \[Star] is converted to the appropriate special character on
input.)

Cheers,
Paul

--
Paul Abbott                                   Phone: +61 8 9380 2734
School of Physics, M013                         Fax: +61 8 9380 1014
The University of Western Australia      (CRICOS Provider No 00126G)
35 Stirling Highway
Crawley WA 6009                      mailto:paul at physics.uwa.edu.au
AUSTRALIA                            http://physics.uwa.edu.au/~paul

```

• Prev by Date: Re: Solving a matrix equation
• Next by Date: Re: Trying to use Mathematica as "word processor" for my math homework
• Previous by thread: Re: Function-type arguments in function definition
• Next by thread: Re: Antw: pdf-export