# [ACCEPTED]-How to elegantly ignore some return values of a MATLAB function-return-value

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

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

Note that the `,`

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

will not work, and will throw an 1 error.

See the release notes for details.

This is somewhat of a hack, but it works:

First 8 a quick example function:

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

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

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

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

if all you 2 care about from `polyfit`

is the third argument.)

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

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

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

`ans`

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

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

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

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

Here's another option you can use. First 6 make a cell array to capture all the outputs 5 (you can use the NARGOUT function to determine 4 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 3 call the function as follows:

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

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

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

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

You can then 6 call

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

You could also wrap up the function 5 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 4 is overhead associated with using anonymous 3 functions like this, and this is not something 2 I would do in code that would be called 1 thousands of times.

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

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

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

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

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

Then 2 you can call your function like this:

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

Or 1 you can assign the output to a variable:

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

There isn't any reason not to use ans(n). Like 7 this:

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

It gives b = 10, and this way would 6 be compatible with all MATLAB versions.

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

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

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

, to catch 1 more arguments!)

More Related questions

We use cookies to improve the performance of the site. By staying on our site, you agree to the terms of use of cookies.