Arrays, Vector Algebra and Graph Plottings

Introduction

One of the powers of computers is their ability to perform a large number of calculations in a short time. In order to make effective use of this, it is necessary to organise and keep track of all the values involved in calculations and the results that are being generated in an efficient way. One way of doing this is to organize the data by placing them in arrays.

As mentioned last week, the NumPy package is directly available in the IPython console in Spyder, so at this stage you don't really have to worry about the distinction. Python can work with lists of numbers, words or names, but these cannot be used for as many mathematical functions as arrays, so for now we will only use arrays.

An array is a systematic arrangement of objects (usually numbers) in rows and columns

• 1D array: an array with one row (or column). A vector is an example of a 1D array.
• 2D array: an array of N rows and M columns, where N>1 & M>1. Matrices are examples of 2D arrays. Data entered into a spreadsheet can also be thought of as a 2D array.
• nD array: an array consisting of n dimensions. This is a generalization of 1 and 2D arrays. The position of each data point in the array is represented by n integer indices. We will not be dealing with arrays of more than 2 (or maybe 3) dimensions.

The first session was mainly concerned with using Python as a calculator -- performing a range of mathematical operations on single values. This second session is concerned with 1D arrays, how they are handled and some of the uses to which they can be put, specifically vector algebra and graph plotting.

Useful Links

• Array Creation -- routines for creating NumPy arrays
• Array Sorting and Searching -- methods of sorting arrays, searching and counting them.
• Linear Algebra -- including dot and cross products, matrix manipulations
• Array Manipulation -- more advanced array manipulation tools
• Plotting options -- Advanced options and examples on the matplotlib website

Syntax Summary

Arrays

Making 1D Arrays containing specific values

Arrays are the basic structures used in NumPy. Consequently all of the array creation and manipulation techniques that are listed below are contained in the NumPy package.

Generating 1D Arrays

All of these functions are contained in the NumPy package.

Vector Manipulation

Vector manipulations are also contained in the NumPy package.s

Plotting

Basic Plotting

MatPlotLib is a python based plotting package. It is what we are using to make all of the plots in this course. So, all of the plotting functions below are contained in the MatPlotLib package.

† : This applies the sine function to each member of the array x, to produce a sine wave graph. Other functions such as addition, multiplication, log, tan etc. can also be used.

Formatting and Saving Plots

To edit the format of the line: plot(x, x**2, “line colour and style code”, linewidth = N, label = “name for legend”), for example

plot(x, x**2, “r-”, linewidth = 6, label = “x squared”)

More format options can be found in the object inspector or on the matplotlib website.

To edit the format of the plot:

Worksheet

from pylab import *

Work through the explanations and examples given below before attempting the exercises. Generating and manipulating arrays is a fundamental skill that we will make use of in every class and all the assignments in this course. Similarly, be sure that you are comfortable with making and saving plots, we will also be making plots most weeks and in the homework assignments.

Generating Arrays

There are several ways to make an array:

1. Explicitly fill it with the elements you desire. Use the print( ) function to view the array.

   x = array([7,5,5,2,1,4,9])
   print (x)

2. Make and print an array of ones or zeros of the size you request.

   y=zeros(10)
   print (y)
   
   z=ones(15)
   print (z)

3. Make an evenly spaced array 'a' from a minimum value that we shall define as a_start, to a maximum value (a_stop), with a total number of points (a_points) between the starting and ending values.

   a_start = 0
   a_stop = 10
   a_points = 4
   
   a = linspace(a_start, a_stop, a_points)
   print (a)

   
   Note: normally, we will choose a_start < a_stop so as to get an array where the entries are increasing in value. However, you can choose a_start = a_stop (you'll get an array with every value equal) or a_start > a_stop (you'll get an array where the values decrease).
   
   Note: you do not need to define start, stop, step as variables, you can simply create the array in a single command:
