# Mathematica and the Wolfram language on Raspberry Pi

#### Lists

Lists are a fundamental part of the Wolfram language. Other programming languages use lists as well (e.g., Python). Lists also are sometimes referred to as arrays or matrices; however, in the Wolfram language, lists, arrays, and matrices are three distinct things. That said, the three are pretty similar: An array is effectively a list of functions, and a matrix is a list of lists.

In the Wolfram language, a list is contained in curly brackets:

```{1, 2, 3, 4, 5}
{"this", "is", "a", "list", "of", "strings"}```

The curly brackets are shorthand notation for creating a list; the full function for creating a list is:

`List[1, 2, 3, 4, 5]`

However, when you run this code, it is automatically changed to the curly bracket format, so it is usually easier just to use the shorthand notation.

Building lists by manually entering data is a very long-winded process, and for some applications, it is much better to do this in an automated fashion. Luckily, the Wolfram language has you covered, with a number of ways in which to build lists automatically. The first of these methods is the `Range` function, which autofills a list of numbers:

`Range[3, 10, 1/2]`

This code will output a list of values starting at 3 and finishing at 10, with a step size of 1/2 (Example D).

The `Table` function is essentially a more complex version of the `Range` function that allows you to determine start, end, and step size values, and it also introduces an operator that acts on the number before building the list. For example,

`Table[i+1, {i, 3, 10, 1/2}]`

takes the values from the preceding `Range` function and adds `1` to each value, giving the output shown in Example E.

You can change the calculation within the `Table` function from `i+1` to anything you like (e.g., `i^3` or `i*3`).

To create a matrix, just create a list of lists:

`matrix = {{5, 1, 3}, {7, 3, 0}, {9, 2, 4}}`

You can then display this in a 2D format using the `MatrixForm` function,

`MatrixForm[matrix]`

Which gives the output in Example F.

You can even apply functions to an entire list because the Wolfram language treats them as a single entity. For instance,

`Sqrt[{5, 1, 3, 8, 9, 4}]`

gives the output in Example G.

Last, but not least, you can pull out individual values from within a list very easily using:

```list = {1, 2, 3, 4, 5, 6}
2 * list[[1]]```

You can also perform functions on individual elements within the list and then write the result back to the list itself:

`list[[4]] = Sqrt[list[[4]]]`

The output of those last few commands is shown in Example H.

As you can see, the final `Sqrt` command only performed the square root function on the fourth element in the list, changing it from 4 to 2, unlike the previous square root example, where the entire list was changed.

Bear in mind when using lists in the Wolfram language that the index of a list starts at `1` – in other words, if you want to address the first item in a list, you use the code `list[[1]]`. In many programming languages (including Python), a list index starts at `0`.

#### Variables

In programming, a variable is a symbol or string that represents a quantity in a mathematical or computational expression. It is convenient to use variables when you have a number or expression that repeats. Additionally, if you ever need to make a change to a number in a calculation, you can use variables instead of actual numbers. In that way, if you want to change a value, you won't have to change every instance of that expression – all you have to do is change the definition of the variable.

For example, say you know the radius of a circle is 5, and you are asked to make a number of calculations to establish the magnitude of the diameter, circumference, and area of the circle. If you did not have variables, you would have to type:

```diameter = 2 * 5
circumference = 2 * Pi * 5
area = Pi * 5^2```

Now if you were told the radius is actually 7, you would have to change three instances of the old radius, 5, to the new radius, 7. Imagine instead that you used variables to achieve this same result:

```radius = 5
circumference = 2 * Pi * radius

Now, if you were told to change the radius to 7, you would only have to change one parameter – the definition of the variable `radius` at the top. This is only a simple example to demonstrate a point, but as I am sure you can imagine, in a long and complicated series of calculations variables are extremely useful for this reason.

If you have typed in and executed any of the above code, you will have realized that for every input line you type in, an output line is generated in Mathematica. If you would rather not see this output, you can add a semicolon to the end of the line. Not only does this neaten up the output by removing unnecessary feedback, it also significantly speeds up the calculation of the results – because instead of using up CPU time to output results to the user interface, Mathematica can use all of the CPU available to it for the calculation process. For small programs like those I have used here, this is not such a problem, but it is good practice to get into the habit early of putting a semicolon at the end of every line for which you do not require output.

In the above example for the circle parameters, you are defining the radius, so you do not need or want Mathematica to generate output for this line. Therefore, you can adapt the code to

```radius = 5;
circumference = 2 * Pi * radius

and press Shift+Enter to run. Notice the difference in output from the previous example that did not include the semicolon.

Express-Checkout as PDF

Pages: 2

Price \$2.95
(incl. VAT)

SINGLE ISSUES

SUBSCRIPTIONS

TABLET & SMARTPHONE APPS

UK / Australia

## Related content

• Exploring the Pixy sensor with Mathematica

We show how to track objects and plot their movement using the Pixy camera and the Mathematica package that's included with Raspbian.

• The Pi Wire

Things move quickly in the Raspberry Pi ecosystem. This regular column rounds up the best Raspberry Pi and open hardware news to keep you up to date on the latest projects, products, and events.

• Math, Music, and Cat Toys

Welcome to Raspberry Pi Geek – the first and only print magazine dedicated to the amazing Raspberry Pi mini-PC and the open hardware revolution. We ring in the new and old in this issue. (Actually, nothing is really very old with the Raspberry Pi, but we follow up on some previous themes, including a report on how it went for the wind-turbine-powered Raspberry Pi we described last time.)

• On the DVD