从二维数组中取值向量化

Question

I am having some trouble with the following. I have a M x 2N array ( solution ). I want to take the values and put them into NM x 2 arrays, each stored in a different object in the list masses . The code cannot rely on all loops because the program is very slow otherwise. Here is my attempt:

        for i in range(len(masses)):
            self.masses[i].l = solution[:len(solution)][2*i: 2*(i + 1)]

The problem is, this just takes the entire solution array and puts it in each l array. Any ideas why this might be happening?

As an example, say I have 3 objects in the array masses . The solution input is

[[0,0,0,0,0,0]
 [1,2,3,4,5,6]
 [2,4,6,8,10,12]]

The expected values of l in each of the objects in masses is:

self.masses[0].l = [[0,0]
                    [1,2]
                    [2,4]]


self.masses[1].l = [[0,0]
                    [3,4]
                    [6,8]]

self.masses[2].l = [[0,0]
                    [5,6]
                    [10,12]]

Instead, each l array is just set as the the solution array.

Answer 1

You could do this with a list comprehension. It's faster than a normal loop.
I do not know what objects are stored inside masses , so for the sake of this example let me use masses as a simple list.

solution = [[0,0,0,0,0,0], [1,2,3,4,5,6], [2,4,6,8,10,12]]

masses = [None] * 3 #I get that its length should be half of the length of the inner lists in solution.
for i in range(len(masses)):
     masses[i] = [j[2*i:2*(i+1)] for j in solution]

print(masses)

masses is:

[
 [[0, 0], [1, 2], [2, 4]], 
 [[0, 0], [3, 4], [6, 8]], 
 [[0, 0], [5, 6], [10, 12]]
]

Which should be what you want.

Guessing how to use it with your masses list, it shoud be:

for i in range(len(masses)):
    self.masses[i].l = [j[2*i:2*(i+1)] for j in solution]

Just be sure that you have enough objects in your self.masses list, or you will get an IndexError .

EDIT after comments

If solution is a Mx2N numpy array, it can be done like this:

import numpy as np
solution = np.array([[0,0,0,0,0,0], [1,2,3,4,5,6], [2,4,6,8,10,12]])
masses = [solution[...,2*i:2*(i+1)] for i in range(int(solution.shape[1]/2))]

masses is:

[
 array([[0, 0], [1, 2], [2, 4]]), 
 array([[0, 0], [3, 4], [6, 8]]), 
 array([[0, 0], [5, 6], [10, 12]])
]

As I said in the comments, if you use the list comprehension mentioned before it works, but each masses entry will be a list of 1D numpy array. Now each masses entry is a 2D numpy array.
I am not sure about efficiency, but give it a try: numpy indexing is quite fast.
However if you are dealing with tons of data, at some point you just need to bear with it. There is a limit on optimization.

In your OOP setting, you likely have a method to populate that self.masses attribute list. It should be something like:

def setmasses(self, solution):
    for i in range(int(solution.shape[1]/2)):
        self.masses[i].l = solution[...,2*i:2*(i+1)]

I am afraid there is not easy way to avoid the for loop in this case, because you need to loop over a list of already existing objects.