4. Make an array of numbers covering the range from a_start up to (but not including) a_stop, with a gap of a_step between each value. Note: the largest value in the array will be smaller than a_stop.

   a_start = 0
   a_stop = 10
   a_step = 1
   
   b = arange(a_start, a_stop, a_step)
   print (b)

   
   Note: Normally, you wouldn't bother defining a_start, a_stop, a_step, but would just write

   b = arange(0,10,1)

   You can generate the same array using:

   c = arange(10)
   print(c)

   When we just use arange(10), the function assumes that we wish to start at zero and have a step size of 1.
   Note: when using arange, if all the inputs (a_start, a_stop, a_step) are integers the array that's returned is populated with integers (not floats).
   Note: you can have a negative step size, a_step, but in this case a_stop must be smaller than a_start. For example:

   d = arange(0, -10, -2)

Print this array made using arange and compare it to one generated using the linspace function to make sure you understand the difference. linspace() should be used when covering the range is the important thing, whereas arange() should be used when the step size is more important.

Variable types in Arrays

The computer will recognise an array as either an integer or a float. If you want to define an array as an integer you can do any of the following:

x = array([1,2,3])
x = array([1,2,3], dtype=int)

Look in the variable explorer, and you will see that x shows up as an array of size (3,) and of type int (or int32 or int64). To get a floating point array, you can do any of the following:

x = array([1, 2, 3], dtype=float)
x = array([1., 2., 3.])

In the first case, we have explicitly asked for the type of the array to be float rather than int. In the second case, we have entered the numbers as floats. Note that if you enter a mix of integers and floats, the array that is returned will contain all floats.

Calculations with Arrays

All of the calculation techniques that were introduced last week can also be used on arrays. We can perform basic arithmetic using arrays, use powers, exponentials, logarithms, trigonometric functions and much more. In this section, we give a quick overview of some of the more basic functionality. Virtually every week, we will be learning additional ways of manipulating and calculating with arrays and it will all build on the basics here. So it is important to be comfortable with the basic ideas. For now, we will just treat an array as a list of numbers. Later, we will see how the methods we introduce here can be applied to vector calculations and also to making graphs and analyzing experimental data.

We start by defining two arrays (as floats) in the console as

x = array([1,2,3], dtype=float)
y = array([3,2,1], dtype=float)

Addition and Subtraction

Addition and subtraction of a constant

You can add or subtract a constant to every term in the array by entering

z = x + 3
print (z)
z = y - 3
print (z)

Addition and subtraction of arrays

You can add and subtract arrays in exactly the same way as we did for integers and floats:

z = x + y
print (z)
z = x - y
print (z)

This adds/subtracts each of the entries in the second array to/from the corresponding entry in the first array.

Note: If you try to perform array operations on arrays of different shapes or sizes, you will see the error ValueError: shape mismatch: objects cannot be broadcast to a single shape. For example

a = array([2, 4, 6])
b = array([3, 4])
a + b # This will not work

Multiplication and Division

Multiplication and division by a constant

You can also multiply or divide an array by a constant. This multiplies or divides every element in the array by the specified value. For example

z = 3*x
print (z)
z = x/5.
print (z)

Multiplication and division of arrays

It is possible to multiply and divide arrays of the same length. For example

z = x * y
print(z)
z = x / y
print (z)

This multiplies or divides each of the entries in the first array by the corresponding entry in the second array. As with addition/subtraction, if the two arrays are of a different length, then multiplication and division will not work

Powers and Roots

It is possible to raise an array x to the power n. When doing this, every element in the array is raised to the specified power. For example, we can first generate an array of integers from 0 to 9

i = arange(10)
print (i) 

Then, square the entries in the array using

i_sq = i**2
print (i_sq)
i_sq = pow(i,2)
print (i_sq)

Similarly, we can calculate the square root of an array

i_sqrt = sqrt(i)
print (i_sqrt)
i_sqrt = i**0.5
print (i_sqrt)

It is straightforward to make a plot of i² against i. We met the syntax briefly last week. To make the plot, simply type

plot(i, i_sq)
plot(i, i_sqrt)

