On 28Mar2006, Bill Denney wrote:
 I have a function that I want to force to have a variable number of output
 arguements based on its calling function's number of output arguements.
 In other words, I want to do something like

 function [varargout] = fxn1(varargin)

 varargout{:} = fxn2(varargin{:});

 endfunction

 and I want fxn2 to see the same number of output arguements that fxn1
 sees.

 I thought of initializing varargout like

 varargout = cell(1, nargout);

 but that didn't work. Is there a way to do this?
I think what you want is
function varargout = fxn1 (varargin)
varargout = cell (nargout, 1);
[varargout{:}] = fxn2 (varargin{:});
endfunction
but this feature of Matlab is not yet implemented in Octave. The
reason it is not done yet is that decoding the LHS of the assignment
[varargout{:}] = fxn2 (varargin{:});
must be done before the function on the RHS is called so that nargin
may be set properly when the function is called, and doing that in the
general case is relatively complex and may require partial evaluation
of the expression inside the square brackets on the LHS. For example,
think about a case like
[foo(i,j(k),f(x,y,z)).bar{s:t}] = fxn2 (...);
the index expressions used here could be functions with side effects,
etc. To know precisely how many elements are in the commaseparated
list on the LHS, the expression must be evaluated. I'm not sure what
is reasonable in a complex case like this, or what Matlab does. Even
if function calls are not allowed inside an expression like this,
implementing this feature requires a significant change to the way
Octave works because Octave currently evaluates the LHS after the RHS
(all we do is count the number of expressions in the list inside the
square brackets on the LHS, and set nargout to that number).
Note that in Octave it is possible to write
function varargout = f1 (varargin)
varargout = cell (nargout, 1);
[varargout{:}] = f2 (varargin{:});
endfunction
function varargout = f2 (varargin)
nargin
nargout
varargout = varargin;
endfunction
and things appear to work for a call like
octave:8> [a,b,c] = f1 (1,2,3)
ans = 3
ans = 1
a = 1
b = 1
c = 1
except that nargout is wrong in the call to f2. It should be 3
instead of 1.
But maybe it would be relatively simple to correctly handle simple
cases like the one in your example above, and implementing that might
get 90% of the uses of this kind of feature.
BTW, even this feature does not allow you to eliminate all checks on
nargout because it will fail (in Matlab) if you call fxn1 with no
output values to assign, so you still need to handle that case:
function varargout = fxn1 (varargin)
if (nargout > 0)
varargout = cell (nargout, 1);
[varargout{:}] = fxn2 (varargin{:});
else
fxn2 (varargin{:});
endif
endfunction
But this seems like a missing feature/bug in Matlab. Why not simply
set nargout to 0 if varargout is empty in the expression
[varargout{:}]? Am I missing something here?
jwe

Octave is freely available under the terms of the GNU GPL.
Octave's home on the web:
http://www.octave.orgHow to fund new projects:
http://www.octave.org/funding.htmlSubscription information:
http://www.octave.org/archive.html