How can I check whether an argument is given or not (inputParser)?

Hi everyone,

I think the title is pretty obvious ! To be a little bit more precise, I'm using an InputParser to let the user choose what arguments (s)he wants to use. Therefore I would like to check what optional inputs have been enter or not. InputParser allows to enter name,value paire for each variable and I need something to check if a specific argument exists among all of those enter when the function is called.

It appears that 'isempty' doesn't work. I've also try this but it failed too

 if varargin{:,1} == 'arg_name'
     disp('ok')
 else
     disp('not ok')
 end

(even if cell_structure(:,1)=='string' works outside a function)

Thanks in advance, Edward

Answer 1

[Sean de Wolski]

There's a 'UsingDefaults' property of the inputParser that is populated after it is parsed. This will tell you which variables are not using the default value.

https://www.mathworks.com/help/releases/R2016b/matlab/ref/inputparser-class.html

[Ezor]

I had not thought about that but I seems to be a good solution to bypass this issue. Thank you

Answer 2

[Guillaume]

Well, if the behaviour of your code is going to change depending on whether or not an optional input was given, then it's not really an optional input anymore.

inputParser does not offer the option of knowing which of the optional inputs were actually given. If you really need that, you're going to have to write your own input parser or reparse the optional parameters yourself.

[Ezor]

Thanks for your answer. Actually, I said 'optional' but it doesn't really matter. I am looking for something to look into varargin in order to know if parameter 'arg_name' is given or not (without for loop everywhere!)

[Guillaume]

function my_function(varargin)
   valid_argnames = {'arg_name1', 'arg_name2', 'arg_name3'};
   argwasspecified = ismember(valid_argnames, varargin(1:2:end));
   %...

each element of argwasspecified is true if the corresponding element of valid_argnames is specified anywhere in the odd elements of varargin.

Note that ismember comparison is case sensitive. If you need case-insensitive you can wrap varargin(1:2:end) in lower.

Unlike inputParser, this does not support partial matches. This would require significantly more work.

edited: bug in indexing of varargin

[Ezor]

Thank you. That could do the trick. I'll try this and let you know if the ismember function suits my need.

Answer 3

[Ian]

A bit late to the game here, but expanding on Sean de Wolski's brief suggestion, here is a code snippet that should satisfy. This is essentially the inverse of Guillaume's approach -- test for the absence of a parameter in the UsingDefaults

function  test_used(varargin)
    p = inputParser;
    addOptional(p,'opt1',[]);
    addParameter(p,'arg1',[]);
    addParameter(p,'arg2',[]);    
    parse(p,varargin{:}); 
    
    if (~ismember('opt1',p.UsingDefaults)), fprintf('opt1 present\n'); end
    if (~ismember('arg1',p.UsingDefaults)), fprintf('arg1 present\n'); end
    if (~ismember('arg2',p.UsingDefaults)), fprintf('arg2 present\n'); end
end

and showing results:

>> test_used(10)
opt1 present
>> test_used(10,'arg2','goodbye')
opt1 present
arg2 present
>> test_used('arg1','hello')
arg1 present

This is similar to Guillaume's solution above, which is also good, but won't work if you have optional positional parameters (addOptional(...) ) or if the parser's StructExpand it set to true.

For those curious why this is needed, or at least useful: it allows setting related parameters when an optional or key/value pair is specified, without overriding a user setting. For example, I might want to set arg2 to arg1's value if the user specifies arg1 only, but keep the user's arg2 setting if both arg1 and arg2 are passed in.

[Maikel Zhilin]

This < > helped me, thank you :)

< ~ismember('arg1',p.UsingDefaults) >

Answer 4

[KSSV]

function Hello(varargin)
if nargin==1
    disp('Okay')
else
    disp('not okay')
end

It takes any inputs, for one input it says ok for other inputs it says not ok.

[Ezor]

thanks for your answer. Your solution could work if I had only one parameter. Unfortunately the function's call looks like

   my_function('arg_name1',value1,'arg_name2',value2,..)

I would like to check whether my_target is present among the arguments (namely if arg_name1 or arg_name2 is the same as my_target) or not.

[KSSV]

The given code can make to work for any input parameters.

[Ezor]

Maybe, but in that case there is something I don't understand. The code you gave me counts the arguments, but in my case, I don't know which one will be entered in 1st position and 2nd position. I'd like to dertermine if a given string my_target belongs to a list/array/cell array ('arg_name1','arg_name2')

[KSSV]

function Hello(varargin)
N = nargin ;
inputs = cell(N,1) ;
for i = 1:N
    inputs{i} = varargin{i} ;
    class(inputs{i})
end

Call it by Hello('Distance',3,'Velocity',{5})

Function will tell the classes of the inputs. Depending on your usage, you can code in the way you want.

Answer 5

[Leon]

Is there any reason not to use exist("arg_name", "var") ? It doesn't give a false positive for a global of the same name.

Maybe it would be too slow if you are calling the function many times per second.

[Walter Roberson]

@Leon

The context is the parser for name/value pairs. The pseudo-variable that gets coded to "absorb" those is varargin . If varargin has been declared in the function header, then it will always exist for exit("varargin", "var") purposes -- it might just be empty if no name/value pairs were entered.

[Leon]

Sorry, you're right. I thought you would be able to check for the existence of the actual individual argument by name, but it looks like Matlab's approach will force it to exist with its default value – you can't just let it not exist. My bad.

Another option would be to set a dummy default value such as "Not set" and check for that (and Matlab lets it be something that would fail the validation, so you can usually avoid using something that could be a valid input) but the UsingDefaults is obviously a much better approach.