Comment puis-je indexer un tableau MATLAB retourné par une fonction sans d'abord l'assigner à une variable locale?

Par exemple, si je veux lire la valeur intermédiaire magic(5), je peux le faire comme ceci:

M = magic(5);
value = M(3,3);

obtenir value == 13. J'aimerais pouvoir faire quelque chose comme l'un d'eux:

value = magic(5)(3,3);
value = (magic(5))(3,3);

de se passer de la variable intermédiaire. Cependant, MATLAB se plaint de Unbalanced or unexpected parenthesis or bracketla première parenthèse avant le 3.

Est-il possible de lire les valeurs d'un tableau / d'une matrice sans d'abord l'assigner à une variable?

En fait, il est possible de faire ce que vous voulez, mais vous devez utiliser la forme fonctionnelle de l'opérateur d'indexation. Lorsque vous effectuez une opération d'indexation à l'aide de (), vous effectuez en fait un appel à la subsreffonction. Donc, même si vous ne pouvez pas faire cela:

value = magic(5)(3, 3);

Vous pouvez le faire:

value = subsref(magic(5), struct('type', '()', 'subs', {{3, 3}}));

Moche, mais possible. ;)

En général, il vous suffit de modifier l'étape d'indexation en un appel de fonction afin de ne pas avoir deux jeux de parenthèses qui se suivent immédiatement. Une autre façon de procéder serait de définir votre propre fonction anonyme pour effectuer l'indexation en indice. Par exemple:

subindex = @(A, r, c) A(r, c);     % An anonymous function for 2-D indexing
value = subindex(magic(5), 3, 3);  % Use the function to index the matrix

Cependant, quand tout est dit et fait, la solution de variable locale temporaire est beaucoup plus lisible, et certainement ce que je suggérerais.

Il y a juste un bon article de blog sur Loren sur l'Art du Matlab il y a quelques jours avec quelques gemmes qui pourraient aider. En particulier, en utilisant des fonctions d'assistance comme:

paren = @(x, varargin) x(varargin{:});
curly = @(x, varargin) x{varargin{:}};

où paren()peut être utilisé comme

paren(magic(5), 3, 3);

retournerais

ans = 16

Je suppose également que ce sera plus rapide que la réponse de gnovice, mais je n'ai pas vérifié (utilisez le profileur !!!). Cela étant dit, vous devez également inclure ces définitions de fonction quelque part. Personnellement, je leur ai fait des fonctions indépendantes sur mon chemin, car elles sont super utiles.

Ces fonctions et d'autres sont désormais disponibles dans le module complémentaire Functional Programming Constructs, disponible via l'explorateur de modules complémentaires MATLAB ou sur l' échange de fichiers .

Que pensez-vous de l'utilisation de fonctionnalités non documentées:

>> builtin('_paren', magic(5), 3, 3)               %# M(3,3)
ans =
    13

ou pour les réseaux de cellules:

>> builtin('_brace', num2cell(magic(5)), 3, 3)     %# C{3,3}
ans =
    13

Comme par magie :)

MISE À JOUR:

Mauvaise nouvelle, le hack ci-dessus ne fonctionne plus dans R2015b ! C'est très bien, c'était une fonctionnalité non documentée et nous ne pouvons pas nous y fier en tant que fonctionnalité prise en charge :)

Pour ceux qui se demandent où trouver ce type de chose, regardez dans le dossier fullfile(matlabroot,'bin','registry'). Il y a un tas de fichiers XML qui répertorient toutes sortes de goodies. Soyez averti que l'appel direct de certaines de ces fonctions peut facilement planter votre session MATLAB.

Au moins dans MATLAB 2013a, vous pouvez utiliser getfieldcomme:

a=rand(5);
getfield(a,{1,2}) % etc

pour obtenir l'élément à (1,2)

malheureusement, la syntaxe magic(5)(3,3)n'est pas supportée par matlab. vous devez utiliser des variables intermédiaires temporaires. vous pouvez libérer de la mémoire après utilisation, par exemple

tmp = magic(3);
myVar = tmp(3,3);
clear tmp

Notez que si vous comparez les temps d'exécution avec la méthode standard (attribuez le résultat puis accédez aux entrées), ils sont exactement les mêmes.

subs=@(M,i,j) M(i,j);
>> for nit=1:10;tic;subs(magic(100),1:10,1:10);tlap(nit)=toc;end;mean(tlap)

ans =

0.0103

>> for nit=1:10,tic;M=magic(100); M(1:10,1:10);tlap(nit)=toc;end;mean(tlap)

ans =

0.0101

À mon avis, l'essentiel est: MATLAB n'a pas de pointeurs, vous devez vivre avec.

Cela pourrait être plus simple si vous créez une nouvelle fonction:

function [ element ] = getElem( matrix, index1, index2 )
    element = matrix(index1, index2);
end

puis l'utiliser:

value = getElem(magic(5), 3, 3);

Votre notation initiale est la façon la plus concise de le faire:

M = magic(5);  %create
value = M(3,3);  % extract useful data
clear M;  %free memory

Si vous faites cela en boucle, vous pouvez simplement réaffecter M à chaque fois et ignorer la déclaration claire également.

Pour compléter la réponse d'Amro, vous pouvez utiliser à la fevalplace de builtin. Il n'y a vraiment aucune différence, sauf si vous essayez de surcharger la fonction opérateur:

BUILTIN (...) est le même que FEVAL (...) sauf qu'il appellera la version intégrée d'origine de la fonction même s'il existe une surcharge (pour que cela fonctionne, vous ne devez jamais surcharger BUILTIN).

>> feval('_paren', magic(5), 3, 3)               % M(3,3)
ans =
    13

>> feval('_brace', num2cell(magic(5)), 3, 3)     % C{3,3}
ans =
    13

Ce qui est intéressant, c'est que cela fevalsemble être un tout petit peu plus rapide que builtin(de ~ 3,5%), du moins dans Matlab 2013b, ce qui est bizarre étant donné qu'il fevalfaut vérifier si la fonction est surchargée, contrairement à builtin:

>> tic; for i=1:1e6, feval('_paren', magic(5), 3, 3); end; toc;
Elapsed time is 49.904117 seconds.
>> tic; for i=1:1e6, builtin('_paren', magic(5), 3, 3); end; toc;
Elapsed time is 51.485339 seconds.