Q2

In this question, we'll explore the basics of using NumPy arrays. We'll also start using functions as they were intended: incremental building blocks to simplify a larger task. This means the solution to each part may be used in future parts. I've tried to make these constituent components fairly easy, but if you run into problems, please ask for help!

Remember: when using a solution you wrote from a previous part, you DO NOT need to copy it from its original cell into the cell you're currently working on! By having clicked the "Play" button on the cell with the code you want to use, you've essentially "saved" it into Python, so all you have to do is call it like you would any other function; no need to copy/paste it!

Part A

NumPy arrays are wonderful improvements over native Python lists for many reasons, the biggest of which is its ability to perform "vectorized" operations over entire arrays without having to write loops.

Write a function which takes two NumPy arrays as arguments and returns their difference (in order of the arguments themselves; if you're getting an AssertionError, try flipping the ordering of the arguments in your function).

Your function should:

• be named difference
• take two arguments: both NumPy arrays of floats
• return 1 NumPy array, containing the element-wise difference of the two vectors (second array from first array).

You will need to check if the arrays are the same length; if not, raise a ValueError.

You cannot use any loops, built-in functions, or NumPy functions.

Part B

Write a function which takes a NumPy array and returns another NumPy array with all its elements squared.

Your function should:

• be named squares
• take 1 argument: a NumPy array
• return 1 value: a NumPy array where each element is the squared version of the input array

You cannot use any loops, built-in functions, or NumPy functions.

Part C

Write a function which computes the sum of the elements of a NumPy array.

Your function should:

• be named sum_of_elements
• take 1 argument: a NumPy array
• return 1 floating-point value: the sum of the elements in the NumPy array

You cannot use any loops, but you can use the numpy.sum function.

Part D

You may not have realized it yet, but in the previous three parts, you've implemented almost all of what's needed to compute the Euclidean distance between two vectors, as represented with NumPy arrays. All you have to do now is link the code you wrote in the previous three parts together in the right order.

Write a function which takes two NumPy arrays and computes their distance. Your function should:

• be named distance
• take 2 arguments: both NumPy arrays of the same length
• return 1 number: a non-zero floating point value that is the distance between the two arrays

Remember how Euclidean distance $d$ between two vectors $\vec{a}$ and $\vec{b}$ is calculated:

$$ d(\vec{a}, \vec{b}) = \sqrt{(a_1 - b_1)^2 + (a_2 - b_2)^2 + ... + (a_n - b_n) ^2} $$

where $a_1$ and $b_1$ are the first elements of the arrays $\vec{a}$ and $\vec{b}$; $a_2$ and $b_2$ are the second elements, and so on.

You've already implemented everything except the square root; in addition to that, you just need to arrange the functions you've written in the correct order inside your distance function. Aside from calling your functions from Parts A-C, there is VERY LITTLE ORIGINAL CODE you'll need to write here! The tricky part is understanding how to make all these parts work together.

You cannot use any functions aside from those you've already written.

Part E

Now, you'll use your distance function to find the pair of vectors that are closest to each other. This is a very, very common problem in data science: finding a data point that is most similar to another data point.

In this problem, you'll write a function that takes two arguments: the data point you have (we'll call this the "reference data point"), and a list of data points you want to search. You'll loop through this list and, using your distance() function defined in Part D, compute the distance between the reference data point and each data point in the list, hunting for the one that gives you the smallest distance (meaning here that it is most similar to your reference data point).

Your function should:

• be named similarity_search
• take 2 arguments: a reference point (NumPy array), and a list of data points (list of NumPy arrays)
• return 1 value: the smallest distance you could find between your reference data point and one of the data points in the list

For example, similarity_search([1, 1], [ [1, 1], [2, 2], [3, 3] ]) should return 0, since the smallest distance that can be found between the reference data point [1, 1] and an data point in the list is the list's first element: an exact copy of the reference data point. The distance between a 2D point and itself will always be 0, so this is pretty much as small as you can get.

HINT: This really isn't much code at all! Conceptually it's nothing you haven't done before, either--it's very much like the question in Assignment 3 that asked you to write code to find the minimum value in a list. This just looks intimidating, because now you're dealing with NumPy arrays. If your solution goes beyond 10-15 lines of code, consider re-thinking the problem.