MathGroup Archive 2011

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Overloading functions

  • To: mathgroup at smc.vnet.net
  • Subject: [mg119157] Re: Overloading functions
  • From: Leonid Shifrin <lshifr at gmail.com>
  • Date: Mon, 23 May 2011 06:26:23 -0400 (EDT)

Sam,

On Sun, May 22, 2011 at 2:57 PM, Sam Takoy <sam.takoy at yahoo.com> wrote:

> Thanks Leonid.
>
> Let me paraphrase, so I can clarify my original confusion and see if I got
> it
> right.
>
> I assume (am I wrong?) that MyOperator[f][x, y] associates left
> (MyOperator[f])[x, y]. At the time MyOperator[f] is called, no decision is
> made
> as to which f to send to MyOperator, because what is sent to the operator
> is
> just the symbol "f". Inside MyOperator, Mathematica sees Derivative[1,0][f]
> and
> based on this looks for a rule for "f" that takes two variables.
>
> Is that correct?
>

Yes, this is correct. From the Trace output in my previous answer you could
see that Derivative constructs
an anonymous  pure function's body, with the number of arguments determined
by its specification ([1,0] in this case, so 2 variables). Therefore, it
constructs f[#1,#2], and it is at this moment that the 2-argument rule for
<f> fires, and f[#1,#2] gets rewritten into #1+#2 according to that rule.
Since #1 and #2 are used not yet in the context of pure functions, they are
as good the arguments as any.

In other words: there is only one principle at work here - for any rule to
apply, you need at some stage to form the expression of the form f[x1,x2]
etc. In this case, this is done in the implementation of Derivative. There
is nothing else at work here, everything follows directly from the
term-rewriting mechanism.

Cheers,
Leonid


>
> Thanks!
>
> Sam
>
>
>
> ________________________________
> From: Leonid Shifrin <lshifr at gmail.com>
> To: Sam Takoy <sam.takoy at yahoo.com>; mathgroup at smc.vnet.net
> Sent: Sat, May 21, 2011 7:20:51 PM
> Subject: [mg119130] Re: [mg119093] Overloading functions
>
> Sam,
>
> This is a misunderstanding. Mathematica will always use the symbol f.
> Different
> definitions for f are different rules, and the analogy with function
> overloading
> in other languages is only superficial (on the level of syntax only). The
> choice
> of which rule to apply is then based on how Derivative works. Since you
> call it
> as Derivative[1,0], it assumes 2 independent variables, and this determines
> the
> way it calls f:
>
> In[23]:= Derivative[1,0][f][x,y]//Trace
>
> Out[23]= {{f^(1,0),{f[#1,#2],#1+#2},1&},(1&)[x,y],1}
>
> So, there is a single symbol with different rules. Which rule is used is
> determined once the expression f[args] is formed. It is as simple as that.
>
> Regards,
> Leonid
>
>
>
> On Sat, May 21, 2011 at 3:50 AM, Sam Takoy <sam.takoy at yahoo.com> wrote:
>
> Hi,
> >
> >In the following code
> >
> >MyOperator[g_][x_, y_] = 4 + Derivative[1, 0][g][x, y];
> >
> >f[x_, y_] = x + y;
> >f[x_, y_, z_] = 2 x + 2 y + 2 z;
> >
> >MyOperator[f][x, y]
> >
> >
> >how does Mathematica know which f to send to MyOperator. Can someone
> >outline the formal decision tree that Mathematica follows?
> >
> >Thanks!
> >
> >Sam
> >
> >
>


  • Prev by Date: Re: Overloading functions
  • Next by Date: Re: unable to import csv-Data
  • Previous by thread: Re: Overloading functions
  • Next by thread: Re: Overloading functions