ENH: allow linspace to take 1D vectors as start and end

I have a line segment in N-dimensional space, defined by its begin- and endpoints (both 1D vectors). For example in 3D:

start = array([0,1,2])
end = array([1,3,6])

I would like to be able segment the line in k segments, for example 4, or 5 including the endpoints. The result would then be:

 array([[ 0.  ,  0.25,  0.5 ,  0.75,  1.  ],
       [ 1.  ,  1.5 ,  2.  ,  2.5 ,  3.  ],
       [ 2.  ,  3.  ,  4.  ,  5.  ,  6.  ]]) 

I extended (and broke) linspace to not only accept scalar, but also 1D vector start- and endpoints:

def linspace(start,stop,num=50,endpoint=True,retstep=False):
    spannedRange = stop-start
    numberOfSteps = num - (1 if endpoint else 0)
    step = array(spannedRange/numberOfSteps,ndmin=2).T
    coefficientColumn = numpy.arange(num)
    samples = numpy.kron(coefficientColumn,step)+array(start,ndmin=2).T
    if retstep:
        return (samples,step)
    else:
        return samples

Would it be possible (without breaking linspace former behaviour) to incorporate this functionality into NumPy?

[seberg]

Not sure if its worth it (where do you add the new axis seems the biggest ambiguity), though unless someone already abused it for such a thing (you can with endpoint=False), I guess it cannot break anything.

In any case, you do not have to look so far, the current code basically supports it already, since it is just broadcasting really.

def linspace(start, stop, num=50, endpoint=True, retstep=False):
    # just pre-process start and stop a bit:
    start = np.asarray(start)[...,None]
    stop = np.asarray(stop)[...,None]
    num = int(num)
    if num <= 0:
        dtype = np.result_type(start, stop, 1.) # conserve dtype
        shape = np.broadcast(start, end).shape[:-1] + (0,)
        return np.empty(shape, dtype=dtype)
    if endpoint:
        if num == 1:
            dtype = np.result_type(start, stop, 1.)
            return start.astype(dtype)
        step = (stop-start)/float((num-1))
        y = _nx.arange(0, num) * step + start
        y[...,-1] = stop[...,0]
    else:
        step = (stop-start)/float(num)
        y = _nx.arange(0, num) * step + start
    if retstep:
        return y, step
    else:
        return y

should do the trick (as you see, mostly reshape at the start and fixing of the y assignment and the special cases, and some other smaller unrelated changes I smuggled in).

[mhvk]

Implemented in #12388, so closing.