Turn expression into function

Question

I'm new to Mathematica and I spent the last hour trying to make the expression

expression = 
  3 + 2 cos[t] + 3 cos[2t] + 5 cos[3t] + 7 cos[4t] + 9 sin[t] +  4 sin[3t] + 5 sin[4t]

into a function of t. I tried

f[t_] := expression

but it didn't work.

Answer 1

Evaluate is your friend

expression = 
 3 + 2 Cos[t] + 3 Cos[2 t] + 5 Cos[3 t] + 7 Cos[4 t] + 9 Sin[t] + 
 4 Sin[3 t] + 5 Sin[4 t];
f[t_] := Evaluate[expression];
f[0]

20

Edit: This is the same as

f[t_] = expression;

Answer 2

First, note that sin and cos are not built-in functions; I shall use Sin and Cos.

Please see: Scoping in assigning a derivative

Typically you do not want to make a definition for a parameter t without protecting t on the RHS. That is to say, using Evaluate or f[t] = can leave t to evaluate to its present global value.

If you define expression with := you will make sure t remains unevaluated there as well.

t = "Fail!";

expression := 
  3 + 2 Cos[t] + 3 Cos[2 t] + 5 Cos[3 t] + 7 Cos[4 t] + 9 Sin[t] + 4 Sin[3 t] + 5 Sin[4 t]

Block[{t},
  f[t_] = expression;
]

f[0.7]

6.84554

The method above is automated in the abstraction localSet defined here:

• How to make a function like Set, but with a Block construct for the pattern names

Answer 3

Using Evaluate to make a function is not a robust solution. A true function is one which takes all its input from its arguments and return its result from its last return value and has no side effects out of this.

Here is an example why Evaluate does not make f[t] a true function

expression = Cos[t] + globalX;
globalX = 1;
f[t_] := Evaluate[expression];

In the above, f[t] took part of its input (the t only) via the argument, but the other part (x) was accessed by using a global variable. Accessing global variables from inside a function is not a good way to do things (tm).

It is better to do it the good old fashioned way, and put the body of the function inside the function, and pass it all its input via arguments

f[t_, x_] := Cos[t] + x

The difference is important. If one writes some Module and uses symbols not passed via arguments and also not local to the module, then the notebook interface will show this symbol with different color. This can be important in telling one something is wrong. This becomes more important when working with lots of functions and more complex program. By Evaluating an external expression, one does not have the advantage of this check.

Compare the color of x used by the function in these 4 cases:

and

and

a black colored x will immediately tell one they are accessing a global x (a symbol with different context at least), and to correct this. The third and fourth examples above are true functions, while the first two are not.

Answer 4

While other answers are valid, I believe you could just use something as straightforward as

f = Function[t, Evaluate@expression]

Let's see how it works:

In[1]:= expression = 3 + 2 cos[t] + 9 sin[t]
                       + 3 cos[2t]
                       + 5 cos[3t] + 4 sin[3t]
                       + 7 cos[4t] + 5 sin[4t];
In[2]:= ClearAll[f]

In[3]:= f = Function[t, Evaluate@expression]
Out[3]= Function[t, 3 + 2 cos[t] + 9 sin[t]
                      + 3 cos[2t]
                      + 5 cos[3t] + 4 sin[3t]
                      + 7 cos[4t] + 5 sin[4t]]

Then,

In[4]:= f[0]

evaluates:

Out[4]= 3 + 17 cos[0] + 18 sin[0]

(Mathematica only has definitions for capitalized Cos and Sin, that's why no more simplifications for your expression are provided.)

You may skip the rest of the answer if this solution is enough for you, and you are not interested in Mathematica subtleties.

---

However, there is a subtle aspect that may cause unexpected problems in the future. In[3] would modify the “own values” of symbol f:

In[5]:= OwnValues[f]
Out[5]= {HoldPattern[f] :>
           Function[t, 
                       3 + 2 cos[t] + 9 sin[t]
                         + 3 cos[2t]
                         + 5 cos[3t] + 4 sin[3t]
                         + 7 cos[4t] + 5 sin[4t]]}

and if you try to add some modifications to your definition then, you could unexpectedly bump into error:

In[6]:= f[t_, shift_] := shift + f[t]

(Check out the Out[5] error message if you want.) Definitions like the one in In[5] deal with “down values” of f, contrary to “own values”.

You could use a bit more elaborate mechanism for assigning DownValues, in case you plan to use In[6]-like definitions for f extensively in the future:

In[7]:= nameToPattern = # :> Pattern[#, Blank[]] &;

In[8]:= defineWithExplicitArguments[listOfArgs_List, f_, expr_] :=
          With[{listOfPatterns = listOfArgs /. nameToPattern /@ listOfArgs}, (
            DownValues@f = DeleteCases[DownValues@f, _[_[_@@listOfPatterns], _], 1];
            Evaluate[f@@listOfPatterns] := expr)]

In[9]:= defineWithExplicitArguments[singleArgument_, f_, expr_] :=
          With[{pattern = singleArgument /. nameToPattern@singleArgument}, (
            DownValues@f = DeleteCases[DownValues@f, _[_[_@pattern], _], 1];
            Evaluate[f@pattern] := expr)]

Now, let's remove all definitions for f

In[10]:= ClearAll[f]

and we're free to use defineWithExplicitArguments for assigning “down values” to it:

In[11]:= defineWithExplicitArguments[t, f, expression]

In[12]:= f[0]
Out[12]= 3 + 17 cos[0] + 18 sin[0]

Additional definitions would work, too:

In[13]:= f[t_, shift_] := shift + f[t]

In[14]:= f[0, -3]
Out[14]= 17 cos[0] + 18 sin[0]

By the way, the In[13] definition could be added by means of defineWithExplicitArguments, as well. Let's check it:

In[15]:= f[t_, shift_] =.

Here, we redefined “two-arguments version” of f, and it does not calculate the shifted wave anymore:

In[16]:= f[0, -3]
Out[16]= f[0, -3]

Then,

In[17]:= defineWithExplicitArguments[{t, shift}, f, expression + shift]

makes it work again:

In[18]:= f[0, -3]
Out[18]= 17 cos[0] + 18 sin[0]