In this question I asked for a way to compute the closest projected point to a hyperbolic paraboloid using python.

Thanks to the answer, I was able to use the code below to calculate the closest point to multiple paraboloids.

from scipy.optimize import minimize

# This function calculate the closest projection on a hyperbolic paraboloid
# As Answered by @Jaime https://stackoverflow.com/questions/18858448/speeding-up-a-closest-point-on-a-hyperbolic-paraboloid-algorithm
def fun_single(x, p0, p1, p2, p3, p):
    u, v = x
    s = u*(p1-p0) + v*(p3-p0) + u*v*(p2-p3-p1+p0) + p0
    return np.linalg.norm(p-s)


# Example use case:
# Generate some random data for 3 random hyperbolic paraboloids
# A real life use case will count in the tens of thousands.
import numpy as np
COUNT = 3
p0 = np.random.random_sample((COUNT,3))
p1 = np.random.random_sample((COUNT,3))
p2 = np.random.random_sample((COUNT,3))
p3 = np.random.random_sample((COUNT,3))
p = np.random.random_sample(3)

uv = []
for i in xrange(COUNT):
    uv.append(minimize(fun_single, (0.5, 0.5), (p0[i], p1[i], p2[i], p3[i], p)).x)
uv = np.array(uv)

# UV projections for my random data
#[[ 0.34109572  4.39237344]
# [-0.2720813   0.17083423]
# [ 0.48993333 -0.99415568]]

Now that I have a projection for each item it's possible to find more useful info, such as which of the given items is closest to the query point, find its array index and derive more data from it, etc...

The problem with calling minimize for each item is that it becomes very slow when dealing with hundreds of thousands of items. So to try to resolve the issue I took a crack at changing the function to work with many inputs.

from numpy.core.umath_tests import inner1d

# This function calculate the closest projection to many hyperbolic paraboloids
def fun_array(x, p0, p1, p2, p3, p):
    u, v = x
    s = u*(p1-p0) + v*(p3-p0) + u*v*(p2-p3-p1+p0) + p0
    V = p-s
    return np.min(np.sqrt(inner1d(V,V)))

# Lets pass all the data to minimize
uv = minimize(fun_array, (0.5, 0.5), (p0, p1, p2, p3, p)).x

# Result: [ 0.25090064,  1.19732181]
# This corresponds to index 2 of my random data, 
# which is the closest projection.

Minimizing the function fun_array is much faster than the iterative approach, but it only returns the single closest projection, not all projections.

QUESTION

Is it possible to use minimize to return all projections as with the iterative approach? And if not, is it at least possible to get the index of the "winning" array element?