‌

Functions

Functions are common to all programming languages. They work exactly like the name suggests. A single input or set of inputs is mapped to a single output.

In Mathematica, functions are defined using variables followed by an underscore square brackets and can be defined with either = or := , which has the same meaning as with variables.

= uses the immediate values of the right hand side while := recalculates these when called for.

The := definition works most similarly to standard programming languages and is the definition I would suggest using by default

Here we'll define a simple function to add two primes using :=

 primeSum[n1_,n2_]:=Prime[n1]+Prime[n2]
primeSum[1,10]

 31

The same works with plain =

 primeSum[n1_,n2_]=Prime[n1]+Prime[n2];
primeSum[1,10]

 31

Differences between = and :=

Let's write a more complex function that moves a position around randomly. This position could be the position of an atom, say as hydrogen. Let's start it out at the origin.

 hydrogenPosition={0,0,0};

Now we'll define a function to move our hydrogen around randomly and return where it is now.

 moveOurH[]:=
  Row@{
    "H is at:",
    hydrogenPosition+=
      {
        RandomReal[{-1,1}],
        RandomReal[{-1,1}],
        RandomReal[{-1,1}]
        }
    }
moveOurH[]

 Row[{"H is at:", {-0.839815, 0.504928, -0.876682}}]

We can move it again and again, and it'll randomly walk around:

 moveOurH[]
moveOurH[]
moveOurH[]

 Row[{"H is at:", {-0.523173, -0.378415, -0.278032}}]

 Row[{"H is at:", {-0.464874, 0.338277, -0.101727}}]

 Row[{"H is at:", {-0.973597, 0.327556, -0.682705}}]

Now let's try to do the same, but using =

 hydrogenPosition={0,0,0};
moveOurH[]=
  Row@{
    "H is at:",
    hydrogenPosition+=
      {
        RandomReal[{-1,1}],
        RandomReal[{-1,1}],
        RandomReal[{-1,1}]
        }
    };
moveOurH[]
moveOurH[]
moveOurH[]

 Row[{"H is at:", {-0.939441, 0.210649, -0.231079}}]

 Row[{"H is at:", {-0.939441, 0.210649, -0.231079}}]

 Row[{"H is at:", {-0.939441, 0.210649, -0.231079}}]

You'll notice our position doesn't change. That's because the right hand side was evaluated as the function was defined.

Note that this is not always a bug. Sometimes this can be a feature as there are instances where having most values set is useful.

Function

There is also a special object called a Function which is defined as follows:

 Function[{var1,var2,var3,...,varn}, code]

This is useful primarily in complicated code when a simple function needs to be used just once or twice and it is not worth defining a full function to do this.

This form of function can also be defined as follows:

 (code&)

where var1,var2,var3,...,varn are replaced by ``````#1,#2,...,#n in the code. For example:

 Function[
  {a,b,c},
  {
    {"a is:",a},
    {"b is:",b},
    {"c is:",c}
    }
  ]

could be written as:

 ({
  {"a is:",#1},
  {"b is:",#2},
  {"c is:",#3}
  }&)

And to see that they are in fact the same function. We call the first:

 Function[
  {a,b,c},
  {
    {"a is:",a},
    {"b is:",b},
    {"c is:",c}
    }
  ][1,2,3]

 {{"a is:",1},{"b is:",2},{"c is:",3}}

And then the second:

 ({
  {"a is:",#1},
  {"b is:",#2},
  {"c is:",#3}
  }&)[1,2,3]

 {{"a is:",1},{"b is:",2},{"c is:",3}}

And note that they give exactly the same output.

In Mathematica these are known as pure functions, to distinguish them from functions defined the way we've done before.