# How to elegantly ignore some return values of a MATLAB function

MatlabFunctionReturn Value## Matlab Problem Overview

Is it possible to get the 'nth' return value from a function without having to create dummy variables for all `n-1`

return values before it?

Let's say, I have the following function in MATLAB:

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

Now suppose, I'm only interested in the *third* return value. This can be accomplished by creating one dummy variable:

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

But I think this is kind of *ugly*. I would think that you might be able to do something like one of the following things, but you can't:

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

`[, , variableThatIWillUse, ] = func;`

`variableThatIWillUse = func(3);`

`variableThatIWillUse = func()(3);`

Are there any *elegant* ways to do this that do work?

So far, the best solution is to simply use the `variableThatIWillUse`

as a dummy variable. This saves me from having to create a real dummy variable that pollutes the work-space (or that I would need to clear). In short: the solution is to use the `variableThatIWillUse`

for every return value up until the interesting one. Return values after can simply be ignored:

```
[variableThatIWillUse, variableThatIWillUse, variableThatIWillUse] = func;
```

I still think this is very ugly code.

## Matlab Solutions

## Solution 1 - Matlab

With MATLAB Version 7.9 (R2009b) you can use a ~, e.g.,

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

Note that the `,`

isn't optional. Just typing `[~ ~ var]`

will not work, and will throw an error.

See the release notes for details.

## Solution 2 - Matlab

This is somewhat of a hack, but it works:

First a quick example function:

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

Now the key here is that if you use a variable **twice** on the left-hand side of a multiple-expression assignment, an earlier assignment is clobbered by the later assignment:

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

(Just to check, I also verified that this technique works with `[mu,mu,mu]=polyfit(x,y,n)`

if all you care about from `polyfit`

is the third argument.)

There's a better approach; see ManWithSleeve's answer instead.

## Solution 3 - Matlab

If you wish to use a style where a variable will be left to fall into the bit bucket, then a reasonable alternative is

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

`ans`

is of course the default junk variable for MATLAB, getting overwritten often in the course of a session.

While I do like the new trick that MATLAB now allows, using a `~`

to designate an ignored return variable, this is a problem for backwards compatibility, in that users of older releases will be unable to use your code.

I generally avoid using new things like that until at least a few MATLAB releases have been issued to ensure there will be very few users left in the lurch. For example, even now I find people are still using an old enough MATLAB release that they cannot use anonymous functions.

## Solution 4 - Matlab

Here's another option you can use. First make a cell array to capture all the outputs (you can use the NARGOUT function to determine how many outputs a given function returns):

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

Then call the function as follows:

```
[a{:}] = func();
```

Then simply remove the element from **a** that you want, and overwrite **a**:

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

## Solution 5 - Matlab

I wrote a kth out function:

```
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;
[outargs{1:k}] = feval(ffnc, varargin{:});
kth = outargs{k};
end %function
```

You can then call

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

You could also wrap up the function like:

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

After which you use

```
val_i_want = func_i_want(func_input_1, func_input_2);
```

Note that there is overhead associated with using anonymous functions like this, and this is not something I would do in code that would be called thousands of times.

## Solution 6 - Matlab

In MATLAB 2010a, I found a neat way of doing what you are asking for.

It is simply to use the character "~" (without the quotes of course) as your dummy variable (as many as you want when returning multiple parameters). This also works for input parameters to functions if the functions are designed to handle missing data.

I don't know if this existed in previous versions, but I just came across it recently.

## Solution 7 - Matlab

You can make a function (or anonymous function) that only returns selected outputs, e.g.

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

Then you can call your function like this:

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

Or you can assign the output to a variable:

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

## Solution 8 - Matlab

I don't see any reason not to use ans(n). Like this:

```
size(rand([5 10 20 40]));
b = ans(2);
```

It gives b = 10, and this way would be compatible with all MATLAB versions. Note that size() here is just used to represent any function that has multiple return variables.

Furthermore, this works to get the second output argument when you don't know how many arguments there will be! Whereas, if you do this:

```
[~, b] = size(a);
```

Then b = 8000! (You need to end with `~`

, to catch more arguments!)