How do I assign values from 1D arrays to 4D arrays efficiently

I have multiple 4D arrays where each dimension is the slip ratio of one wheel of a car. Each array stores a parameter's value at every combination of slip ratios from all 4 wheels. I do this so I can use vectorization to greatly speed up the performance of my calculations by using element-wise operations. However, this requires me to have some basic pre-filled arrays to perform my computations on. These include arrays that simply contain slip ratios and forces which only vary in one dimension for each tyre. Currently I'm filling these in like so-

sr_arr_size=8
Slip_ratio_FL = zeros(sr_arr_size,sr_arr_size,sr_arr_size,sr_arr_size); %Define like this for all 4D arrays used below
for i = 1:sr_arr_size
    slip_ratio = slip_ratio_set(i);
    Slip_ratio_FL(i,:,:,:) = slip_ratio;
    Slip_ratio_FR(:,i,:,:) = slip_ratio;
    Slip_ratio_RL(:,:,i,:) = slip_ratio;
    Slip_ratio_RR(:,:,:,i) = slip_ratio;

    Fx_FL(i,:,:,:) = Fx_FL_sr(i);
    Fx_FR(:,i,:,:) = Fx_FR_sr(i);
    Fx_RL(:,:,i,:) = Fx_RL_sr(i);
    Fx_RR(:,:,:,i) = Fx_RR_sr(i);

    Fy_FL(i,:,:,:) = Fy_FL_sr(i);
    Fy_FR(:,i,:,:) = Fy_FR_sr(i);
    Fy_RL(:,:,i,:) = Fy_RL_sr(i);
    Fy_RR(:,:,:,i) = Fy_RR_sr(i);
end

Here, dimension-1 is FL(frontLeft tyre), dimension-2 is FR(frontRight tyre) etc etc...

slip_ratio_set, Fx_FL_sr, ...., Fy_RR_sr are all 1D arrays indexed by i, which I'm trying to fill into the 4D equivalents of themselves

Is there a more efficient and cleaner way of filling these? Currently this takes about 10-15% of my total runtime

[Walter Roberson]

It is common to use ndgrid() to construct arrays like that, such as perhaps

[Slip_ratio_FL, Slip_ratio_FR, Slip_ratio_RL, Slip_ratio_RR] = ndgrid(slip_ratio_set);

However, I do not know if that would be any faster than what you are doing.

[Chaitanya Sindagi]

I'm currently thinking of using cat to somehow to generate arrays that are identical regardless of the first 3 dimensions, generate 4 copies and then use permute to swap dimensions around for each copy so that the dimension that's relevant is in the right place. But I can't quite figure out how to do any of that.

[Sulaymon Eshkabilov]

Hi,

It is doable but your script "as is" contains some inconsistent points.

• All of your assigned values for slip_ratio_FL, slip_ratio_FR, slip_ratio_RL, slip_ratio_RR will have the same value and their sizes are sr_arr_size-by1, 1-by-sr_arr_size, 1-by-1-by-sr_arr_size, and 4D, respectively. "As is" the indexes are not assigned correctly. Similarly, the sizes of Fx_FL, Fx_FR, Fx_RL, Fx_RR, and Fy_FL, Fy_FR, Fy_RL, Fy_RR.
• Fix these inconsistencies and repost your script. Then I'll show a vectorized solution of your exercise.

[Walter Roberson]

Historically, repmat() was implemented by indexing with repeated index. So

v = ones(1,sr_arr_size);
temp{1} = slip_ratio_set(v, :, v, v);
for K = 2:4
    temp{K} = permute(temp{K-1}, [2 3 4 1]);
end

might work in theory.

These days, repmat() is built in and might be faster than before.

Ah, I just looked at the code for ndgrid, and it uses repmat().

[Chaitanya Sindagi]

@Walter Roberson

I tried ndgrid and measured its performance to be about 1.9x better than the one I currently use at the array size I have. Its better for sure, but hopefully there are some other, faster solutions. For anyone else looking at this, my array size is 8, when I tried with an array size of 100, the performance was much much better than the original code I used

[Chaitanya Sindagi]

@Sulaymon Eshkabilov

I'm not sure if I understand you correctly, but I believe you're saying that my array dimenions aren't predefined. That's my bad, I define them as shown in the edited question

[Chaitanya Sindagi]

@Walter Roberson

Since ndgrid uses repmat, I don't think I'll try to evaluate its performance compared to ndgrid since they'll probably be very similar

[J. Alex Lee]