For now, we will not worry too much about formatting the plot. Later on, we will learn how to do this correctly by adding axis labels, legends, etc.

Trigonometry

Next, let's calculate the values of some trigonometric functions using arrays. First, we define the values we are interested in

x = linspace(0, 360, 13)
print (x)

This gives us points evenly spaced between 0 and 360 degrees. We then want to turn these values into radians and calculate the sine of the angles

y = radians(x)
print (sin(y))

Note, computers often have a very small rounding error. We know that sin(360°) should return 0. This is the last entry in the array and it is not zero. Due to rounding error, the result is -2.44929360e-16. Though this kind of error is very small, it can produce problems. For example, try taking the square root of sin(360°). Since it is impossible to take the root of a negative number, so this returns an error and the value nan (Not A Number).

Once again, we can make a plot. If we were to just make the plot, it would be put on the same axes as the plot we made earlier. So, we first ask for a new figure and then plot the sine curve

figure()
plot(y, sin(y))

You will probably notice that the sine curve doesn't look very smooth. That's because we have only used 13 points to plot the whole thing. To make a better curve, repeat what's above but use 100 points (or more).

Application: Vector Algebra

In the above sections, we have introduced various ways to manipulate arrays. Now, we will apply these methods to allow us to perform vector algebra calculations. Some of the operations that we introduced are applicable to vectors (for example addition and subtraction). But others are not (multiplication, trigonometric calculations).

The following gives the operations which are applicable to vectors as well as introducing some functions specifically designed for performing vector algebra.

Let us start by defining two arrays consisting of three numbers:

x = array([3,5,2], dtype=float)
y = array([2,4,3], dtype=float)

We can then interpret each of these as a 3D vector:

x = 3i + 5j + 2k and y = 2i + 4j + 3k

Vector addition and subtraction

Addition and subtraction of vectors can be done as above, for example

z = x + y
z = x - y

Multiplication by a constant

We can re-scale a vector by multiplying every entry by a constant:

z = 1.8*x

Dot and cross products

There are functions in NumPy to calculate the dot and cross products between vectors:

dot(x,y)
cross(x,y)

It ought to be easy to check the dot product, but a little more work to verify the cross product.

Vector magnitude

Finally, the magnitude of a vector (the square root of the sum of the squares of each element) can be found using

norm(x)

Plotting and Formatting Graphs

We have already made simple plots. Now, we will learn how to make more complex plots and format them appropriately for inclusion into written reports or presentations. The plotting routines that we will use are provided within the Spyder console through the matplotlib library.

x = linspace(0, 2*pi, 100)
figure()
plot(x, sin(x))

plot(x, cos(x))

clf()

figure(n)

• Choose the style of the lines on the plot. The default behaviour is to plot the first line in blue, the second in green and so on. There are many other line style, point style and colour options available. You can overwrite this by specifying the linestyle you desire, for example

  plot(x, sin(x), "r--" )
  

  Shown bellow are a few options, but there are many more which you can find by looking up the plot() online documentation..

  Colour	Red	Blue	Green
  Code	r	b	g
  Line style	Solid	Dashed	Dotted
  Code	-	--	:
  Marker Style	Plus	Cross	Circle
  Code	+	x	o

• Change the marker size by specifying the value

  plot(x, sin(x), 'yo', markersize=2)
  

• Change the line width by specifying the value

  plot(x, sin(x), linewidth=2)
  

• Add a label to the line. This will be used later when making a legend, but will have no immediate effect when the line is plotted.

  plot( x, sin(x), label='sin(x)' )
  

  Putting this all together, the standard syntax for plotting a formatted line is:
  plot(x, y, “line colour and style code”, linewidth = n, label = “name for legend” )
  Then, we can format the rest of the graph. This is done after the lines are plotted by
• Adding labels on the axes

  xlabel("x", fontsize = 12)
  ylabel("y", fontsize = 12)

• Adding a title

  title("My plot of sin(x) vs x", fontsize=16)
  

