# Numpy Exercise 2

## Imports

In [1]:
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

## Factorial

Write a function that computes the factorial of small numbers using np.arange and np.cumprod.

In [14]:
def np_fact(n):
"""Compute n! = n*(n-1)*...*1 using Numpy."""
numbers=np.arange(1,n+2) #creates an array with numbers up to n+1
a=numbers.cumprod() #makes a the running product of the previous numbers.
fact=a[n-1] #selects the second to last product which is the factorial of n
return fact

In [15]:
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 [16]:
def loop_fact(n):
"""Compute n! using a Python for loop."""
if n==0:  #defines the case when n=0
fact=1
else:
fact=n # sets fact equal to n
i=n-1
while i>0: #while i is greater than zero multiplies i by n and then decreses i
fact=fact*i
i-=1
return fact

In [17]:
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 [43]:
%timeit -n1 -r1 loop_fact(50)

1 loops, best of 1: 14.1 µs per loop

In [44]:
%timeit -n1 -r1 np_fact(50)

1 loops, best of 1: 89.9 µs per loop

In the cell below, summarize your timing tests. Which version is faster? Why do you think that version is faster?

My function loop_fact, which computes the factorial of n using a while loop and an if/else statement takes 14.1us to run. My funciton np_fact, which achieves the same result but by using array functions takes 89.9us to run. This is roughly 6 times slower. This doesn't make sense, since I was under the impression that it should be the opposite.

In [ ]: