¿Cómo ignorar elegantemente algunos valores de retorno de una función MATLAB?

¿Es posible obtener el valor de retorno 'enésimo' de una función sin tener que crear variables ficticias para todos los n-1valores de retorno anteriores?

Digamos que tengo la siguiente función en MATLAB:

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

Ahora suponga que solo me interesa el tercer valor de retorno. Esto se puede lograr creando una variable ficticia:

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

Pero creo que esto es algo feo . Creo que podría hacer algo como una de las siguientes cosas, pero no puede:

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

[, , variableThatIWillUse, ] = func;

variableThatIWillUse = func(3);

variableThatIWillUse = func()(3);

¿Hay alguna forma elegante de hacer esto que funcione?

Hasta ahora, la mejor solución es simplemente usar variableThatIWillUsecomo variable ficticia. Esto me evita tener que crear una variable ficticia real que contamine el espacio de trabajo (o que necesitaría borrar). En resumen: la solución es usar el variableThatIWillUsepara cada valor de retorno hasta el interesante. Los valores devueltos después pueden simplemente ignorarse:

[variableThatIWillUse, variableThatIWillUse, variableThatIWillUse] = func;

Sigo pensando que este es un código muy feo, pero si no hay una mejor manera, supongo que aceptaré la respuesta.

Esto es algo así como un truco pero funciona:

Primero, una función de ejemplo rápido:

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

Ahora, la clave aquí es que si usa una variable dos veces en el lado izquierdo de una asignación de expresión múltiple, una asignación anterior se ve afectada por la asignación posterior:

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

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

(editar: solo para verificar, también verifiqué que esta técnica funciona [mu,mu,mu]=polyfit(x,y,n)si todo lo que le importa polyfites el tercer argumento)

editar: hay un mejor enfoque; vea la respuesta de ManWithSleeve en su lugar.

Con MATLAB Versión 7.9 (R2009b) puede usar un ~, por ejemplo,

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

Tenga en cuenta que ,no es opcional. Simplemente escribir [~ ~ var]no funcionará y arrojará un error.

Consulte las notas de la versión para obtener más detalles.

Si desea utilizar un estilo en el que se dejará que una variable caiga en el cubo de bits, una alternativa razonable es

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

ans es, por supuesto, la variable basura predeterminada para matlab, y se sobrescribe a menudo en el transcurso de una sesión.

Si bien me gusta el nuevo truco que ahora permite MATLAB, el uso de ~ para designar una variable de retorno ignorada, es un problema de compatibilidad con versiones anteriores, ya que los usuarios de versiones anteriores no podrán usar su código. Por lo general, evito usar cosas nuevas como esa hasta que se hayan publicado al menos algunas versiones de MATLAB para garantizar que queden muy pocos usuarios en la estacada. Por ejemplo, incluso ahora encuentro que la gente sigue usando una versión de MATLAB lo suficientemente antigua como para no poder usar funciones anónimas.

Aquí tienes otra opción que puedes usar. Primero haga una matriz de celdas para capturar todas las salidas (puede usar la función NARGOUT para determinar cuántas salidas devuelve una función dada):

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

Luego llame a la función de la siguiente manera:

[a{:}] = func();

Luego, simplemente elimine el elemento de a que desee y sobrescriba a :

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

Escribí una función kth out:

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

entonces puedes llamar

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

también puede terminar la función como

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

después de lo cual usas

val_i_want = func_i_want(func_input_1,func_input_2);

tenga en cuenta que hay una sobrecarga asociada con el uso de funciones anónimas como esta, y esto no es algo que haría en un código que se llamaría miles de veces.

En Matlab 2010a, encontré una forma elegante de hacer lo que está pidiendo. Es simplemente usar el carácter "~" (sin las comillas, por supuesto) como su variable ficticia (tantas como desee al devolver múltiples parámetros). Esto también funciona para los parámetros de entrada a las funciones si las funciones están diseñadas para manejar datos faltantes. No sé si esto existía en versiones anteriores, pero me lo encontré recientemente.

Puede crear una función (o función anónima) que solo devuelva salidas seleccionadas, por ejemplo

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

Entonces puedes llamar a tu función así:

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

O puede asignar la salida a una variable:

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

¿Hay alguna razón para no usar ans (n), como esta:

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

size(a);

b=ans(2);

Da b = 10, ¿y de esta manera no sería compatible con todas las versiones de Matlab?

Además, esto funciona para obtener el segundo argumento de salida cuando no se sabe cuántos argumentos habrá. Considerando que, si haces esto:

[~, b] = size(a);

¡Entonces b = 8000! (¡Tienes que terminar con ~ para captar más argumentos!)