This is my code that uses a text file to do some calculations. I want to make my code more dynamic rather than static the way it is right now, I need some help on how I can shorten the code more specifically the part where I am calculating the sum. I am a bit new to python so please bear with me.

import numpy as np import math # Getting all the values in the file accept the first line file = open("history.txt", "r") next(file) lines = np.array([list(map(int,line.split())) for line in file]) mylist=np.unique(lines,axis=0) print(f"Positive entries: {len(mylist)}") file.close() # Getting the first line of the file file = open("history.txt", "r") first_line = [list(map(int,line.split())) for line in file] No_items = first_line[0][1] No_Customers = first_line[0][0] file.close() # Creating a zeros array vectors = np.zeros((No_items,No_Customers)) rows = [i[1] - 1 for i in lines] # print(rows) columns = [x[0] - 1 for x in lines] # print(columns) vectors[rows, columns] = 1 print(vectors) number_of_vectors = len(vectors) * (len(vectors) - 1) def calc_angle(x, y): norm_x = np.linalg.norm(x) norm_y = np.linalg.norm(y) cos_theta = np.dot(x, y) / (norm_x * norm_y) theta = math.degrees(math.acos(cos_theta)) return theta sum = (calc_angle(vectors[0],vectors[1]) + calc_angle(vectors[0],vectors[2]) + calc_angle(vectors[0],vectors[3]) + calc_angle(vectors[0],vectors[4]) + calc_angle(vectors[1],vectors[0]) + calc_angle(vectors[1],vectors[2]) + calc_angle(vectors[1],vectors[3]) + calc_angle(vectors[1],vectors[4]) + calc_angle(vectors[2],vectors[0]) + calc_angle(vectors[2],vectors[1]) + calc_angle(vectors[2],vectors[3]) + calc_angle(vectors[2],vectors[4]) + calc_angle(vectors[3],vectors[0]) + calc_angle(vectors[3],vectors[1]) + calc_angle(vectors[3],vectors[2]) + calc_angle(vectors[3],vectors[4]) + calc_angle(vectors[4],vectors[0]) + calc_angle(vectors[4],vectors[1]) + calc_angle(vectors[4],vectors[2]) + calc_angle(vectors[4],vectors[3])) print(sum/number_of_vectors)

## Answer

Why use for loops atall? You can do this in a vectorized way by doing this. –

### Vectorized to work as pairwise

Here is a completely vectorized approach without using np.vectorize signatures. This takes in a matrix containing row vectors and runs a pairwise calc_angle on it before taking a sum.

def calc_angle(vectors): norm = np.linalg.norm(vectors, axis=-1) cos_theta = np.dot(vectors,vectors.T) / np.outer(norm,norm) theta = np.degrees(np.arccos(cos_theta)) np.fill_diagonal(theta, 0) return theta np.sum(calc_angle(vectors)) #Takes in one set of vectors

### Vectorized to work for 2 independent vectors

This takes in 2 independent vectors (or sets of vectors) as inputs instead of one matrix. Allows you to work with 2 different sets of vectors as well if you don’t want to do pairwise distances among the same input vectors.

def calc_angle(x, y): norm_x = np.linalg.norm(x, axis=-1) norm_y = np.linalg.norm(y, axis=-1) cos_theta = np.dot(x,y.T) / np.outer(norm_x,norm_y) theta = np.degrees(np.arccos(cos_theta)) np.fill_diagonal(theta, 0) return theta np.sum(calc_angle(vectors, vectors)) #Takes 2 sets of vectors (could be same)

### Using np.vectorize

It’s not very efficient, but helps when you are stuck with non-vectorizable code.

def calc_angle(x, y): norm_x = np.linalg.norm(x) norm_y = np.linalg.norm(y) cos_theta = np.dot(x,y) / (norm_x * norm_y) theta = np.degrees(np.arccos(cos_theta)) return theta calc_angle_vec = np.vectorize(calc_angle, signature='(k),(k)->()') sums = calc_angle_vec(vectors[None,:,:], vectors[:,None,:]) np.fill_diagonal(sums, 0) output = np.sum(sums)

**Broad idea –**

- These approaches calculate pairwise calc_angle between all vectors by taking norm over the last axis
- Then the dot of the matrices in numerator normalized by the outer of the norms give you the distances
- The distances are then passed to numpy functions which are vectorized and turn them into corresponding degrees
- Next, fill diagonals by 0 (because they are the same vectors)
- Finally reduce the matrix with a
`np.sum`

. **Note:**I have changed the math functions to equivalent NumPy functions because they support vectorization.