A command to catch the variable values from the workspace, inside a function

when I am doing a function in Matlab. Sometimes I have equations and every one of these have constants. Then, I have to declare these constants inside my function. I wonder if there is a way to call the values of that constants from outside of the function, if I have their values on the workspace.

I don't want to write this values as inputs of my开发者_运维百科 function in the function declaration.

In addition to the solutions provided by Iterator, which are all great, I think you have some other options.

First of all, I would like to warn you about global variables (as Iterator also did): these introduce hidden dependencies and make it much more cumbersome to reuse and debug your code. If your only concern is ease of use when calling the functions, I would suggest you pass along a struct containing those constants. That has the advantage that you can easily save those constants together. Unless you know what you're doing, do yourself a favor and stay away from global variables (and functions such as eval, evalin and assignin).

Next to global, evalin and passing structs, there is another mechanism for global state: preferences. These are to be used when it concerns a nearly immutable setting of your code. These are unfit for passing around actual raw data.

If all you want is a more or less clean syntax for calling a certain function, this can be achieved in a few different ways:

You could use a variable number of parameters. This is the best option when your constants have a default value. I will explain by means of an example, e.g. a regular sine wave y = A*sin(2*pi*t/T) (A is the amplitude, T the period). In MATLAB one would implement this as:

function y = sinewave(t,A,T)
y = A*sin(2*pi*t/T);

When calling this function, we need to provide all parameters. If we extend this function to something like the following, we can omit the A and T parameters:

function y = sinewave(t,A,T)
if nargin < 3
   T = 1; % default period is 1
   if nargin < 2
      A = 1; % default amplitude 1
   end
end
y = A*sin(2*pi*t/T);

This uses the construct nargin, if you want to know more, it is worthwhile to consult the MATLAB help for nargin, varargin, varargout and nargout. However, do note that you have to provide a value for A when you want to provide the value of T. There is a more convenient way to get even better behavior:

function y = sinewave(t,A,T)
if ~exists('T','var') || isempty(T)
   T = 1; % default period is 1
end
if ~exists('A','var') || isempty(A)
   A = 1; % default amplitude 1
end
y = A*sin(2*pi*t/T);

This has the benefits that it is more clear what is happening and you could omit A but still specify T (the same can be done for the previous example, but that gets complicated quite easily when you have a lot of parameters). You can do such things by calling sinewave(1:10,[],4) where A will retain it's default value. If an empty input should be valid, you should use another invalid input (e.g. NaN, inf or a negative value for a parameter that is known to be positive, ...).

Using the function above, all the following calls are equivalent:

t = rand(1,10);
y1 = sinewave(t,1,1);
y2 = sinewave(t,1);
y3 = sinewave(t);

If the parameters don't have default values, you could wrap the function into a function handle which fills in those parameters. This is something you might need to do when you are using some toolboxes that impose constraints onto the functions that are to be used. This is the case in the Optimization Toolbox.

I will consider the sinewave function again, but this time I use the first definition (i.e. without a variable number of parameters). Then you could work with a function handle:

f = @(x)(sinewave(x,1,1));

You can work with f as you would with an other function:

e.g. f(10) will evaluate sinewave(10,1,1).

That way you can write a general function (i.e. sinewave that is as general and simple as possible) but you create a function (handle) on the fly with the constants substituted. This allows you to work with that function, but also prevents global storage of data.

You can of course combine different solutions: e.g. create function handle to a function with a variable number of parameters that sets a certain global variable.

The easiest way to address this is via global variable: http://www.mathworks.com/help/techdoc/ref/global.html

You can also get the values in other workspaces, including the base or parent workspace, but this is ill-advised, as you do not necessarily know what wraps a given function.

If you want to go that route, take a look at the evalin function: http://www.mathworks.com/help/techdoc/ref/evalin.html

Still, the standard method is to pass all of the variables you need. You can put these into a struct, if you wish, and only pass the one struct.