Assigning values to an array of arbitrary dimensions in MATLAB.

49 vues (au cours des 30 derniers jours)
Michael Ransom
Michael Ransom le 16 Mar 2019
I have a problem that requires assigning values to an array of arbitrary dimensions.
For a given integer j, I pre-allocate a regular j-dimensional array such that
where are integers for . Such an array in MATLAB looks like:
Array = NaN.*ones( repmat( d , 1 , j ) ) ;
The problem is assigning values for elements in this array. Specifically, given are vectors of length , I require all combinations of element-wise multiplication for each of these vectors, where each result is assigned to .
For the simplest case , assuming vectors are stored in cell-arrays, I can do this quite easily using loops:
for m = 1:d
for n = 1:d
Array( m , n ) = v{ 1 }( m ).*v{ 2 }( n ) ;
end
end
But, a "psudeo-code" implementation with j loops would look something like:
for m( 1 ) = 1:d
...
for m( j ) = 1:d
Array( m( 1 ) , ... , m( j ) ) = v{ 1 }( m( j ) ).* ... .*v{ j }( m( j ) ) ;
end
...
end
The indexing of now becomes variable, which I have had no success in implementing.
Does there exist a way of assigning values to an array of arbitrary dimensions in MATLAB in this manner, or perhaps a neater method?
  4 commentaires
Walter Roberson
Walter Roberson le 16 Mar 2019
Modifié(e) : per isakson le 18 Mar 2019
prod(cat(2, v{:}),2)
Michael Ransom
Michael Ransom le 16 Mar 2019
Modifié(e) : Michael Ransom le 16 Mar 2019
Thanks for your answer, Walter.
The answer you have commented returns a vector of length d. Unfortunately, it's not what I'm after. Please see the comment to dpb for further information on the problem if you haven't done so already.
However, the function seems useful for element-wise multiplication across the elements of vectors , as does for concatenating results. I think we might be on the right lines.

Connectez-vous pour commenter.

Réponse acceptée

per isakson
per isakson le 17 Mar 2019
Modifié(e) : per isakson le 18 Mar 2019
"The problem I have is to be able to this with an arbitrary value of j." I think value2arrayND does that. It takes a cell array, {dim1,dim2,dim3,...}, and returns an array, the size of which is [dim1,dim2,dim3,...]. value2array2D and value2array3D are based on the code of your comment. They are used to produce expected values.
>> a2 = value2array2D( );
>> aN2 = value2arrayND( {5,5} );
>> aN2-a2
ans =
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
>> a3 = value2array3D( );
>> aN3 = value2arrayND( {5,5,5} );
>> aN3(:,:,3)-a3(:,:,3)
ans =
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
where
function array = value2arrayND( d )
rng('default'); % for reproducing rand;
N = length(d);
v = cell( 1, N );
for jj = 1 : N
v{ jj } = rand( d{jj}, 1 );
end
array = nan(d{:});
nel = numel( array );
sz = [d{:}];
dim = cell( 1, N );
for ii = 1 : nel
[dim{:}] = ind2sub( sz, ii );
array(ii) = prod( arrayfun( @(jj) v{jj}(dim{jj}), 1:N, 'uni',true ) );
end
end
and
function array = value2array3D( )
rng('default'); % for reproducing rand;
d = { 5, 5, 5 }; % vector length; arbitrary
v{ 1 } = rand( d{1}, 1 ); % vector 1
v{ 2 } = rand( d{2}, 1 ); % vector 2
v{ 3 } = rand( d{3}, 1 ); % vector 3
array = nan(d{:});
for p = 1 : d{1}
for q = 1 : d{2}
for r = 1 : d{3}
array( p, q, r ) = v{ 1 }( p ).*v{ 2 }( q ).*v{ 3 }( r );
end
end
end
end
and
function array = value2array2D( )
rng('default'); % for reproducing rand;
d = { 5, 5 }; % vector length; arbitrary
v{ 1 } = rand( d{1}, 1 ); % vector 1
v{ 2 } = rand( d{2}, 1 ); % vector 2
array = nan(d{:});
for m = 1 : d{1}
for n = 1 : d{2}
array( m, n ) = v{ 1 }( m ).*v{ 2 }( n );
end
end
end
  2 commentaires
Michael Ransom
Michael Ransom le 17 Mar 2019
Thanks for your answer, per isakson.
This is exactly what I was after. A few rearrangements:
clear; clc;
rng = ('default'); % for reproducing rand
d = 5; % vector length
j = 3; % arbitrary value
v = cell( 1 , j ) ;
for m = 1:j
v{ m } = rand( d , 1 ); % vectors 1,...,j
end
Array = value2arrayND( d , j , v ) ;
followed by the function you provided in your answer with a few tweaks:
function Array = value2arrayND( d , j , v )
Array = NaN.*ones( repmat( d , 1 , j ) );
nel = numel( Array );
sz = size( Array );
dim = cell( 1 , j );
for ii = 1:nel
[dim{:}] = ind2sub( sz, ii );
Array( ii ) = prod( arrayfun( @(jj) v{jj}(dim{jj}), 1:length(v), 'uni',true ) );
end
end
Many thanks!
dpb
dpb le 17 Mar 2019
+1 Per...was thinking on those lines when made initial comment; it came to me overnight precisely how and I was all excited this AM to post my clever solution! Then, you beat me to it! :)

Connectez-vous pour commenter.

Plus de réponses (1)

Christine Tobler
Christine Tobler le 17 Juil 2020
Using the somewhat recent implicit expansion, this can also be done without indexing into every element of the array:
function Array = value2arrayND(v)
Array = 1;
for ii=1:length(v)
% Turn d-by-1 vector into 1-by-...-by-1-by-d vector, where d is in dimension ii
viiPermuted = permute(v{ii}(:), [2:ii 1 ii+1:length(v)]);
Array = Array .* viiPermuted;
end
For the 2D case, this corresponds to
Array = v{1}(:) .* v{2}(:).'; % (d-by-1 matrix) .* (1-by-d matrix)

Catégories

En savoir plus sur Matrices and Arrays dans Help Center et File Exchange

Produits


Version

R2018b

Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!

Translated by