• Adding a legend. If you labelled the lines when plotting them, all that's needed is

  legend()
  

• Adding a grid

  grid()
  

• Changing the limits of the plot

  xlim([0, pi])
  ylim([0, 1])

An example of a figure incorporating these is:

x = linspace(0,2,100)
clf()
plot( x, x**2, 'r-', linewidth = 6, label = 'n = 2' )
plot(x, x**3, 'k', linewidth = 4, label = 'n = 3' )
plot( x, x**4, 'b--', linewidth = 4, label = 'n = 4' )
xlabel("x", fontsize = 12)
ylabel("x to the power n", fontsize = 12)
title("A plot of some polynomials")
legend(loc='best' )
grid()

It is important to take the time to make sure the plot looks good before saving it. It is critical that everything on the plot is legible, and that the lines are easily distinguished and the font size is appropriate -- especially if the figure will be shrunk to fit in a report or projected in a large lecture hall. Plots should have labels on the axes and a legend if appropriate.

Saving figures

Once you produce a a graph, you can automatically save the resulting plot as an image on your computer, to include in other reports or to share with others.

You can save the plot by typing:

savefig('some_filename.png')

Logarithmic Arrays and Plots

So far, we have been dealing with arrays which are linearly spaced and also plots on a linear scale. It is straightforward to make both log-scale arrays and also log plots (where either the x-axis, y-axis or both axes are on a log scale).

The logspace command is used to generate an array of points evenly spaced on a log10 scale from 10^a_start to 10^a_stop with a_points entries

a_start = 0
a_stop = 2
a_points = 10
a = logspace(a_start, a_stop, a_points)
print (a)

It is straightforward to make plots where one or both of the axes is on a log-scale. For example, using the array that we just made, we can make a log-log plot of ln(a) against a:

b = log(a)
figure()
loglog(a, b)

Note: When you take the log of an array, the default behaviour is to use natural log (base e). However, when making logspace arrays and log plots, the default is to use log base 10. This may seem strange, but it does make sense as most calculations are done base e, but it's much easier to read a log plot in base 10.

Or, plot either the x-axis or y-axis on a log scale:

figure()
semilogx(a,b)
figure()
semilogy(a,b)

Excercises

1. Arrays [1¾]

1. Using arange() or linspace(), generate an array, a, containing the numbers 0 to 10 in increasing order
2. Using arange() or linspace(), generate an array, b, containing the numbers 10 to 0 in decreasing order
3. Calculate 2 × a
4. Calculate a + b
5. Calculate a * b
6. Calculate a/b
7. Test where a is equal to b (use the equality operator ==)

2. Vectors [1¼]

Define arrays to represent the following vectors:

a = 6.0i + 5.0j + 0k and b = 3.0i - 2.0j + 1.0k

1. Find the dot product a.b. Is this equal to the dot product b.a?
2. Find the cross product a x b. Is this equal to the cross product b x a?
3. Find the length of the vector a x b.
4. Calculate both a.a and |a|² and verify that they give the same numerical answer (use the equality test ==). What is the value?
5. Calculate the angle between a and b. Recall that a.b = |a| |b| cos θ, where θ is the angle between the two vectors.

3. Plotting [1]

Plot and save a graph of sin(x), cos(x) and sin(2x) for x between 0 and 2π. Make sure that:

• The range of the x-axis is from 0 to 2π.
• Each of the lines of the plot are a different colour and style
• The plot has labels on the x and y axes
• The plot has a legend.

Figure: An example of a well presented graph, showing various trigonometric functions plotted in the range 0 to 2π.

4. Log plots [1]

1. Generate a log-space array of values for x between 0.1 and 10 (i.e. 10^-1 to 10¹, not 10^0.1 to 10¹⁰).
2. Make a plot of x² against x. By choosing the correct plot type (one of plot(), loglog(), semilogy(), semilogx()), make the plot a straight line.
3. Add lines for x³ and x⁴ against x.
4. Complete the plot with axis labels, legend, etc and save the formatted graph.