If you also mean execution time to be included in "efficient", not just coding, then it appears to me that indexing arrays of dimensions > 2 is just generally slow (no matter how efficiently you code, ultimately it is whatever matlab's internal indexing scheme is that is slow).

To achieve performance, maybe either re-consider the storage scheme (e.g., if you don't need to do matrix math on those variables in the end), or you might have to go to a compiled language?

[Chaitanya Sindagi]

I actually only meant efficient in terms of performance, the code can look as ugly as it needs to be for all I care. I considered a compiled language but my array sizes are variable so I don't quite know how to handle that. Would a very long 1D array with some way of mapping 4D indices to a 1D index be more efficient(like sub2ind?). All my matrix math is element wise so the exact matrix structure is irrelevant. However, generating and filling in a 1D array with all the values in the right places seems even more of a complex problem

[J. Alex Lee]

I am not sure about relative indexing speed vs nd-arrays, if you don't necessarily need the nd-array structure, but how about cell array, at least at the "top level" of "wheel number"?

[Chaitanya Sindagi]

I tried doing this

a = 15;
Fx_FL_sr = rand(a,1);
Fx_FR_sr = rand(a,1);
Fx_RL_sr = rand(a,1);
Fx_RR_sr = rand(a,1);
for i = 1:a
    Fx_FL(i,:,:,:) = Fx_FL_sr(i);
    Fx_FR(:,i,:,:) = Fx_FR_sr(i);
    Fx_RL(:,:,i,:) = Fx_RL_sr(i);
    Fx_RR(:,:,:,i) = Fx_RR_sr(i);
end % Takes 0.25ms
[Fx_FL_nd, Fx_FR_nd, Fx_RL_nd, Fx_RR_nd] = ndgrid(Fx_FL_sr,Fx_FR_sr,Fx_RL_sr,Fx_RR_sr); % Takes 0.165ms
for i = 1:length(Fx_FL_1d)
    [fl,fr,rl,rr] = ind2sub([a,a,a,a], i); % 287ms
    Fx_FL_1d(i) = Fx_FL_sr(fl); % ~2ms
    Fx_FR_1d(i) = Fx_FR_sr(fr); % ~2ms
    Fx_RL_1d(i) = Fx_RL_sr(rl); % ~2ms
    Fx_RR_1d(i) = Fx_RR_sr(rr); % ~2ms
end

ind2sub is so slow I'm wondering what I'm getting wrong here

I'm not quite sure what the benefit of putting the 4 wheels in a cell array would be?

EDIT:

I replaced ind2sub with a manual approach and it takes a lot less time, but still an order of magnitude or slower than the other methods

for i = 0:(length(Fx_FL_1d)-1)
    Fx_FL_1d(i+1) = Fx_FL_sr(mod(floor(i/a^3), a) +1); % 2ms
    Fx_FR_1d(i+1) = Fx_FR_sr(mod(floor(i/a^2), a) +1); % 2.6ms
    Fx_RL_1d(i+1) = Fx_RL_sr(mod(floor(i/a), a) +1);   % 3ms
    Fx_RR_1d(i+1) = Fx_RR_sr(mod(i,a)+1);              % 3.2ms
end                                                    % 1.6ms

[J. Alex Lee]

Well, looks like Matt J's answer is the one you need, since it looks like it turns out you actually did want to do some math in matrix-like sense on the data itself. In this case, I agree cells would not have helped.

Answer 1

[Matt J]

I do this so I can use vectorization to greatly speed up the performance of my calculations by using element-wise operations. However, this requires me to have some basic pre-filled arrays to perform my computations on.

No, not if you have Matlab R2016b or higher. If so, you can just organize your arrays as vectors along each of the relevant dimensions, e.g. Nx1x1x1 and 1xNx1x1 and 1x1xNx1 and 1xNx1x1 and then you rely on implicit expansion when you do the array arithmetic. This will be much faster and consume much less memory . My ndgridVecs utility

https://www.mathworks.com/matlabcentral/fileexchange/74956-ndgridvecs

may be useful for setting up the initial arrays. It works much the same as ndgrid,

[Slip_ratio_FL, Slip_ratio_FR, Slip_ratio_RL, Slip_ratio_RR] = ndgridVecs(slip_ratio_set);

As an example, this will compute all sums of quadruplets [a,b,c,d] of numbers between 1 and 3,

[A,B,C,D]=ndgridVecs(1:3);

S=A+B+C+D; %sums of all combinations

[Chaitanya Sindagi]

Wow this is amazing, I had no idea about implicit expansion. My code went from being O(n^4) to around O(n), not to mention the memory savings, I had nearly 30 4D arrays, now I have just a few that I cannot avoid.

Thank you so much!