In [1]:
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns
Write a function that computes the factorial of small numbers using np.arange and np.cumprod.
In [7]:
def np_fact(n):
"""Compute n! = n*(n-1)*...*1 using Numpy."""
if n > 0:
a = np.arange(1, n + 1)
factorial = np.cumprod(a)
return max(factorial)
else:
return 1
In [8]:
assert np_fact(0)==1
assert np_fact(1)==1
assert np_fact(10)==3628800
assert [np_fact(i) for i in range(0,11)]==[1,1,2,6,24,120,720,5040,40320,362880,3628800]
Write a function that computes the factorial of small numbers using a Python loop.
In [9]:
def loop_fact(n):
"""Compute n! using a Python for loop."""
factorial = 1
a = range(1, n + 1)
if n > 0:
for i in a:
factorial *= i
return factorial
else:
return 1
In [10]:
assert loop_fact(0)==1
assert loop_fact(1)==1
assert loop_fact(10)==3628800
assert [loop_fact(i) for i in range(0,11)]==[1,1,2,6,24,120,720,5040,40320,362880,3628800]
Use the %timeit magic to time both versions of this function for an argument of 50. The syntax for %timeit is:
%timeit -n1 -r1 function_to_time()
In [11]:
%timeit -n1 -r1 np_fact(50)
%timeit -n1 -r1 loop_fact(50)
In the cell below, summarize your timing tests. Which version is faster? Why do you think that version is faster?
According to the %timeit test, my loop_fact function is faster than my np_fact function. This makes sense as np_fact has to do one more operation than loop_fact. They both define an element holding the same values, and they both go through that element and calculate either the cumulative product, or the product of each successive term with a previously defined total. However, np_fact then has to search through an array of cumulative products to find the largest one, which happens to be the factorial. loop_fact does not need to do this, meaning it has one less step to take and therefore is faster.
In [ ]: