How To Replace For Loops And If Statements With Numpy Arrays

I have a numpy array like this: [[1, 2], [1, 3], [2, 1], [2, 2], [2, 3], ...] I would like to get the combinations of all 'sub' arrays (i.e [X, Y]) three by three: [[1, 1] [1, 1]

Solution 1:

Try itertool and numpy like:

import numpy as np
import itertools


some_list = [[1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [-1,-1]]


# use "itertools.combinations" or "itertools.combinations_with_replacement"# whatever you want to get in therms of repeting elements.# Then cast it into a numpy array.
combinations = np.array(list(itertools.combinations_with_replacement(some_list, 3)))


# from here your can do your boolean statements in the numpy sytax for example# applying your first rule "X1,X2,X3 > 0" could be done with:
first_rule = combinations[:,:,0] > 0print('boolean array for the first rule "X1,X2,X3 > 0"')
print(np.all(first_rule,axis=1))


# and the second rule "X1 + Y1 <= X2"
second_rule = combinations[:,0,0]+combinations[:,0,1] <= combinations[:,1,0]
print('\n\nboolean array for the first rule "X1 + Y1 <= X2"')
print(second_rule)

I assumed that its not just a regular grid because of the first condition X1,X2,X3 > 0, but yes if its regular then the meshgrid is the best solution (see the other answer).

Solution 2:

Edit: You don't even need itertools you can use numpy to create the combinations and it's extremely fast

# This is your input array from [1,1] to [5,5]
a = np.array(np.meshgrid(np.arange(1,6), np.arange(1,6))).T.reshape(-1,2)

b = np.array(np.meshgrid(a, a, a)).T.reshape(-1, 3, 2)

As you can see it takes 6ms: 5.88 ms ± 836 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Your array looks like this now:

array([[[1, 1],
        [1, 1],
        [1, 1]],

       [[1, 1],
        [1, 1],
        [1, 2]],

       [[1, 1],
        [1, 1],
        [1, 3]],

       ...,

       [[5, 5],
        [5, 5],
        [5, 3]],

       [[5, 5],
        [5, 5],
        [5, 4]],

       [[5, 5],
        [5, 5],
        [5, 5]]])

Because this is a numpy array now, you can safely use a for loop to check your conditions. For example row[0,0] would be your X1 and row[0,1] would be your Y1 etc.

for row in b:
    row[0,0] + row[0,1] <= row[1,0]

This also takes a really short amount of time to execute: 10.3 ms ± 278 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

So you can safely do this for your other conditions aswell.

Solution 3:

from itertools import product a = [[1,1],[1, 2], [1, 3], [2, 1], [2, 2], [2, 3]] perms = np.array(list(product(a, repeat=3))) This will create an array of shape (n^3, 3, 2) where n is the number of elements in a.

Now you can do all your fancy operations...

perms[:, :, 0] > 0perms[:, 0, 0] + perms[:, 0, 1] <= perms[:, 1, 0]perms[:, 1, 0] + perms[:, 1, 1] <= perms[:, 2, 0]perms[:, 0, :] != perms[:, 1, :]perms[:, 1, :] != perms[:, 2, :]
...

note that the last two expression will check x1!=x2 and y1!=y2seperately and return a result of shape (n^3,2). However if your requirement is to check whether those instances are not equal as a whole you can just do

output = perms[:, 0, :] != perms[:, 1, :] np.logical_or(output[:, 0], output[:, 1])

which will return the output with shape (n^3).