The fastest way I can think of is calculating the step-size, construct the vector from that using implicit binary expansion.

 a = [ -1; 0; 1];
 n = 3;
 stepsizes = (max(a,0)-min(a,0))/(n-1);
 A = min(a,0) + (0:(n-1)).*stepsizes;

Timeit:

A couple of timeit results using (use timeit(@SO) and remove comments from the blocks to be timed):

function SO()
n = 1e3;
m = 1e5;
a = randi(9,m,1)-4;

% %Wolfie
% aminmax = [min(a, 0), max(a,0)]';
% A = interp1( [0,1], aminmax, linspace(0,1,n) )';

% %Nicky
% stepsizes = (max(a,0)-min(a,0))/(n-1); 
% A = min(a,0) + (0:(n-1)).*stepsizes;

% %Loop
% A = zeros(m,n);
% for i=1:m
%     A(i,:) = linspace(min(a(i),0),max(a(i),0),n);
% end

%Arrayfun:
A = cell2mat(arrayfun(@(x) linspace(min(x,0),max(x,0),n),a,'UniformOutput',false));

Then the times are:

• Wolfie: 2.2243 s
• Mine: 0.3643 s
• Standard loop: 1.0953 s
• arrayfun: 2.6298 s

You can create a linear spline with the points in a as control points. After that you can specify as many points as you want from a beginning interval to an ending interval. As what Raab70 said, you can use interp1. interp1 can be called in the following way (using linear interpolation):

out = interp1(x, y, xp, 'linear')

x are the x values and y are the y values for the control points. xp are the points you want to evaluate the function at. Because you don't explicitly have x values and you just want the y values, you can create a dummy vector that goes from 1 up to L where L is how many points are in your output data. This dummy vector is for your x values. After, specify y as your output data. In this case, it is the array of a. Next, you need to specify where you want to sample along the curve. Because you want to introduce 5 points in between each space, you will have in total 5*4 + 5 = 25 points all together. 5 points per "slot", and there are 4 slots all together. You also include the 5 points that were from your original output data. To create these 25 points, simply perform linspace from 1 up to 5 and specify that you want 25 points in between this interval. This should perfectly capture the control points (the dummy values of 1,2,3,4,5) as well as the values that you want to use to interpolate in between each of the control points.

As such, try something like this:

N = 5; %// Number of points to introduce in between each control point
y = [0 0 1 0 0]; %// Your output data
L = numel(y); %// Size of output data. Cache so we don't have to keep typing in numel(y)
x = 1:L; %// Dummy vector
xp = linspace(1, L, N*(L-1) + N); %// Create points to interpolate. N*(L-1) + N is also just N*L
out = interp1(x, y, xp, 'linear'); %// Generate interpolated array

out thus gives me:

out =

Columns 1 through 9

     0         0         0         0         0         0         0    0.1667    0.3333

Columns 10 through 18

0.5000    0.6667    0.8333    1.0000    0.8333    0.6667    0.5000    0.3333    0.1667

Columns 19 through 25

     0         0         0         0         0         0         0

This method is faster than looping over linspace: x = linspace(0,1,nPoints); A2 = go + x.*(st - go); Here's a timing test for |nGo = 10000|: nGo = 10000; go = randi(100, nGo, 1); st = go + randi(100, nGo, 1); nPoints = 10; %number of points in each row tic for ii = 1:100 A = nan(nGo, nPoints); for iGo = 1:nGo A(iGo,:) = linspace(go(iGo),st(iGo),nPoints); %create array of linearly spaced rows end end t(1) = toc; tic for ii = 1:100 x = linspace(0,1,nPoints); A2 = go + x.*(st - go); end t(2) = toc; fprintf('Method 1: %.4f msec\nMethod 2: %.4f msec\nSpeedup: %.2f x\n', t*10, t(1)/t(2)); On my computer, I get: Method 1: 9.6675 msec Method 2: 0.0676 msec Speedup: 143.07 x Differences between A and A2 are on order of 1e-16.

There are a couple of ways you can do this:

• Using the colon operator:

  startValue = 1;
  endValue = 10;
  nElements = 20;
  stepSize = (endValue-startValue)/(nElements-1);
  A = startValue:stepSize:endValue;
  

• Using the linspace function (as suggested by Amro):

  startValue = 1;
  endValue = 10;
  nElements = 20;
  A = linspace(startValue,endValue,nElements);
  

Keep in mind that the number of elements in the resulting arrays includes the end points. In the above examples, the difference between array element values will be 9/19, or a little less than 0.5 (unlike the sample array in the question).