Question

Fill in 2D Numpy array recursively, and compute execution times. M is a 2D array with dimensions N \times N, where N > 1 is an integer. It is defined as following. The first column is just the set of numbers 0, 1, ... N-1. The first row of elements is zero. The rest of the array is computed via a recrsive formula in which the element is equal to the sum of (a) the one just above and (b) also the element above and to the left. The figure below illustrates this: to compute the value of the element in the red oval, we add the two elements in the blue box. [0 0 0 0 0 0 0 0] [1 0 0 0 0 0 0 0] [2 1 0 0 0 0 0 0] [3 3 1 0 0 0 0 0] [4 6 4 1 0 0 0 0] [5 10 10 5 1 0 0 0] (1) For any N, define a function $F_1$ that would implement this recursive process, filling in M, by using two \texttt{for} loops to loop over columns and rows. Print your resulting matrix M1 for N = 8. [4] (2) Define another function $F_2$ that achieves the same goal but uses only one \texttt{for} loop to go over rows of M2. That is, for each row, start from the left of it, and fill the row in by going to the right end of the row. Print your resulting matrix M2. [4] (3) Visualise matrix M1 for some value of N, e.g., N = 10, with \texttt{imshow}. [3] (4) In the rest of the Task we measure code efficiency of the two methods as a function of the number of elements in the matrix. Define an array $N_i = 2^i$, where $i = 0, 1, 2,... 12$. For each value of $N_i$, find the matrices $M_1$, $M_2$ (do not print them as they become large), and the time it took your code to do so, $t_1(N_i)$ and $t_2(N_i)$. Print your $t_i$ in a clear fashion. [3] (5) Plot the resulting execution times $t_1$ and $t_2$ versus $N_i$. Try to make your plot as clear as possible. Analyse your results, and make quantitative conclusions about how large $t_1$ and $t_2$ would be for a very large $N_i$, e.g. $N_i = 10^5$. [11]

          Fill in 2D Numpy array recursively, and compute execution times.
M is a 2D array with dimensions N \times N, where N > 1 is an integer. It is defined as following. The first column is just the set of numbers 0, 1, ... N-1. The
first row of elements is zero. The rest of the array is computed via a recrsive formula in which the element is equal to the sum of (a) the one just above and (b)
also the element above and to the left. The figure below illustrates this: to compute the value of the element in the red oval, we add the two elements in the
blue box.
[0 0 0 0 0 0 0 0]
[1 0 0 0 0 0 0 0]
[2 1 0 0 0 0 0 0]
[3 3 1 0 0 0 0 0]
[4 6 4 1 0 0 0 0]
[5 10 10 5 1 0 0 0]
(1) For any N, define a function $F_1$ that would implement this recursive process, filling in M, by using two \texttt{for} loops to loop over columns and rows.
Print your resulting matrix M1 for N = 8. [4]
(2) Define another function $F_2$ that achieves the same goal but uses only one \texttt{for} loop to go over rows of M2. That is, for each row, start from the left
of it, and fill the row in by going to the right end of the row. Print your resulting matrix M2. [4]
(3) Visualise matrix M1 for some value of N, e.g., N = 10, with \texttt{imshow}. [3]
(4) In the rest of the Task we measure code efficiency of the two methods as a function of the number of elements in the matrix. Define an array $N_i = 2^i$,
where $i = 0, 1, 2,... 12$. For each value of $N_i$, find the matrices $M_1$, $M_2$ (do not print them as they become large), and the time it took your code to
do so, $t_1(N_i)$ and $t_2(N_i)$. Print your $t_i$ in a clear fashion. [3]
(5) Plot the resulting execution times $t_1$ and $t_2$ versus $N_i$. Try to make your plot as clear as possible. Analyse your results, and make quantitative
conclusions about how large $t_1$ and $t_2$ would be for a very large $N_i$, e.g. $N_i = 10^5$. [11]

Fill in 2D Numpy array recursively, and compute execution times.
M is a 2D array with dimensions N ×N, where N > 1 is an integer. It is defined as following. The first column is just the set of numbers 0, 1, ... N-1. The
first row of elements is zero. The rest of the array is computed via a recrsive formula in which the element is equal to the sum of (a) the one just above and (b)
also the element above and to the left. The figure below illustrates this: to compute the value of the element in the red oval, we add the two elements in the
blue box.
[0 0 0 0 0 0 0 0]
[1 0 0 0 0 0 0 0]
[2 1 0 0 0 0 0 0]
[3 3 1 0 0 0 0 0]
[4 6 4 1 0 0 0 0]
[5 10 10 5 1 0 0 0]
(1) For any N, define a function F1 that would implement this recursive process, filling in M, by using two for loops to loop over columns and rows.
Print your resulting matrix M1 for N = 8. [4]
(2) Define another function F2 that achieves the same goal but uses only one for loop to go over rows of M2. That is, for each row, start from the left
of it, and fill the row in by going to the right end of the row. Print your resulting matrix M2. [4]
(3) Visualise matrix M1 for some value of N, e.g., N = 10, with imshow. [3]
(4) In the rest of the Task we measure code efficiency of the two methods as a function of the number of elements in the matrix. Define an array Ni = 2^i,
where i = 0, 1, 2,... 12. For each value of Ni, find the matrices M1, M2 (do not print them as they become large), and the time it took your code to
do so, t1(Ni) and t2(Ni). Print your ti in a clear fashion. [3]
(5) Plot the resulting execution times t1 and t2 versus Ni. Try to make your plot as clear as possible. Analyse your results, and make quantitative
conclusions about how large t1 and t2 would be for a very large Ni, e.g. Ni = 10^5. [11]

Added by Sharon M.

Question

Please give Ace some feedback