Prev: Animated Gif
Next: What's wrong with this assuming?
From: Murray Eisenberg on 21 Jul 2010 07:15 For a start at what's going on, try: s = x + h; Manipulate[s^2, {h, 0.1, 1}] On 7/20/2010 3:42 AM, Sam Takoy wrote: > Hi, > > I find that I don't understand a very basic thing about the building > blocks of Mathematica. > > When the first command is > > s = x + h > > I figured that (string?) "s" represents (string?) "x+h". > > This theory pans out when one tries > > s^2 > > or > > D[s, x] > > or > > Integrate[s, {x, 0, h}] > > and > > s /. h -> 1 > > But then by doesn't this work: > > Manipulate[ Plot[s, {x, 0, h}], {h, 0.1, 1}] > > Many thanks in advance! > -- Murray Eisenberg murray(a)math.umass.edu 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
From: Sam Takoy on 22 Jul 2010 05:44 Thanks to all who responded! May I belabor this point a little. I understand how to make Manipulate work and I understand functions. (I am a product of Scheme from with Mathematica seems to have borrowed a few ideas.) My question is much more formal: What are the building blocks of Mathematica, the formal language. When you say s = x+h what is s? Is it an "expression"? Does s represent x+h wherever it appears (assuming x and h are unassigned at the time of s=x+h)? Apparently not always: yes in s/.h->5, but not in Manipulate. So here, then is my "model" of Mathematica: In s = x+h, s is an "Expression" In s[x_, h_]:=x+h, s is a "Function" Manipulate expects a "Function" so that answers my question. Then what is s[h_] := x + h? Is it an "Expression" or a "Function" of h with a parameter x? Would then Manipulate[Plot[s[h], {x, 0, 1}, PlotRange -> {0, 1}], {h, 0, 1}] work? (The answer is yes.) So apparently, Plot is happy with an "Expression", but Manipulate wants a "Function"? Why? Also, in Manipulate[Plot[x+h, {x, 0, 1}, PlotRange -> {0, 1}], {h, 0, 1}], x+h is no longer an "Expression", but is once again a "Function", because of the context? Even though it's inside Plot which is happy with an "Expression"? A personal note: I guess I'm a little frustrated that after a few months of working with Mathematica, I still have to try things before I know whether they'll work or not. I'm used to having a clear picture of the grammar of the language that I'm working with, but I'm struggling here. On 7/21/2010 7:14 AM, dr DanW wrote: > I ran into this problem yesterday. I don't know exactly why it > happens, I think it has something to do with the way Manipulate > localizes variables. To solve it, I use a trick I found that lets me > take an expression built up of global symbols and localize the > symbols. Your trivial example: > > s = x + h > > Make a function out of it. The Evaluate[] is necessary to evaluate s, > which replaces it with x+h > > sfnc = Function[{x, h}, Evaluate[s]] > > Now the Manipulate[] works fine > > Manipulate[Plot[sfnc[x, h], {x, 0, h}], {h, 0.1, 1}] > > I find myself using this trick a lot. > > Regards, > Daniel >
From: Bill Rowe on 23 Jul 2010 07:11 On 7/22/10 at 5:44 AM, sam.takoy(a)yahoo.com (Sam Takoy) wrote: >May I belabor this point a little. I understand how to make >Manipulate work and I understand functions. (I am a product of >Scheme from with Mathematica seems to have borrowed a few ideas.) >My question is much more formal: What are the building blocks of >Mathematica, the formal language. When you say >s = x+h >what is s? >Is it an "expression"? No, s is a symbol which evaluates to x+h as a result of the assignment operation. >Does s represent x+h wherever it appears (assuming x and h are >unassigned at the time of s=x+h)? Apparently not always: yes in >s/.h->5, but not in Manipulate. >So here, then is my "model" of Mathematica: In s = x+h, s is an >"Expression" In s[x_, h_]:=x+h, s is a "Function" With s=x+h, x+h is evaluated and becomes one of the OwnValues of s. With s[x_, h_]:= x+h, x+h is not evaluated and the expression x+h becomes one of the DownValues for s. That is: In[5]:= s = x + h; {OwnValues[s], DownValues[s]} Out[6]= {{HoldPattern[s] :> h + x}, {}} In[7]:= Clear[s]; s[x_, h_] := x + h {OwnValues[s], DownValues[s]} Out[9]= {{}, {HoldPattern[s[x_, h_]] :> h + x}} >Manipulate expects a "Function" so that answers my question. No, the following works just fine. Manipulate[Plot[x (1 + a x), {x, 0, 6}], {a, 0, 2}] Here, the argument x (1 + a x) is simply an expression, clearly not a function with named arguments. >Then what is >s[h_] := x + h? Is it an "Expression" or a "Function" of h with a >parameter x? Actually, I would call this an example of bad programming style. The result depends on h which is local to s and x which is a global parameter. The dependence on a global parameter often leads to unexpected results and difficult debugging. >Would then Manipulate[Plot[s[h], {x, 0, 1}, PlotRange -> {0, 1}], >{h, 0, 1}] work? (The answer is yes.) So apparently, Plot is happy >with an "Expression", but Manipulate wants a "Function"? Why? Manipulate isn't restricted to functions. >Also, in Manipulate[Plot[x+h, {x, 0, 1}, PlotRange -> {0, 1}], {h, >0, 1}], x+h is no longer an "Expression", but is once again a >"Function", because of the context? Even though it's inside Plot >which is happy with an "Expression"? No, x+h doesn't become a function simply by making it an argument to Plot. >A personal note: I guess I'm a little frustrated that after a few >months of working with Mathematica, I still have to try things >before I know whether they'll work or not. I'm used to having a >clear picture of the grammar of the language that I'm working with, >but I'm struggling here. I don't have much to say here. I've been using Mathematica since version 1.2 and still find I need to try some things out before I know whether they will work as I want. This is particularly true of newer features like Manipulate that I don't use frequently.
From: Leonid Shifrin on 23 Jul 2010 07:12 Hi Sam, A short answer is that there are no functions in Mathematica, only expressions and replacement rules (except pure functions perhaps). When you define a "function" like s[x_, h_]:=x+h you really associate a certain global replacement rule with a symbol <s>. When evaluator sees a match, it rewrites according to this rule. There are no stack frames or activation records - it is a completely different mechanism that superficially resembles function calls (there is evaluation stack which is similar but not the same). So, <s> is always a Symbol. Generally, Mathematica at its hart is a rule-based engine, not a functional language. Functional layer sits already on top of it. So comparisons with Scheme or Lisp may be misleading. In particular, if you study Mathematica evaluation loop, you will see that the recursive part will be similar to Lisp (that expressions are evaluated before subexpressions normally), but the part related to rule application is not found in Lisp.You may want to check out some simple account explaining these things about Mathematica, perhaps some parts of the virtual book or documentation related to evaluation of expressions. I also dwelt somewhat on this in my book, www.mathprogramming-intro.org/ Regarding Manipulate, this behavior is related to scoping (Manipulate is a scoping construct and you relationship between <s> and <h> was originally defined outside of the scope of Manipulate). Hope this helps. Regards, Leonid On Thu, Jul 22, 2010 at 1:44 PM, Sam Takoy <sam.takoy(a)yahoo.com> wrote: > Thanks to all who responded! > > May I belabor this point a little. I understand how to make Manipulate > work and I understand functions. (I am a product of Scheme from with > Mathematica seems to have borrowed a few ideas.) > > My question is much more formal: What are the building blocks of > Mathematica, the formal language. When you say > > s = x+h > > what is s? > > Is it an "expression"? Does s represent x+h wherever it appears > (assuming x and h are unassigned at the time of s=x+h)? Apparently not > always: yes in s/.h->5, but not in Manipulate. > > So here, then is my "model" of Mathematica: > In s = x+h, s is an "Expression" > In s[x_, h_]:=x+h, s is a "Function" > > Manipulate expects a "Function" so that answers my question. > > Then what is > > s[h_] := x + h? Is it an "Expression" or a "Function" of h with a > parameter x? > > Would then Manipulate[Plot[s[h], {x, 0, 1}, PlotRange -> {0, 1}], {h, 0, > 1}] work? (The answer is yes.) So apparently, Plot is happy with an > "Expression", but Manipulate wants a "Function"? Why? > > Also, in Manipulate[Plot[x+h, {x, 0, 1}, PlotRange -> {0, 1}], {h, 0, > 1}], x+h is no longer an "Expression", but is once again a "Function", > because of the context? Even though it's inside Plot which is happy with > an "Expression"? > > A personal note: I guess I'm a little frustrated that after a few months > of working with Mathematica, I still have to try things before I know > whether they'll work or not. I'm used to having a clear picture of the > grammar of the language that I'm working with, but I'm struggling here. > > > On 7/21/2010 7:14 AM, dr DanW wrote: > > I ran into this problem yesterday. I don't know exactly why it > > happens, I think it has something to do with the way Manipulate > > localizes variables. To solve it, I use a trick I found that lets me > > take an expression built up of global symbols and localize the > > symbols. Your trivial example: > > > > s = x + h > > > > Make a function out of it. The Evaluate[] is necessary to evaluate s, > > which replaces it with x+h > > > > sfnc = Function[{x, h}, Evaluate[s]] > > > > Now the Manipulate[] works fine > > > > Manipulate[Plot[sfnc[x, h], {x, 0, h}], {h, 0.1, 1}] > > > > I find myself using this trick a lot. > > > > Regards, > > Daniel > > > > >
From: Nasser M. Abbasi on 23 Jul 2010 07:14
On 7/22/2010 2:44 AM, Sam Takoy wrote: > > A personal note: I guess I'm a little frustrated that after a few months > of working with Mathematica, I still have to try things before I know > whether they'll work or not. I'm used to having a clear picture of the > grammar of the language that I'm working with, but I'm struggling here. > Welcome to Mathematica programming :) In Mathematica, there is no language reference manual. Hence, one must try something to learn how it works. Its like you have a large box full of different tools, it takes time to learn which tool works best with which other tool and the best way to carry and move each tool. It is well known that Mathematica has a steep learning curve, and I think this is the main reason for that. But it seems that after more time with it, one starts to see common patterns of how things works and to see the logic behind things, but it does take time. May be years, not months? --Nasser |