Defining Your Own Function: Elementary Introduction to the Wolfram Language

40	Defining Your Own Functions

As we’ve seen in this book, there’s a huge amount that can be done with functions that are already built into the Wolfram Language. But you can go even further if you define your own functions too. And the Wolfram Language has a very flexible way of letting you do this.

Let’s start with a typical, simple example of a function definition.

This defines a function pinks that takes any argument:

pinks[n_] := Table[Pink, n]

This uses the function definition:

pinks[5]

pinks[10]

How does this function definition work? The idea is that the := defines a value for the pattern pinks[n_]. When you ask for pinks[5], this matches the pinks[n_] pattern, and the value you’ve defined for this is used.

But this is just the beginning of the story of function definition in the Wolfram Language. Because in the Wolfram Language, you can give a definition for anything.

Here’s a list of expressions:

{f[Red], f[Yellow], f[Green], f[Orange], f[Magenta]}

Define values for f[Red] and f[Green]:

f[Red] = 1000; f[Green] = 2000;

Now f[Red] and f[Green] are replaced by the values defined; the other cases are left unchanged:

{f[Red], f[Yellow], f[Green], f[Orange], f[Blue]}

Now let’s add a definition for the pattern f[x_]. The Wolfram Language will use this whenever the special definitions for f[Red] and f[Green] don’t apply.

Define a value for f with any argument:

f[x_] := Framed[Column[{x, ColorNegate[x]}]]

If the special cases don’t apply, the general definition is used:

{f[Red], f[Yellow], f[Green], f[Orange], f[Blue]}

Clear definitions for f to make sure nothing gets confused later:

Clear[f]

As another example, let’s do the classic computer science exercise of defining the factorial function. Start by saying that factorial[1]=1. Then define how to compute factorial[n_] recursively in terms of another instance of factorial.

Give a recursive definition of factorial:

factorial[1] = 1; factorial[n_Integer] := n*factorial[n - 1]

Ask for factorial[50]:

factorial[50]

There’s also a built-in factorial function, which gives the same result:

50!

Instead of having definitions for factorial[1] and factorial[n_] we could have had a single definition and used If. But having separate definitions for each case tends to make things much easier to read and understand.

An alternative definition using If:

factorial[n_Integer] := If[n == 1, 1, n*factorial[n - 1]]

It’s nice to be able to break out special cases, but the real power of being able to make definitions for anything comes when one goes beyond simple function[argument] cases.

As a simple example, consider making a definition for plusminus[{x_,y_}].

Define a value for a pattern:

plusminus[{x_, y_}] := {x + y, x - y}

Use the definition:

plusminus[{4, 1}]

A much less elegant form based on a traditional function[argument] definition:

plusminus[v_] := {v[[1]] + v[[2]], v[[1]] - v[[2]]}

It’s very common to want to define a function that applies only to objects with a certain structure. This is easy to do with patterns. Here’s an example.

A list with some Framed objects:

{a, Framed[b], c, Framed[{d, e}], 100}

Define a function that applies only to framed objects:

highlight[Framed[x_]] := Style[Labeled[x, "+"], 20, Background -> LightYellow]

Apply highlight to each element of a list; it knows what to do when it’s given something framed:

highlight /@ {a, Framed[b], c, Framed[{10, 20}], 100}

This definition applies to anything with head List:

highlight[list_List] := highlight /@ list

Now you no longer have to use /@:

highlight[{a, Framed[b], c, Framed[{10, 20}], 100}]

Give a general case, to use if none of the special cases apply:

highlight[x_] := Style[Rotate[x, -30 Degree], 20, Orange]

This uses the special cases when it can, then the general case when nothing else applies:

highlight[{a, Framed[b], c, Framed[{10, 20}], 100}]

Exercises

Check your answers in the Wolfram Cloud

Note: These exercises involve defining functions. Remember to use Clear to get rid of definitions once you’re finished with each exercise.

40.1Define a function f that computes the square of its argument. »