没有 varargin 的 inputParser

Question

I would like to use inputParser on the function f(a,b,c,d) , where a is mandatory and bd are optional. I would like to keep bd named = not use f(a, varargin) , because that varargin doesn't tell you anything when you actually want to use the function. The simple p.parse(a,b,c,d) obviously does not work unless all 4 parameters are given.

The only way I know how to do it is to use setDefaultValue(argname, value) , and then use p.parse(...) for checks if needed. But is there a simple way to hack this using just inputParser (without tons of ifs)?

As a side question, there is no easy way to do named arguments like in C# in MATLAB, right? So I would have that f(a,b,c,d) and use as such. First argument is a, then b, then c ... But when the user wanted to call it like f(a, 'd', 3, 'c', 2) , he could. In this example, he would keep default b and use 3 for d and 2 for c. Without tons of work on my side of course - I know how to do it, writing my own parsing of the thing, but I would like a simpler solution (like other person's parsing :))

Answer 1

Im going to give you an alternative answer: Don't be lazy, write docs.

If you do this:

function [out]= foo(a,b,c,d)
%FOO does foo things
%
% FOO(a,b) does very foo thins to a and b
%
% FOO(a,b,c) is quite foo-y on c also
%
% FOO(a,b,c,d) c and d are optional FOO things

if (nargin==3)
...

then if the user presses F1 or types help foo they will get all the information in the comments.

---

To have users able to put inputs such as foo(1,2,'d',5) in my code, I use the following "inputparser" for optional parameters:

function [c,d]=parse_inputs(argin)
opts=     {'c','d'};
defaults=ones(length(opts),1);
% Check inputs
nVarargs = length(argin);
if mod(nVarargs,2)
    error('InvalidInput','Invalid number of inputs')
end

% check if option has been passed as input
for ii=1:2:nVarargs
    ind=find(ismember(opts,lower(argin{ii})));
    if ~isempty(ind)
        defaults(ind)=0;
    else
       error('InvalidInput',['Optional parameter "' argin{ii} '" does not exist' ]); 
    end
end

for ii=1:length(opts)
    opt=opts{ii};
    default=defaults(ii);
    % if one option is not default, then extrac value from input
    if default==0
        ind=double.empty(0,1);jj=1;
        while isempty(ind)
            ind=find(isequal(opt,lower(argin{jj})));
            jj=jj+1;
        end
         if isempty(ind)
            error('InvalidInput',['Optional parameter "' argin{jj} '" does not exist' ]); 
        end
        val=argin{jj};
    end

    switch opt
        case 'c': 
          if default;
             c=4;
          else
             c=val;
          end
     ...
     otherwise
            error('InvalidInput',['Invalid input name:', num2str(opt),'\n No such option in SART()']);
    end
end

Then The first thing I do inside foo is:

[c,d]=parse_inputs(varargin);

Answer 2

The first part of the question on how to handle varying number of inputs without varargin was answered well by Ander Biguri's answer .

Regarding the second part of the question on how to parse inputs in pairs, here is my simplified "input parser" :

function parseVarargin( argin )
% Simplified function to parse varargin property-value pairs

% Read input arguments
if mod(numel(argin),2)
    error('Uneven number of inputs')
end
for i = 1 : 2 : numel(argin)-1
    if ~ischar(argin{i})
        error('Properties must be strings')
    end
    isValid = evalin('caller', sprintf('exist(''%s'',''var'')', argin{i}));
    if isValid && ~strcmp(argin{i},'MRX')
        assignin('caller', argin{i}, argin{i+1})
    else
        error(['Undefined property %s. ', ...
            'Please note case-sensitivity.'], argin{i});
    end
end

To use it, simply set the default variable values and the call parseVarargin on varargin :

function foo( a, varargin )
%FOO general description
%
% Usage:
%   foo(a)
%   foo(a, 'property-value-pairs')
% 
% Properties:
%   b : This ...
%   c : That ...

% Default property values
b = 1;
c = [];

% Read property-value paris
parseVarargin( varargin );

% Do other stuff