NumPyΒΆ
NumPy is not imported into sage initially. To use NumPy, you first need to import it.
sage: import numpy
The basic object of computation in NumPy is an array. It is simple to create an array.
sage: l=numpy.array([1,2,3])
sage: l
array([1, 2, 3])
NumPy arrays can store any type of python object. However, for speed,
numeric types are automatically converted to native hardware types
(i.e., int, float, etc.) when possible. If the value or
precision of a number cannot be handled by a native hardware type,
then an array of Sage objects will be created. You can do
calculations on these arrays, but they may be slower than using native
types. When the numpy array contains Sage or python objects, then the
data type is explicitly printed as object. If no data type is
explicitly shown when NumPy prints the array, the type is either a
hardware float or int.
sage: l=numpy.array([2**40, 3**40, 4**40])
sage: l
array([1099511627776, 12157665459056928801, 1208925819614629174706176], dtype=object)
sage: a=2.0000000000000000001
sage: a.prec() # higher precision than hardware floating point numbers
67
sage: numpy.array([a,2*a,3*a])
array([2.000000000000000000, 4.000000000000000000, 6.000000000000000000], dtype=object)
The dtype attribute of an array tells you the type of the array.
For fast numerical computations, you generally want this to be some
sort of float. If the data type is float, then the array is stored as
an array of machine floats, which takes up much less space and which
can be operated on much faster.
sage: l=numpy.array([1.0, 2.0, 3.0])
sage: l.dtype
dtype('float64')
You can create an array of a specific type by specifying the dtype
parameter. If you want to make sure that you are dealing with machine
floats, it is good to specify dtype=float when creating
an array.
sage: l=numpy.array([1,2,3], dtype=float)
sage: l.dtype
dtype('float64')
You can access elements of a NumPy array just like any list, as well as take slices
sage: l=numpy.array(range(10),dtype=float)
sage: l[3]
3.0
sage: l[3:6]
array([3., 4., 5.])
You can do basic arithmetic operations
sage: l+l
array([ 0., 2., 4., 6., 8., 10., 12., 14., 16., 18.])
sage: 2.5*l
array([ 0. , 2.5, 5. , 7.5, 10. , 12.5, 15. , 17.5, 20. , 22.5])
Note that l*l will multiply the elements of l componentwise. To get
a dot product, use numpy.dot().
sage: l*l
array([ 0., 1., 4., 9., 16., 25., 36., 49., 64., 81.])
sage: numpy.dot(l,l)
285.0
We can also create two dimensional arrays
sage: m = numpy.array([[1,2],[3,4]])
sage: m
array([[1, 2],
[3, 4]])
sage: m[1,1]
4
This is basically equivalent to the following
sage: m=numpy.matrix([[1,2],[3,4]])
sage: m
matrix([[1, 2],
[3, 4]])
sage: m[0,1]
2
The difference is that with numpy.array(), m is treated as just
an array of data. In particular m*m will multiply componentwise,
however with numpy.matrix(), m*m will do matrix multiplication. We can
also do matrix vector multiplication, and matrix addition
sage: n = numpy.matrix([[1,2],[3,4]],dtype=float)
sage: v = numpy.array([[1],[2]],dtype=float)
sage: n*v
matrix([[ 5.],
[11.]])
sage: n+n
matrix([[2., 4.],
[6., 8.]])
If n was created with numpy.array(), then to do matrix vector
multiplication, you would use numpy.dot(n,v).
All NumPy arrays have a shape attribute. This is a useful attribute to manipulate
sage: n = numpy.array(range(25),dtype=float)
sage: n
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.,
11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21.,
22., 23., 24.])
sage: n.shape=(5,5)
sage: n
array([[ 0., 1., 2., 3., 4.],
[ 5., 6., 7., 8., 9.],
[10., 11., 12., 13., 14.],
[15., 16., 17., 18., 19.],
[20., 21., 22., 23., 24.]])
This changes the one-dimensional array into a \(5\times 5\) array.
NumPy arrays can be sliced as well
sage: n=numpy.array(range(25),dtype=float)
sage: n.shape=(5,5)
sage: n[2:4,1:3]
array([[11., 12.],
[16., 17.]])
It is important to note that the sliced matrices are references to the original
sage: m=n[2:4,1:3]
sage: m[0,0]=100
sage: n
array([[ 0., 1., 2., 3., 4.],
[ 5., 6., 7., 8., 9.],
[ 10., 100., 12., 13., 14.],
[ 15., 16., 17., 18., 19.],
[ 20., 21., 22., 23., 24.]])
You will note that the original matrix changed. This may or may not be what you want. If you want to change the sliced matrix without changing the original you should make a copy
m=n[2:4,1:3].copy()
Some particularly useful commands are
sage: x=numpy.arange(0,2,.1,dtype=float)
sage: x
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1, 1.2,
1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9])
You can see that numpy.arange() creates an array of floats increasing by 0.1
from 0 to 2. There is a useful command numpy.r_() that is best explained by example
sage: from numpy import r_
sage: j=numpy.complex(0,1)
sage: RealNumber=float
sage: Integer=int
sage: n=r_[0.0:5.0]
sage: n
array([0., 1., 2., 3., 4.])
sage: n=r_[0.0:5.0, [0.0]*5]
sage: n
array([0., 1., 2., 3., 4., 0., 0., 0., 0., 0.])
numpy.r_() provides a shorthand for constructing NumPy arrays efficiently.
Note in the above 0.0:5.0 was shorthand for 0.0, 1.0, 2.0, 3.0, 4.0.
Suppose we want to divide the interval from 0 to 5 into 10
intervals. We can do this as follows
sage: r_[0.0:5.0:11*j]
array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. ])
The notation 0.0:5.0:11*j expands to a list of 11 equally space
points between 0 and 5 including both endpoints. Note that j is the
NumPy imaginary number, but it has this special syntax for creating
arrays. We can combine all of these techniques
sage: n=r_[0.0:5.0:11*j,int(5)*[0.0],-5.0:0.0]
sage: n
array([ 0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. ,
0. , 0. , 0. , 0. , 0. , -5. , -4. , -3. , -2. , -1. ])
Another useful command is numpy.meshgrid(), it produces meshed grids. As an
example suppose you want to evaluate \(f(x,y)=x^2+y^2\) on a
an equally spaced grid with \(\Delta x = \Delta y = .25\) for
\(0\le x,y\le 1\). You can do that as follows
sage: import numpy
sage: j=numpy.complex(0,1)
sage: def f(x,y):
....: return x**2+y**2
sage: from numpy import meshgrid
sage: x=numpy.r_[0.0:1.0:5*j]
sage: y=numpy.r_[0.0:1.0:5*j]
sage: xx,yy= meshgrid(x,y)
sage: xx
array([[0. , 0.25, 0.5 , 0.75, 1. ],
[0. , 0.25, 0.5 , 0.75, 1. ],
[0. , 0.25, 0.5 , 0.75, 1. ],
[0. , 0.25, 0.5 , 0.75, 1. ],
[0. , 0.25, 0.5 , 0.75, 1. ]])
sage: yy
array([[0. , 0. , 0. , 0. , 0. ],
[0.25, 0.25, 0.25, 0.25, 0.25],
[0.5 , 0.5 , 0.5 , 0.5 , 0.5 ],
[0.75, 0.75, 0.75, 0.75, 0.75],
[1. , 1. , 1. , 1. , 1. ]])
sage: f(xx,yy)
array([[0. , 0.0625, 0.25 , 0.5625, 1. ],
[0.0625, 0.125 , 0.3125, 0.625 , 1.0625],
[0.25 , 0.3125, 0.5 , 0.8125, 1.25 ],
[0.5625, 0.625 , 0.8125, 1.125 , 1.5625],
[1. , 1.0625, 1.25 , 1.5625, 2. ]])
You can see that numpy.meshgrid() produces a pair of matrices, here denoted
\(xx\) and \(yy\), such that \((xx[i,j],yy[i,j])\) has coordinates
\((x[i],y[j])\). This is useful because to evaluate \(f\) over a grid, we
only need to evaluate it on each pair of entries in \(xx\), \(yy\). Since
NumPy automatically performs arithmetic operations on arrays
componentwise, it is very easy to evaluate functions over a grid with
very little code.
A useful module is the numpy.linalg module. If you want to solve an
equation \(Ax=b\) do
sage: import numpy
sage: from numpy import linalg
sage: A=numpy.random.randn(5,5)
sage: b=numpy.array(range(1,6))
sage: x=linalg.solve(A,b)
sage: numpy.dot(A,x)
array([1., 2., 3., 4., 5.])
This creates a random 5x5 matrix A, and solves \(Ax=b\) where
b=[0.0,1.0,2.0,3.0,4.0]. There are many other routines in the numpy.linalg
module that are mostly self-explanatory. For example there are
qr and lu routines for doing QR and LU decompositions. There
is also a command eigs for computing eigenvalues of a matrix. You can
always do <function name>? to get the documentation which is quite
good for these routines.
Hopefully this gives you a sense of what NumPy is like. You should explore the package as there is quite a bit more functionality.