Wie kann man einige Rückgabewerte einer MATLAB-Funktion elegant ignorieren?

Ist es möglich, den 'n-ten' Rückgabewert von einer Funktion abzurufen, ohne vorher Dummy-Variablen für alle n-1Rückgabewerte erstellen zu müssen ?

Angenommen, ich habe die folgende Funktion in MATLAB:

function [a,b,c,d] = func()
a = 1;
b = 2;
c = 3;
d = 4;

Angenommen, ich interessiere mich nur für den dritten Rückgabewert. Dies kann durch Erstellen einer Dummy-Variablen erreicht werden:

[dummy, dummy, variableThatIWillUse, dummy] = func;
clear dummy;

Aber ich finde das irgendwie hässlich . Ich würde denken, dass Sie in der Lage sein könnten, so etwas wie eines der folgenden Dinge zu tun, aber Sie können nicht:

[_, _, variableThatIWillUse, _] = func;

[, , variableThatIWillUse, ] = func;

variableThatIWillUse = func(3);

variableThatIWillUse = func()(3);

Gibt es elegante Möglichkeiten, dies zu tun, die funktionieren?

Bisher besteht die beste Lösung darin, die variableThatIWillUseVariable einfach als Dummy-Variable zu verwenden. Dies erspart mir die Erstellung einer echten Dummy-Variablen, die den Arbeitsbereich verschmutzt (oder die ich löschen müsste). Kurz gesagt: Die Lösung besteht darin, den variableThatIWillUseWert für jeden Rückgabewert bis zum interessanten zu verwenden. Rückgabewerte nach können einfach ignoriert werden:

[variableThatIWillUse, variableThatIWillUse, variableThatIWillUse] = func;

Ich denke immer noch, dass dies ein sehr hässlicher Code ist, aber wenn es keinen besseren Weg gibt, werde ich die Antwort wahrscheinlich akzeptieren.

Dies ist ein bisschen wie ein Hack, aber es funktioniert:

Zunächst eine kurze Beispielfunktion:

Func3 = @() deal(1,2,3);
[a,b,c]=Func3();
% yields a=1, b=2, c=3

Der Schlüssel hier ist nun, dass, wenn Sie eine Variable auf der linken Seite einer Zuweisung mit mehreren Ausdrücken zweimal verwenden , eine frühere Zuweisung durch die spätere Zuweisung beeinträchtigt wird:

[b,b,c]=Func3();
% yields b=2, c=3

[c,c,c]=Func3();
% yields c=3

(Bearbeiten: Nur um zu überprüfen, habe ich auch überprüft, ob diese Technik funktioniert, [mu,mu,mu]=polyfit(x,y,n)wenn alles, was Sie interessiert, polyfitdas dritte Argument ist.)

edit: es gibt einen besseren Ansatz; Siehe stattdessen die Antwort von ManWithSleeve .

Mit MATLAB Version 7.9 (R2009b) können Sie ein ~ verwenden, z.

[~, ~, variableThatIWillUse] = myFunction();

Beachten Sie, dass das ,nicht optional ist. Nur das Tippen [~ ~ var]funktioniert nicht und wirft einen Fehler auf.

Weitere Informationen finden Sie in den Versionshinweisen.

Wenn Sie einen Stil verwenden möchten, bei dem eine Variable in den Bit-Bucket fällt, ist dies eine sinnvolle Alternative

[ans,ans,variableThatIWillUse] = myfun(inputs);

ans ist natürlich die Standard-Junk-Variable für matlab, die im Verlauf einer Sitzung häufig überschrieben wird.

Ich mag zwar den neuen Trick, den MATLAB jetzt zulässt, indem ein ~ verwendet wird, um eine ignorierte Rückgabevariable zu kennzeichnen, dies ist jedoch ein Problem für die Abwärtskompatibilität, da Benutzer älterer Versionen Ihren Code nicht verwenden können. Ich vermeide es im Allgemeinen, solche neuen Dinge zu verwenden, bis mindestens einige MATLAB-Versionen veröffentlicht wurden, um sicherzustellen, dass nur noch sehr wenige Benutzer im Stich gelassen werden. Zum Beispiel finde ich, dass die Leute auch jetzt noch eine MATLAB-Version verwenden, die alt genug ist, um keine anonymen Funktionen verwenden zu können.

Hier ist eine weitere Option, die Sie verwenden können. Erstellen Sie zunächst ein Zellenarray, um alle Ausgaben zu erfassen (Sie können die NARGOUT- Funktion verwenden, um zu bestimmen, wie viele Ausgaben eine bestimmte Funktion zurückgibt):

a = cell(1,3);  % For capturing 3 outputs
% OR...
a = cell(1,nargout(@func));  % For capturing all outputs from "func"

Rufen Sie dann die Funktion wie folgt auf:

[a{:}] = func();

Dann entfernen Sie einfach das Element aus einem , dass Sie möchten, und überschreiben ein :

a = a{3};  % Get the third output

Ich habe eine k-te Funktion geschrieben:

function kth = kthout(k,ffnc,varargin)
%% kthout: take the kth varargout from a func call %FOLDUP
% 
% kth = kthout(k,ffnc,varargin)
%
% input:
%  k                      which varargout to get
%  ffnc                   function to call;
%  varargin               passed to ffnc;
% output:
%  kth                    the kth argout;
% global:
% nb: 
% See also:
% todo:
% changelog: 
%
%% %UNFOLD

[outargs{1:k}]  = feval(ffnc,varargin{:});
kth                         = outargs{k};

end %function

Sie können dann anrufen

val_i_want  = kthout(3,@myfunc,func_input_1,func_input_2); %etc

Sie können die Funktion auch wie folgt abschließen

func_i_want = @(varargin)(kthout(3,@myfunc,varargin{:}));  %assuming you want the 3rd output.

Danach verwenden Sie

val_i_want = func_i_want(func_input_1,func_input_2);

Beachten Sie, dass mit der Verwendung anonymer Funktionen wie dieser Overhead verbunden ist, und dies würde ich nicht in Code tun, der tausende Male aufgerufen wird.

In Matlab 2010a habe ich eine gute Möglichkeit gefunden, das zu tun, wonach Sie fragen. Es ist einfach, das Zeichen "~" (natürlich ohne Anführungszeichen) als Dummy-Variable zu verwenden (so viele, wie Sie möchten, wenn Sie mehrere Parameter zurückgeben). Dies funktioniert auch für Eingabeparameter für Funktionen, wenn die Funktionen für die Verarbeitung fehlender Daten ausgelegt sind. Ich weiß nicht, ob dies in früheren Versionen vorhanden war, aber ich bin erst kürzlich darauf gestoßen.

Sie können eine Funktion (oder eine anonyme Funktion) erstellen, die nur ausgewählte Ausgaben zurückgibt, z

select = @(a,b) a(b);

Dann können Sie Ihre Funktion folgendermaßen aufrufen:

select(func,2);
select(func,1:3);

Oder Sie können die Ausgabe einer Variablen zuweisen:

output(1,2:4) = select(func,1:3);

Gibt es einen Grund, ans (n) nicht wie folgt zu verwenden:

a=rand([5 10 20 40]);

size(a);

b=ans(2);

Gibt b = 10 und wäre dieser Weg nicht mit allen Matlab-Versionen kompatibel?

Außerdem funktioniert dies, um das zweite Ausgabeargument zu erhalten, wenn Sie nicht wissen, wie viele Argumente es geben wird! Wenn Sie dies tun:

[~, b] = size(a);

Dann ist b = 8000! (Sie müssen mit ~ enden, um mehr Argumente zu fangen!)