MathGroup Archive 2010

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

Search the Archive

Re: What does & mean?

  • To: mathgroup at
  • Subject: [mg107087] Re: [mg107050] What does & mean?
  • From: Murray Eisenberg <murray at>
  • Date: Tue, 2 Feb 2010 03:29:41 -0500 (EST)
  • Organization: Mathematics & Statistics, Univ. of Mass./Amherst
  • References: <>
  • Reply-to: murray at

The short answer:  you don't actually need that #1 == #2& there.  You 
could use simply:

    DSolve[MapThread[Equal, {X'[t], A.X[t]}], {x[t],y[t]}, t]

[I prefer to solve for things like x[t] rather than x, but you can 
change that 2nd argument of DSolve to {x,y} if you wish.]

The long answer:

First, let's understand why something like MapThread is needed at all. 
If you evaluate each of  X'[t]  and A.X[t]  you'll get a 2-element list 
in each case, namely:

{4 x[t] - 6 y[t], x[t] - y[t]}

What you want to do is to solve together the pair of differential equations:

   x'[t] == 4 x[t] - 6 y[t]
   y'[t] == x[t] - y[t]

In other words, what you want to construct is the expression:

   DSolve[{x'[t]==4x[t]-6y[t],y'[t]==x[t]-y[t]}, {x[t],y[t]}, t]

In a perfect world, Mathematica would save you the work of separating 
out the two equations if you just used instead:

   DSolve[{x'[t], y'[t]} == {4x[t]-6y[t], x[t]-y[t]}, {x[t],y[t]}, t]

That is, you would expect Mathematica to "thread" the Equal function 
(==) over the two lists {x'[t], y'[t]} and {4x[t]-6y[t], x[t]-y[t]} so 
as to automatically create what you really wanted.

More generally -- and this should help to understand what's involved 
here -- given two lists {a,b} and {c,d}, you'd like Mathematica to 
automatically convert

    (a,b} == {c,d}


    {a == c, b == d}

In earlier versions, Mathematica never (or hardly ever) made such 
conversions. With more recent Mathematica versions, Mathematica does do 
it in some situations, e.g., with Solve. For example:


does automatically solve the pair of simultaneous algebraic equations.

But this automatic threading has not yet permeated to all situations. 
And one of the latter is DSolve.  (We hope it will soon!)

So you have to tell Mathematica explicitly to do such threading for 
DSolve.  How?  Let's go back to the more general situation again:

   (a,b} == {c,d}

The function that does this is MapThread with first argument Equal (that 
is, ==) and second argument the list consisting of the two lists {a,b} 
and {c,d}:

    MapThread[Equal, { {a,b}, {c,d} }]
{a == c, b == d}

Perhaps you'd really like to use the standard abbreviation == for Equal, 
like this:

    MapThread[==, { {a,b}, {c,d} }]

Unfortunately, that's illegal syntax in Mathematica. So you need to do 
the next best thing if you insist on using == instead of Equal: create a 
function F of two variables that's denoted in a way that incorporates 
the == abbreviation and that does not violate syntax.  That is, F should do:

   F[one, two]
one == two

You can create such an F "on the fly", without creating any new name for 
the function, if you use a "pure function"  -- what in some languages is 
called a lambda-function:

    Function[{var1, var2}, var1 == var2]

This works: for example:

    Function[{var1, var2}, var1 == var2][one,two]
one == two

But that Function expression is much too wordy.  So Mathematica has a 
shorthand notation for such a pure function.  In this notation, instead 
of using explicit names for the variables you use #1 and #2; and to 
indicate that you're forming a pure function without using "Function", 
you terminate the expression for the pure function with the & 
characters.  Thus:

    #1 == #2&

means exactly the same thing as Function[{var1, var2}, var1 == var2], so 

one == two

Thus the alternative to the general

   MapThread[Equal, { {a,b}, {c,d} }]


   MapThread[#1 == #2&, { {a,b}, {c,d} }]

and the result is the same:

{a == c, b == d}

Finally, back to the differential equation, we see that

   MapThread[#1 == #2&, {X'[t], A.X[t]}]

gives the same pair of differential equations as

   MapThread[Equal, {X'[t], A.X[t]}]

and thus

   DSolve[MapThread[#1 == #2&, {X'[t], A.X[t]}], {x[t],y[t]}, t]

solves the same system as does the slightly shorter:

   DSolve[MapThread[Equal, {X'[t], A.X[t]}], {x[t],y[t]}, t]

As I suggested earlier, perhaps in a new version of Mathematica soon it 
will no longer be necessary to do that.

On 2/1/2010 6:14 AM, Michael Knudsen wrote:
> Hi,
> I have recently bought Mathematica, and I have a really tough time
> getting started. I'm reading the various documents found under
> "Complete Documentation" at the Mathematica homepage, but it doesn't
> feel like the right place to start.
> For example, I'm now trying to solve some simple differential
> equations, and the documentation provides the following example:
> A = {{4, -6}, {1,-1}};
> X[t_] = {x[t], y[t]};
> system = MapThread[#1 == #2&, {X'[t], A.X[t]}];
> sol = DSolve[system, {x,y}, t]
> However, there is no explanation of how&  works here (and it isn't in
> the MapThread documentation either). Where should one start reading in
> order to understand basic constructs like this? This particular
> example is really nasty, since&  is generally ignored by search
> engines.
> Thanks,
> Michael Knudsen

Murray Eisenberg                     murray at
Mathematics & Statistics Dept.
Lederle Graduate Research Tower      phone 413 549-1020 (H)
University of Massachusetts                413 545-2859 (W)
710 North Pleasant Street            fax   413 545-1801
Amherst, MA 01003-9305

  • Prev by Date: Re: Re: How to combine graphics pimitives and
  • Next by Date: matrix problem
  • Previous by thread: Re: What does & mean?
  • Next by thread: Re: Re: What does & mean?