What is the best way to insure that all of my functions are using the same constant values?

I want to make sure that my functions are all using the same values for physical constants, like earth radius, elipsoidal flattening, etc. and avoid hard-coding a bunch of constant values in each function.

Some people advocate using a function that returns constant values, e.g.

Re = LibraryConstant('Earth_Radius');
f = LibraryConstant('Ellipsoid_flattening');
ev = LibraryConstant('electron_volt');
...

The function "LibraryConstant" is a big case-select structure that returns the requested value.

Or, you might define a bunch of global constants, but this seems like an undesirable approach.

What about creating a structure or table that contains all of the constants - this would have to be passed as an additinal argumernt to each function.

What would you recommend as an efficient method?

[Jim Riggs]

Two very good suggestions.

Thanks to @James Tursa and @Steven Lord

Answer 1

[Steven Lord]

You could define a class with Constant properties.

classdef myconstants
    properties(Constant)
        g = 9.8;
        g_units = 'm/s/s';
        c = 299792458;
        c_units = 'm/s';
    end
end

This is similar to James Tursa's struct based approach, but with one major difference: you don't need to call a function to create the struct in your workspace. You just reference the property with the name.

>> x = myconstants.c
x =
   299792458

You can even give your properties help text. [This is documented in the documentation for the help function.]

classdef myconstants
    properties(Constant)
        % g is the gravity of Earth
        % (https://en.wikipedia.org/wiki/Gravity_of_Earth)
        g = 9.8;
        g_units = 'm/s/s';
        % c is the speed of light in a vacuum
        c = 299792458;
        c_units = 'm/s';
    end
end

>> help myconstants.g

[Jim Riggs]

I have been testing this approach and it has some very nice features.

Just for fun, I created a UnitConversion.m class file and populated it with a number of unit conversion constants with detailed descriptions for each, e.g.;

% Class definition for unit conversion constants
%
% (... aditional description text)
%
classdef UnitConversion
    properties (Constant)
        % Length conversion: Nautical mile to feet
        %  X {ft} = Nmi2ft * X {Nmi}
        Nmi2ft = 1852/.3048;
        % Length conversion: feet to Nautical mile
        %  X {Nmi} = ft2Nmi * X {ft}
        ft2Nmi = 0.3048/1852
        % Angle conversion:  radians to degrees
        % X {deg} = rad2deg * X {rad}
        rad2deg = 180/pi;
        % Angle conversion:  degrees to radians
        % X {rad} = deg2rad * X {deg)
        deg2rad = pi/180;
%       ..... etc.
    end
end

What I discovered (and really like) is that the doc command (i.e. "doc UnitConversion") automatically creates a very nice reference page for the classdef. The reference page shows the descriptive text from the top of the classdef, and each property is shown in a concise list with the first line of its description, and automatically hyperlinked to it's individual full description. This documentation feature is very nice!

[Steven Lord]

If all your unit conversion factors have names of the form <unit1>2<unit2> you could even include a helper function to perform the conversion for you.

% Class definition for unit conversion constants
%
% (... aditional description text)
%
classdef UnitConversion
    properties (Constant)
        % Length conversion: Nautical mile to feet
        %  X {ft} = Nmi2ft * X {Nmi}
        Nmi2ft = 1852/.3048;
        % Length conversion: feet to Nautical mile
        %  X {Nmi} = ft2Nmi * X {ft}
        ft2Nmi = 0.3048/1852
        % Angle conversion:  radians to degrees
        % X {deg} = rad2deg * X {rad}
        rad2deg = 180/pi;
        % Angle conversion:  degrees to radians
        % X {rad} = deg2rad * X {deg)
        deg2rad = pi/180;
%       ..... etc.
    end
    
    methods(Static)
        function y = performConversion(value, originalUnit, newUnit)
            % y = performConversion(value, originalUnit, newUnit)
            %
            % Perform conversion of value in originalUnit units to newUnit
            % units.
            %
            % Example:
            % y = UnitConversion.performConversion(180, 'deg', 'rad')
            
            y = value * UnitConversion.(originalUnit + "2" + newUnit);
        end
    end
end

The name is a bit verbose, but it's self-documenting and can be tab completed. [Error checking left as an exercise for the reader.] Though depending on the release you're using, the deg2rad and rad2deg conversion factors may not be necessary as there are functions by those names in MATLAB now. They were moved from Mapping Toolbox to MATLAB in release R2015b, I believe.

[Jim Riggs]

This is a great tip! Thanks!

btw - the syntaxt you gave didnt work for me, but this did:

y = value * UnitConversion.([originalUnit '2' newunit]);

(I am running 2016b)

[Steven Lord]

Ah, I suspect you're using a release that predates the ability to define string arrays using double-quotes.

[Jim Riggs]

Ah yes. I have run into that issue before here in the forum.

[Jim Riggs]

In addition to the "doc" feature that I commented on above, I have just discovered that the auto complete function works seamlessly with the class. So, using my example of the UnitConversion class, if I type

UnitConversion.s <tab>

I get a drop-down menu of all class properties that begin with "s": {slug2lbm | slug2kg | slug2g | slug2grn } This also is a great feature of using classes.

Also, typing

UnitConversion. <tab>

will bring up a list of every property of the class. These features will be a big help in finding the value that I want.

Answer 2

[James Tursa]

I use a function that returns a structure, containing the values and the unit descriptions. Your code can either pass this structure around, or call the function. E.g.,

function e = earth
e.re = 6378.137; % equatorial radius
e.re_units = 'km';
e.we = 7.2921150e-5; % rotation rate
e.we_units = 'radians/sec';
e.flatinv = 298.257223563;
    :
end

I put the units as strings so that simply displaying the structure will show me what the units are.

[Orion Smedley]

Would this run through the entire earth function every time you calll say earth.re? Or would it just run until it got to earth.re and then quit?

(not an issue if the constants are just numbers like this, but this may be an issue if the constants have to be numerically calculated.)

[Jim Riggs]

You would invoke the function "earth", which would define the output structure with all of the fields. You would call this function once in your script, and then refer to the structure fields as needed.