Best Practice: Many Functions relying on Global Variables?

TL;DR: Many answers and help pages recomend avoiding global variables. However, in the case of many functions relying on the same constants, it feels almost unavoidable. What then is best practice? Just use global variables, or is there something better?

The recomendations against global variables

1. https://www.mathworks.com/help/matlab/ref/global.html
2. https://www.mathworks.com/matlabcentral/answers/347418-global-variable-not-seen-by-function-the-function-creates-a-new-empty-variable
3. https://www.mathworks.com/help/optim/ug/passing-extra-parameters.html
4. https://www.mathworks.com/help/matlab/math/parameterizing-functions.html

The Conundrum

I want to explore how a system with many physical parameters varies in response to changes to some of those variables. Say I have ~50 parameters, and I want to sweep a couple of them at a time.

I'd like to break my code up into modular pieces that correspond to physical subsystems that I am simulating.

My Current Solution

I tucked all my parameters into a file, "loadParams.m", which contains over 50 variable assignments like: thing1 = 7.34983. I did not make it a function, so that all the assignments by default go into my main file workspace (which I'm not sure is the same as global or not)

To sweep a few of the parameters, in my main file I have:

loadParams; %this is a script (no not a function). This defines parameters 'thing1' through 'thing50'.
thing2 = 8; %changing one of the parameters from default

for thing1 = 1:20
    procedure1 %computes and stores a results0 variable
    result1 = myfun1(myfun2()+myfun3(), myfun4(7)); 
    result2 = myfun5()
end

%more stuff follows to plot the results.

Is there a better way to do this?

Issues with solutions I've seen

• Just plug all the variables as arguments to each function.
• With 50 parameters, this would make the code bulky and unreadable
• Use global variables like I did:
• easy to make mistakes.
• I've been having some issue with the 'loadParams' parameters not getting read by my functions.
• Then I have to go in and pepper 'global' inside my various files.
• Use annonomous functions
• still ends up being bulky.
• I'd have to define my functions with 50+ inputs
• Then I'd have to clutter my main file with myf1 = @(variable) myfun1(thing1,thing2,thing3,thing4 ...)
• And then I'd have to do that for each function, and hope that I type in the same values for thing1 ...
• Use functions that assume default values for any variable not passed to the function
• Matlab doesn't seem to have a clean way of doing this
• I'd have to put in default values for each function that are the same across all of the functions, so
• it's easy to make mistakes.
• And hard to change the defaults

[Chandler Hall]

It would be helpful to know how exactly you have everything organized. Do you have dozens of functions defined in seperate .m files which you will be ultimately calling from a single main function with a GUI? Are you looking to use all of these functions with the same static data but able to be called independently from the CLI for instance?

[Stephen23]

Two common, robust, easy solutions:

• use a structure
• write a class

[Orion Smedley]

@Stephen23 Would you then pass the structure or class as an argument to the functions?

Or were you thinking of a different way?

[Orion Smedley]

@Chandler Hall yes I have several functions in separate.m files. I haven't broken up the code into as many .m files as as I would like because of this issue with passing arguments. Which means that there's repetative code shared among the different files currently.

But ideally, I'd be able to run a few commands to run the calcualtions from within a live script (which Is what I'm using now), and then be able to plot those results.

(It would be really nice to have something like pivot charts in excel, so I can run a sweep of a few parameters simultatneuously, and then plot the diferernt combinations easlily.)

[Stephen23]

"Would you then pass the structure or class as an argument to the functions?"

Yes. Passing input/output arguments is the simplest and most efficient way of passing data between workspaces, as the MATLAB documentation makes clear:

https://www.mathworks.com/help/matlab/matlab_prog/share-data-between-workspaces.html

"Or were you thinking of a different way?"

I would not make passing data more complex and less efficient, unless there was a good reason to do so.

[Bruno Luong]

@Stephen23 "Yes. Passing input/output arguments is the simplest and most efficient way"

Not quite: The overhead of passing structure as argument might be small, but accessing to the field can be costly (of course depend on the code, the overhead can be matter or negligible).

Steve's instantless class method (see James's answer) is about 4 time faster as showed in this test.

for k=1:50
    s.(sprintf('f%d', k)) = rand;
    % fprintf('p%d = %f;\n', k, rand); % used to generate myconstants
end

tic
structmethod(s);
toc

Elapsed time is 0.117789 seconds.

tic
classmethod();
toc

Elapsed time is 0.037190 seconds.

function structmethod(s)
for k=1:1e6
    x = s.f1; % accssing f1 is more costly than f50
end
end

function classmethod()
for k=1:1e6
    x = myconstants.p1;  % accssing p1 is about the same than p50
end
end

[Stephen23]

"Not quite: The overhead of passing structure as argument might be small, but accessing to the field can be costly (of course depend on the code, the overhead can be matter or negligible). "

In most cases this is very unlikely to be a major time consumer. In the vast majority of cases, a simple structure is quite sufficient. Until the user has confirmed the cause of the bottleneck, the extra complexity is ... just extra complexity.

Efficiency is not just program runtime, but total time to code, debug, etc.

[Bruno Luong]

