weird behavior of plot

Can someone provide an explanation for the following behavior?

I define a function:

a=2480.65;
n[x_] := (1/x^2)*1/(Exp[a/x] – 1);
Plot[n[y], {y, 100, 1000}]
Plot[n[a], {a, 100, 1000}]

The first plot generates this:

while the second one looks like this:

Trivially the first one is correct as this should be a monotonically increasing function.
Is it something in the order of evaluation?
How can I be careful not to stumble upon this point in less easily verified cases?

I’m using MMA 9, with mac

=================

  

 

You’ve defined your function with a fixed parameter aa and then try to plot it with a variable aa.
– David G. Stork
Sep 25 at 22:14

=================

2 Answers
2

=================

Plot and Table and others “effectively use Block to localize variables.”
Let’s first look at your definition of n:

We can see that it depends on the (unevaluated!) global symbol a. That means when a changes its value, the function changes, too!

Block is used to temporarily change the value of a global variable. Observe the difference:

Block[{a = b}, n[a]]
(* 1/(b^2 (-1 + E)) *)

n[a]
(* 9.45746*10^-8 *)

In the first case, a is changed to b and then that is substituted for x in expression for n. So both a and x are changed to b. That makes the first code equivalent to

(1/b^2)*1/(Exp[b/b] – 1)

In the second code, it works as intended, since a retains its value of 2480.65.

The Plot command effectively evaluate the first code,

Block[{a = x}, n[a]]
(* 1/((-1 + E) x^2) *)

except it does it with numeric values substituted for x. So effectively you’re plotting a constant over x^2.

To avoid it, you should avoid having your function definitions depend on global variables, whenever possible. If the global variable is not intended to be a fixed constant, then you should make it an explicit argument of the function. (Such as David Stork has shown while I’ve been typing.)

n[x_, a_] := 1/(x^2 (Exp[a/x] – 1));

This is what probably should be done 99% of the time.

Sometimes it is intended to be a constant. If it is in a package, then it should be in a private context; see Contexts and Packages. Sometimes I’m lazy or the code is temporary, and the constant is a number that appears in several places. In that case, I might use one of the following two ways. First:

Block[{x},
n[x_] = (1/x^2)*1/(Exp[a/x] – 1);
]

Second:

With[{a = 2480.65`},
n[x_] := (1/x^2)*1/(Exp[a/x] – 1);
]

In both cases, we can see that the value of a appears in the exponent. In the first case the use of Set (=) instead of SetDelayed (:=) causes the right-hand side to be evaluated before the definition is stored; that is how the value of a is inserted. In the second, the value is injected with With; this rewriting of the rule causes the formal parameter x to be renamed x$; see, for example, Variables in Pure Functions and Rules. This is to protect the definition from having a value inject for x in the pattern x_, which would break the definition.

  

 

To summarize, are you saying that whenever I wish to use constants (like physical constants), in my function definition, I should use a construct which would force evaluation of the RHS before storing the definition? Would using the Function construct instead of SetDelayed for initial definition of the function do the job too (without other workarounds)?
– Yair M
Sep 26 at 4:38

  

 

@YairM Function has the attribute HoldAll, so the constant a would be unevaluated, unless you used Evaluate: Function[x, Evaluate[body]]. In other words, it has the same problem. Another approach, which you see used by Mathematica, is to use long names that are unlikely to be used for simple parameters in Plot. I’m sure many users just remember not to use a constant as a variable, but it’s a bug waiting to happen. I sometimes start constants with $ and not variables or functions: $a = 2480.65. it’s still a lurking bug, but avoidable if I stick to my convention.
– Michael E2
Sep 26 at 10:19

  

 

Thanks for the clarification
– Yair M
Sep 26 at 12:32

  

 

How do I use the private context approach? Should it read Private`a=2480, and then n[x_]:=(1/x^2)*(Exp[Private`a/x]-1)^(-1)?
– Yair M
Sep 28 at 4:42

  

 

@YairM Something like that. I usually use a lower-case name, like const`a. By private, I meant a context you make up. (More often, I use an explicit parameter, n[x_, a_] and not the context approach).
– Michael E2
Sep 28 at 9:52

You defined a function of a single variable, and then try to plot it as a function of a different variable.

This seems to be what you’re seeking:

n[x_, a_] := 1/(x^2 (Exp[a/x] – 1));
GraphicsColumn[
{With[{a = 2480.65},
Plot[n[a, y], {y, 100, 1000}, AxesLabel -> {“y”, “n[2480.65,y]”}]],
With[{x = 1000},
Plot[n[a, x], {a, 100, 1000}, AxesLabel -> {“a”, “n[a, 1000]”}]]}]

  

 

Why is a a variable? I defined it before as a constant? when I call a function, i.e. n[x], isn’t the argument I call it with treated as a local/temporary variable, regardless of the name I use?
– Yair M
Sep 26 at 4:20

  

 

No. You defined n for a specific value of a; you cannot change it thereafter. To do so, you must make your function a function of a. For the same reason you cannot define a function for the perimeter of a circle as 2πr2 \pi r and then change rr and then change π\pi!
– David G. Stork
Sep 26 at 18:26