How to formulate elegantly and performant functions that depend on a lot of input variables

Hello,

I am not new to MATLAB. However, I have the following problem:

If I have a function e.g.:

output = f(in1,in2,in3,in4,in5,in6,...)

which depends on a lot of input variables.

How can I design it as elegant as possible but at the same time performant?

If I use a struct e.g.

input.in1
input.in2
input.in3 

...

I can formulate the function nice and short:

output = f(input)

But the problem is that the variable naming is fixed for the input as well as in the function. Furthermore, calling values from a struct is slow, so in the function they have to be read first:

function [output] = f(input)
    in1    =  input.in1
    in2    =  input.in2
    in3    =  input.in3 
     ...
    % calculations with in1,in2,in3,...
end

I also know that you should not write a function with so many input variables, yet it happens.

How do you handle such cases?

[Bjorn Gustavsson]

Sometimes a function requires a large number of input arguments. Then it is just to accept ones fate and program it that way. When it comes to options-type arguments I often combine them into a single struct. I find that neater than the "name-value" system used in matlab. But that is partly another question, and a matter of taste.

[Stephen23]

A large number of input arguments increases the risk of mixing up the inputs when calling the function. I have answered questions on this forum where bugs were caused by exactly this problem: too many input arguments, changes to the function, OP lost track of the inputs, no warnings or errors, surprisingly difficult to track down. How descriptive the names are is irrelevant for this to occur.

Use a structure. Acessing data from the structure is unlikely to be the slowest part of your code.

If after billions/trillions of iterations your code runs five minutes slower accessing data from a structure but you save yourself hours of debugging time, then it is still a net gain for you. Summary: write code that is reliable, this is a better use of your time.

[lk]

To mitigate the problem that Stephen Cobeldick mentions, namely

Stephen Cobeldick on 24 Jan 2021 at 6:35

... OP lost track of the inputs, no warnings or errors, surprisingly difficult to track down. ...

You could try (if you haven’t already) function argument validation introduced in R2020b. In particular, it will provide specific error messages for invalid inputs.

Here is the doc link

https://www.mathworks.com/help/matlab/matlab_prog/function-argument-validation-1.html

[Adam Danz]

To add to lk's comment, for releases prior to 20b check out input parser and other input validation techniques.

[Stephen23]

@lk: that works if the data are distinguishable. A whole lot of scalar numeric parameters may be completely indistiguishable by value or range if swapped around... you can find threads on this forum where this has occurred.

[Bjorn Gustavsson]

@Stephen: In the case of "forgetting order" one has the help-section. If my head is really on the line I make sure to check even the order of inputs to atan2.

[Adam Danz]

Another on of my favorites: The opposite order of inputs 1 & 2 in boxplot vs boxchart.

[Walter Roberson]

But the problem is that the variable naming is fixed for the input as well as in the function.

Though there is a sense in which name/value pairs involves "variable naming is fixed for the input as well as in the function", and people use name/value pairs all the time.

Answer 1

[Adam Danz]

A set of inputs like the example you shared is not inelegent. Some may argue that it's more elegant than the alternatives. What is inelegent is the undescriptive function and variable names which I'm guessing is just for the example.

• If all inputs are numeric scalars or arrays of the same size and class, you could require the user to concatentate the values into a single multidimensional array and then the function can index or deconstruct the array as needed, but that's more work if the inputs are typically indpendent variables to begin with. Curve fitting functions often require this syntax for the objective function.
• Another common solution is to use a cell array that support mixed classes and sizes but that also requires more work for the user to set up. For example,

in = {1, struct('t',5), 'a', false};
out = f(in);

• If some of the inputs are not required you could use a varargin to reduce the number of input variables declared within the function. That requires carefully unpacking them, of course.
• If the goal is to keep the variable references tidy within the function, you can use the input parser which validates and stores all inputs within a structure inside the function. That structure is used instide the function instead of the input variable names. I often use this approach to tidy-up the code.

Answer 2

[Divija Aleti]

Hi Ferdinand,

Have a look at the Accepted Answer (and the comment under it) for the question posed in the following link:

Passing multiple variables to function in 1 input - MATLAB Answers - MATLAB Central (mathworks.com)

For more information, refer to the link given below:

TUTORIAL: Why Variables Should Not Be Named Dynamically (eval) - MATLAB Answers - MATLAB Central (mathworks.com)

Regards,

Divija

[Adam Danz]

The OP hasn't indicated that they want to name variables dynamically, though.

[Ferdinand Breit]

Hello,

thanks for your answers and comments, then it seems there is no real solution without using strcuts or cells.

Knowing this is also very helpful. Thanks!

Answer 3

[David Correa]

Usar variables globales podría ser una opción más eficiente que pasar una estructura

[Walter Roberson]

No, global variables are the slowest kind of variables that exist. Referencing a variable that is a parameter is the fastest kind of variable access.

Answer 4

[MATLAB WAN]

I usually using cell。