0

I have a 3-dimensional numpy ndarray.

As an example, a 4x4x2 array as following:

array = [
 [ [7 1] [8 0] [2 0] [7 1] ]
 [ [5 4] [1 4] [6 7] [8 1] ]
 [ [3 2] [4 5] [8 6] [6 2] ]
 [ [6 4] [1 2] [5 5] [7 1] ]
]

I need to find a minimum nested innermost array (the one with two numbers) and it's indices, comparing as Python usually does it: compare first pair of elements, if equal compare next pair, ...

Expected result for the example array: value=[1 2], indices=(3, 1)

Pure Python code to find the element itself would look as following:

min(nested2 for nested1 in array for nested2 in nested1)

I would however prefer a numpy solution, because the arrays are quite huge...

Improve this question
2
  • 1
    The Python min is using a Python sort which for a list of lists of integers is 'lexical'. It appears that you are starting with a numpy array, in which case your last expression could be shorted to min(array.reshape(-1,2).tolist()). That is, replace the nesting with an array reshape. Commented Feb 26, 2020 at 17:31
  • @hpaulj Yep, reshaping works great. But the .tolist() costs on average around 5.4 seconds for each iteration. Everything else runs in under 100ms. So I was hoping to pass on the heavy lifting to numpy... Commented Feb 26, 2020 at 17:41

2 Answers 2

Reset to default
2

Your desired behavior depends on Python doing a lexical sort of a list of lists. That is the sublists are compared as:

In [275]: [1,2]<[2,0]                                                                          
Out[275]: True

np.sort only does a lexical sort with structured arrays and complex values.

In [288]: alist = [ 
     ...:  [ [7, 1], [8, 0], [2, 0], [7, 1] ], 
     ...:  [ [5, 4], [1, 4], [6, 7], [8, 1] ], 
     ...:  [ [3, 2], [4, 5], [8, 6], [6, 2] ], 
     ...:  [ [6, 4], [1, 2], [5, 5], [7, 1] ] 
     ...: ]                                                                                    
In [289]: arr = np.array(alist)                                                                
In [290]: arr                                                                                  
Out[290]: 
array([[[7, 1],
        [8, 0],
        [2, 0],
        [7, 1]],

       [[5, 4],
        [1, 4],
        [6, 7],
        [8, 1]],

       [[3, 2],
        [4, 5],
        [8, 6],
        [6, 2]],

       [[6, 4],
        [1, 2],
        [5, 5],
        [7, 1]]])

Let's try the complex route:

In [291]: x = np.dot(arr, [1,1j])                                                              
In [292]: x                                                                                    
Out[292]: 
array([[7.+1.j, 8.+0.j, 2.+0.j, 7.+1.j],
       [5.+4.j, 1.+4.j, 6.+7.j, 8.+1.j],
       [3.+2.j, 4.+5.j, 8.+6.j, 6.+2.j],
       [6.+4.j, 1.+2.j, 5.+5.j, 7.+1.j]])
In [293]: np.min(x)                                                                            
Out[293]: (1+2j)
In [294]: np.argmin(x)                                                                         
Out[294]: 13
In [295]: np.unravel_index(13, x.shape)                                                        
Out[295]: (3, 1)

Some time tests:

In [302]: timeit min(nested2 for nested1 in alist for nested2 in nested1)                      
2.24 µs ± 19.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [303]: timeit min(arr.reshape(-1,2).tolist())                                               
2.53 µs ± 13.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [304]: timeit np.min(arr.dot([1,1j]))                                                       
19.5 µs ± 46.2 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

The complex route might be faster when the array is much bigger, but with this sample it is inferior.

===

The structured array approach:

In [320]: import numpy.lib.recfunctions as rf                                                  
In [321]: rf.unstructured_to_structured(arr, names=['x','y'])                                  
Out[321]: 
array([[(7, 1), (8, 0), (2, 0), (7, 1)],
       [(5, 4), (1, 4), (6, 7), (8, 1)],
       [(3, 2), (4, 5), (8, 6), (6, 2)],
       [(6, 4), (1, 2), (5, 5), (7, 1)]],
      dtype=[('x', '<i8'), ('y', '<i8')])
In [322]: np.argsort(rf.unstructured_to_structured(arr, names=['x','y']).ravel())              
Out[322]: array([13,  5,  2,  8,  9,  4, 14, 11, 12,  6,  0,  3, 15,  1,  7, 10])
In [323]: timeit np.argsort(rf.unstructured_to_structured(arr, names=['x','y']).ravel())       
41.3 µs ± 192 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Sorting works great. Already reduced from 5.5s to 0.3s, and I still can get rid of creating some intermediate arrays. Structured arrays looks like something I've been missing! (I wasn't using numpy before). np.amin doesn't work though with structured arrays because of TypeError: cannot perform reduce with flexible type
0 
arr1 = np.array(array) # convert your list to numpy array
arr2 = np.sum(arr1,axis=2) # get the sum of the two elements in each array
ind1 = np.unravel_index(arr2.argmin(), arr2.shape) # the indices of the minimum sum
min1 = arr1[ind1] # the value of the minimum array
print(ind1)
(3, 1)
print(min1)
array([1, 2])
Improve this answer

3 Comments

Unfortunately, there's no description what it does, but it definitely does not solve the problem. Instead, it just reduces dimensions of the initial array using a sum function.
I fixed the code for the minimum value. This should work if your criteria is the minimum sum of the two values in an array
"Indices of minimum sum" - you lose information here, since order is important.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.