Thread Subject: Using functions and structures sensibly

Hi,

I have some code that works, but I want to check whether I'm doing
something horribly inefficient or unwise based upon how MATLAB deals with
function arguments.

Basically, I have a (reasonably) large structure, which has been preallocated
with all the correct fields.
I want to pass it to some functions (it isn't certain in advance which functions)
that will modify some fields of the structure.

A dramatically shortened version of the code might be:

% preallocate structure
S = struct( [field names and initial values] );
% apply functions
for ii = 1:numel(fh)
S = feval(fh{ii}, S);
end

where fh is a cell array containing the names of certain functions stored in M
files which begin something like,

function myStruct = myFunction(myStruct)

I read something that suggested modifying input arguments in MATLAB
functions is bad most of the time. I also wasn't sure about using the same
variable name for both the input and the output, but in my mind this seems
sensible for what I want to do.
Is it sensible, or will it result in unnecessary overhead? Would others here do
things the same way or differently?

Currently my code seems to work well and fast enough, but if it is bad
practice and there is a better way then I'd like to learn it. I'm using 2007b at
the moment, and the code is part of a gui created using GUIDE.

Thanks,

Pete

"Pete " <pete.dot.bankhead@btinternet.dot.com> writes:

> Hi,
>
> I have some code that works, but I want to check whether I'm doing
> something horribly inefficient or unwise based upon how MATLAB deals with
> function arguments.
>
> Basically, I have a (reasonably) large structure, which has been preallocated
> with all the correct fields.
> I want to pass it to some functions (it isn't certain in advance which functions)
> that will modify some fields of the structure.
>
> A dramatically shortened version of the code might be:
>
> % preallocate structure
> S = struct( [field names and initial values] );
> % apply functions
> for ii = 1:numel(fh)
> S = feval(fh{ii}, S);
> end
>
> where fh is a cell array containing the names of certain functions stored in M
> files which begin something like,
>
> function myStruct = myFunction(myStruct)
>
> I read something that suggested modifying input arguments in MATLAB
> functions is bad most of the time. I also wasn't sure about using the same
> variable name for both the input and the output, but in my mind this seems
> sensible for what I want to do.
> Is it sensible, or will it result in unnecessary overhead? Would others here do
> things the same way or differently?

Yes, that's sensible. For purposes of the copy-on-write behavior,
fields of structures (and elements of cell arrays) behave the same as
independent variables. That is, if you modify one field of S, only the
struct header (~100-200 bytes) and the modified field are copied.

-Peter

Excellent, that's good to know - thanks!

"Pete " <pete.dot.bankhead@btinternet.dot.com> wrote in
message <fvuu3s$bd$1@fred.mathworks.com>...
> Hi,
>
> I have some code that works, but I want to check whether
I'm doing
> something horribly inefficient or unwise based upon how
MATLAB deals with
> function arguments.
>
> Basically, I have a (reasonably) large structure, which
has been preallocated
> with all the correct fields.
> I want to pass it to some functions (it isn't certain in
advance which functions)
> that will modify some fields of the structure.
>
> A dramatically shortened version of the code might be:
>
> % preallocate structure
> S = struct( [field names and initial values] );
> % apply functions
> for ii = 1:numel(fh)
> S = feval(fh{ii}, S);
> end
>
> where fh is a cell array containing the names of certain
functions stored in M
> files which begin something like,
>
> function myStruct = myFunction(myStruct)
>
> I read something that suggested modifying input arguments
in MATLAB
> functions is bad most of the time.

The only reason why I know modifying inputs "is bad" is
that MATLAB will pass the inputs by value (instead of by
reference). But, one way or another, you are creating
another copy of myStruct anyway.

> I also wasn't sure about using the same
> variable name for both the input and the output, but in
my mind this seems
> sensible for what I want to do.

You could use something like:

function myStruct = myFunction(myInpStruct)
myStruct = myInpStruct;
...

and call it exactly the same way:

myStruct = myFunction(myStruct)

But, I don't know that this is any more efficient. (Might
make it easier to debug MyFunction.)

> Is it sensible, or will it result in unnecessary
overhead? Would others here do
> things the same way or differently?
>
> Currently my code seems to work well and fast enough, but
if it is bad
> practice and there is a better way then I'd like to learn
it. I'm using 2007b at
> the moment, and the code is part of a gui created using
GUIDE.
>
> Thanks,
>
> Pete

In article <fvv6bf$4gd$1@fred.mathworks.com>,
someone <someone@somewhere.net> wrote:

>The only reason why I know modifying inputs "is bad" is
>that MATLAB will pass the inputs by value (instead of by
>reference). But, one way or another, you are creating
>another copy of myStruct anyway.

I -gather- (perhaps incorrectly) from other postings that the
special case of having the same variable on input and output
of a function is handled by modifying the variable in-place
rather than creating a copy of the variable (other than
if the variable happens to share data with another variable.)
--
  "Man's life is but a jest,
   A dream, a shadow, bubble, air, a vapor at the best."
                                         -- George Walter Thornbury

In article <fvv8qq$1d8$1@canopus.cc.umanitoba.ca>, roberson@ibd.nrc-
cnrc.gc.ca says...
> In article <fvv6bf$4gd$1@fred.mathworks.com>,
> someone <someone@somewhere.net> wrote:
>
> >The only reason why I know modifying inputs "is bad" is
> >that MATLAB will pass the inputs by value (instead of by
> >reference). But, one way or another, you are creating
> >another copy of myStruct anyway.
>
> I -gather- (perhaps incorrectly) from other postings that the
> special case of having the same variable on input and output
> of a function is handled by modifying the variable in-place
> rather than creating a copy of the variable (other than
> if the variable happens to share data with another variable.)
>

Sometimes... depends on how it's called from the caller (same right and
left hand side name required) AND requires the calculation to be do-able
inplace.

--
Loren
http://blogs.mathworks.com/loren/