Functional Programming for Mathematicians¶

Author: Minh Van Nguyen <nguyenminh2@gmail.com>

This tutorial discusses some techniques of functional programming that might be of interest to mathematicians or people who use Python for scientific computation. We start off with a brief overview of procedural and object-oriented programming, and then discuss functional programming techniques. Along the way, we briefly review Python’s built-in support for functional programming, including filter, lambda, map and reduce. The tutorial concludes with some resources on detailed information on functional programming using Python.

Styles of programming¶

Python supports several styles of programming. You could program in the procedural style by writing a program as a list of instructions. Say you want to implement addition and multiplication over the integers. A procedural program to do so would be as follows:

Sage

sage: def add_ZZ(a, b):
....:     return a + b
...
sage: def mult_ZZ(a, b):
....:     return a * b
...
sage: add_ZZ(2, 3)
5
sage: mult_ZZ(2, 3)
6

Python

>>> from sage.all import *
>>> def add_ZZ(a, b):
...     return a + b
...
>>> def mult_ZZ(a, b):
...     return a * b
...
>>> add_ZZ(Integer(2), Integer(3))
5
>>> mult_ZZ(Integer(2), Integer(3))
6

Sage Live

def add_ZZ(a, b):
    return a + b
def mult_ZZ(a, b):
    return a * b
add_ZZ(2, 3)
mult_ZZ(2, 3)

The Python module operator defines several common arithmetic and comparison operators as named functions. Addition is defined in the built-in function operator.add and multiplication is defined in operator.mul. The above example can be worked through as follows:

Sage

sage: from operator import add
sage: from operator import mul
sage: add(2, 3)
5
sage: mul(2, 3)
6

Python

>>> from sage.all import *
>>> from operator import add
>>> from operator import mul
>>> add(Integer(2), Integer(3))
5
>>> mul(Integer(2), Integer(3))
6

Sage Live

from operator import add
from operator import mul
add(2, 3)
mul(2, 3)

Another common style of programming is called object-oriented programming. Think of an object as code that encapsulates both data and functionalities. You could encapsulate integer addition and multiplication as in the following object-oriented implementation:

Sage

sage: class MyInteger:
....:     def __init__(self):
....:         self.cardinality = "infinite"
....:     def add(self, a, b):
....:         return a + b
....:     def mult(self, a, b):
....:         return a * b
...
sage: myZZ = MyInteger()
sage: myZZ.cardinality
'infinite'
sage: myZZ.add(2, 3)
5
sage: myZZ.mult(2, 3)
6

Python

>>> from sage.all import *
>>> class MyInteger:
...     def __init__(self):
...         self.cardinality = "infinite"
...     def add(self, a, b):
...         return a + b
...     def mult(self, a, b):
...         return a * b
...
>>> myZZ = MyInteger()
>>> myZZ.cardinality
'infinite'
>>> myZZ.add(Integer(2), Integer(3))
5
>>> myZZ.mult(Integer(2), Integer(3))
6

Sage Live

class MyInteger:
    def __init__(self):
        self.cardinality = "infinite"
    def add(self, a, b):
        return a + b
    def mult(self, a, b):
        return a * b
myZZ = MyInteger()
myZZ.cardinality
myZZ.add(2, 3)
myZZ.mult(2, 3)

Functional programming using map¶

Functional programming is yet another style of programming in which a program is decomposed into various functions. The Python built-in functions map, reduce and filter allow you to program in the functional style. Note that in Python 3 (as compared to Python 2), these functions have different behaviors, and reduce has been removed: if you want to use reduce in Python 3, you must import it from functools.

The function

map(func, seq1, seq2, ...)

takes a function func and one or more sequences, and apply func to elements of those sequences. In particular, you end up with a list like so:

[func(seq1[0], seq2[0], ...), func(seq1[1], seq2[1], ...), ...]

In many cases, using map allows you to express the logic of your program in a concise manner without using list comprehension. For example, say you have two lists of integers and you want to add them element-wise. A list comprehension to accomplish this would be as follows:

Sage

sage: A = [1, 2, 3, 4]
sage: B = [2, 3, 5, 7]
sage: [A[i] + B[i] for i in range(len(A))]
[3, 5, 8, 11]

Python

>>> from sage.all import *
>>> A = [Integer(1), Integer(2), Integer(3), Integer(4)]
>>> B = [Integer(2), Integer(3), Integer(5), Integer(7)]
>>> [A[i] + B[i] for i in range(len(A))]
[3, 5, 8, 11]

Sage Live

A = [1, 2, 3, 4]
B = [2, 3, 5, 7]
[A[i] + B[i] for i in range(len(A))]

Alternatively, you could use the Python built-in addition function operator.add together with map to achieve the same result:

Sage

sage: from operator import add
sage: A = [1, 2, 3, 4]
sage: B = [2, 3, 5, 7]
sage: list(map(add, A, B))
[3, 5, 8, 11]

Python

>>> from sage.all import *
>>> from operator import add
>>> A = [Integer(1), Integer(2), Integer(3), Integer(4)]
>>> B = [Integer(2), Integer(3), Integer(5), Integer(7)]
>>> list(map(add, A, B))
[3, 5, 8, 11]

Sage Live

from operator import add
A = [1, 2, 3, 4]
B = [2, 3, 5, 7]
list(map(add, A, B))

An advantage of map is that you do not need to explicitly define a for loop as was done in the above list comprehension.

Further resources¶

This has been a rather short tutorial to functional programming with Python. The Python standard documentation has a list of built-in functions, many of which are useful in functional programming. For example, you might want to read up on all, any, max, min, and zip. The Python module operator has numerous built-in arithmetic and comparison operators, each operator being implemented as a function whose name reflects its intended purpose. For arithmetic and comparison operations, it is recommended that you consult the operator module to determine if there is a built-in function that satisfies your requirement. The module itertools has numerous built-in functions to efficiently process sequences of items.

Another useful resource for functional programming in Python is the Functional Programming HOWTO by A. M. Kuchling. Steven F. Lott’s book Building Skills in Python has a chapter on Functional Programming using Collections. See also the chapter Functional Programming from Mark Pilgrim’s book Dive Into Python.

You might also want to consider experimenting with Haskell for expressing mathematical concepts. For an example of Haskell in expressing mathematical algorithms, see J. Gibbons’ article Unbounded Spigot Algorithms for the Digits of Pi in the American Mathematical Monthly.

Functional Programming for Mathematicians¶

Styles of programming¶

Functional programming using map¶

Define small functions using lambda¶

Reducing a sequence to a value¶

Filtering with filter¶

Further resources¶