Matrices are an important part of linear algebra. By arranging scalars in a rectangular manner, one can elegantly encode vector transformations like scaling, rotating, shearing and squashing, solve systems of linear equations and represent general vector space homomorphisms.
However, as powerful as matrices are, when actually applying the theoretical tools one has to calculate specific values. Doing so by hand can be done, yet gets cumbersome quite quickly when dealing with any matrices which contain more than a few rows and columns.
So, even though there are a lot of other implementations already present, I set out to write a Python matrix module containing a matrix class capable of basic matrix arithmetic (matrix multiplication, transposition, …) together with a set of functions which perform some higher-level matrix manipulation like applying Gaussian elimination, calculating the reduced row echelon form, determinant, inversion and rank of a given matrix.
Module source code can be seen below and downloaded. When saved as
matrix.py in the current working directory, one can import the module as follows.
>>> import matrix >>> A = matrix.Matrix([[13, 1, 20, 18], ... [ 9, 24, 0, 9], ... [14, 22, 5, 18], ... [19, 9, 15, 14]]) >>> print A**-1 -149/1268 -67/634 83/1268 171/1268 51/1268 239/1902 -105/1268 -33/1268 Matrix( 73/634 803/4755 -113/634 -87/3170 ) 13/1268 -75/634 197/1268 -83/1268
Matrices are defined over a field, typically in theoretical use, though for my implementation I chose not to use a
double data structure, as it lacked the conceptual precision in numbers like a third. As one cannot truly represent a large portion of the reals anyways, I chose to use , which also is a field though can be — to a certain scalar size and precision — accurately represented using fractional data types (Python’s built-in
Fraction is used here).
To simplify working with matrices, the implemented matrix class supports operator overloading such that the following expressions —
A!=B — all behave in a coherent and intuitive way for matrices
A, B, scalars
l and indices
When working with matrices, there are certain rules that must be obeyed, like proper size when adding or multiplying, invertibility when inverting and others. To minimize potential bug track down problems, I tried to include a variety of detailed exceptions (
ValueErrors) explaining the program’s failure at that point.
Apart from basic matrix arithmetic, a large part of my module centers around Gaussian elimination and the functions that follow from it. At their heart lies the implementation of
GaussianElimination, a function which calculates the reduced row echelon form
rref(A) of a matrix together with the transformation matrix
T such that
T*A = rref(A), a list of all matrix pivot coordinates, the number of row transpositions used to achieve row echelon form and a product of all scalars used to achieve reduced row echelon form.
From this function,
rref(A) simply returns the first,
rrefT(A) the second parameter. Functions
rcef(A) (reduced column echelon form) and
A*S=rcef(A)) follow from repeated transposition.
Determinant calculation uses characteristic determinant properties (multilinear, alternating and the unit hypercube has hypervolume one).
Using these properties, the determinant is equal to the product of the total product of all factors used in transforming the matrix into reduced row echelon form and the permutation parity (minus one to the power of the number of transpositions used).
Questions regarding invertibility and rank can also conveniently be implemented using the above described information.
All in all, this Python module implements basic matrix functionality paired with a bit more involved matrix transformations to build a usable environment for manipulating matrices in Python.
# Python 2.7 code; Jonathan Frech; 9th, 10th, 11th, 12th, 14th of December 2017 # 4th of January 2018: added support for matrix inequality, implemented __ne__
A recent PPCG challenge titled The Quantum Drunkard’s Walk was about a tiny drunken person for which quantum mechanics apply and who — being drunk — will randomly walk in one of the four cardinal directions each step they take.
As they experience the strange world of quanta, they can simultaneously take every path at once and their paths influence each other. The challenge then asked to output all possible positions the quantum drunkard could occupy, all paths they could take in ASCII representation.
The question also states this problem’s equivalence to a cellular automaton, when one removes the story boilerplate.
Cells in this cellular automaton are square and can occupy one of three states: empty, awake or sleeping. Each iteration, all cells change according to three rules.
- An empty cell wakes up iff there is exactly one awake cell amongst its cardinal neighbours, else it stays empty.
- An awake cell goes to sleep.
- A sleeping cell continues to sleep.
Being code golf, the aim was to come up with a minimally sized source code; my attempt required 214 bytes and prints a nested array containing one-length strings (characters), as this output method is cheaper than concatenating all characters to one string.
However, one user took the challenge idea a bit further and created an animated gif showing the walk’s, or cellular automaton’s, progression over time with an increasing number of iterations. My Python program shown in this post does exactly that, generating an animated gif showing the automaton’s progression. I even implemented rainbow support, possibly improving the automaton’s visual appearance.
Python source code can be downloaded and seen below.
I use the Python Imaging Library to produce all frames and use a shell call to let ImageMagick convert all frames to an animated gif. Animation parameters are taken via shell arguments, a full list of features follows (also available via the
--iterations NNumber of iterations (initial frame not counted)
--colorempty CEmpty cell color (
--colorawake CAwake cell color (
--colorsleeping CSleeping cell color (
--rainbowUse rainbow colors (overrides color settings)
--scale NCell square pixel size
--convertExecute ImageMagick’s convert command
--delay NDelay between frames in output image.
--loop NGif loops (0 means for indefinite looping)
--keepfilesDo not delete files when converting
# Python 2.7 code; Jonathan Frech; 1st of December 2017