I don't see why Steve method is complex.

The structure method does need to passing around as argument of functions.

Steve method is simpler: call it when one need it. In contrary it's the most simple and most efficient.

[Stephen23]

"I don't see why Steve method is complex."

You are a highly experienced programmer with many years of experience. Not every one is at your level.

Some users struggle with indexing. Some users struggle with getting a single function defined or called.

"In contrary it's the most simple ..."

Perhaps nested functions are?

But really until we define metrics for "complexity" and "efficiency", this is all moot. Thanks for the interesting chat.

Answer 1

[James Tursa]

See this link for a related discussion involving the best way to define global constants, in particular Steven Lord's answer:

https://www.mathworks.com/matlabcentral/answers/480829-what-is-the-best-way-to-insure-that-all-of-my-functions-are-using-the-same-constant-values?s_tid=srchtitle

Basically create a class with properties and use that everywhere. The units of the properties are self documenting using this technique.

[Bruno Luong]

Interesting the instantless usage of OOP.

I imagine one cannot put any method inside.

[Orion Smedley]

In what way is it instantless? @Bruno Luong

[Bruno Luong]

The syntax

myclassname.constant1

refers to a class, there is no instance of this class involved, eg

myobj = myclass();
myobj.constant1

[Stephen23]

@Orion Smedley: search online for "OOP instance-less", you should get the idea.

[Bruno Luong]

@Stephen23 thank you for correction of spelling.

[Steven Lord]

You can have Static methods of a class that can be called without creating an instance of that class. In fact this class could even be Abstract if you want to ensure that users can't instantiate an instance of it.

classdef (Abstract) example1850048
    properties(Constant)
        mph2kphFactor = 1.60934; % Thanks Google
    end
    methods(Static)
        function kph = mph2kph(mph)
            % mph2kph Converts miles per hour to kilometers per hour
            kph = mph*example1850048.mph2kphFactor;
        end
    end
end

I can't run this here in Answers since we can't define classes in scripts, but if you copied that simple class into MATLAB and then ran this line of code you'd receive an answer that agrees pretty closely with Google.

y = example1850048.mph2kph(60)

Plus you could access the help text for either the method or the Constant property.

help example1850048.mph2kph
help example1850048.mph2kphFactor

Answer 2

[John D'Errico]

By far the simplest is to just stuff all of your variables into one struct. then pass it around to anything that will need it. This scheme is utterly simple, needing nothing more than one argument to be passed around.

You could do something more sophisticated of course. Create a function (I'll call it constantcache) that will store all of your constants inside, as persistent internally. Honestly, I'd use a struct inside there. Then if you need the value of myparam1, just call the function, telling it to return the desired parameter.

The usage mught look like this:

% first, initialize the cache of parameters. You might have a script
% somewhere that does this when you first start MATLAB.
datacache.E = 12; % Young's modulus
datacache.sigma = 5; % standard deviation
datacache.c = 300000; % speed of light in aluminum foil

% stuff the cache inside my function
constantcache(datacache)

% now we can use it anywhere, extracting ONLY the one parameter I might
% need at some point.
extractedparam = constantcache('sigma')

extractedparam = 5

% extract the entire cache as a struct
cache = constantcache('datacache')

cache = struct with fields:
        E: 12
    sigma: 5
        c: 300000

An of course, if I failed to provide some parameter, it tells me.

myparam1 = constantcache('myparam1');

Error using solution>constantcache
The sky is falling! parameter myparam1 was not provided in the cache

The code might be as simple as this:

function returnedvalue = constantcache(arg)
  persistent datacache
  if isstruct(arg)
    datacache = arg;
  elseif isstr(arg)
    if isequal(arg,'datacache')
      % return the entire cache, to inspect what is stored.
      returnedvalue = datacache;
    elseif ~isfield(datacache,arg);
      error("The sky is falling! parameter " + arg + " was not provided in the cache")
    else
      % return a specific parameter
      returnedvalue = getfield(datacache,arg);
    end
  end
end

As you can see, there is no need for globals. They just drop you into a special level of programming hell, that not even Dante knew about. If you need to change some constant, then just call constantcache again, passing in the struct again.

Answer 3

[Bruno Luong]

May be a little cumbersome but for serious application and when I'm not lazy, I define a subclass UniversalParameterClass of Singleton class.

classdef UniversalParameterClass < Singleton
   properties % Public Access
      PlankConstant;
      ...
   end
end

Then the first time where I instantiate such class I populate the correct values in the properties (Note: you can set SetAccess of immutable or such).

Inside the function where I need a parameter I would do

UniversalParameter = UniversalParameterClass.instance();
PlankConstant = UniversalParameter.PlankConstant;
etc...

You can also pass UniversalParameter as input argument of the subfunction, if you don't want to call

UniversalParameter = UniversalParameterClass.instance();

again and again inside the subfunction.

[Orion Smedley]

https://www.mathworks.com/help/systemcomposer/ref/systemcomposer.arch.architecture.instantiate.html

did you mean .instantiate()?

Or what does .instance() do?

[Bruno Luong]

instancet) is UniversalParameterClass method implemented similar to SingletonImpl of the FEX