You’re probably right. I’ll put it on the backburner!

If anyone would like this idea implemented, drop me a message (t.clarkremovespam@cantab.net) and I’ll give it a shot.

Tom

Perhaps easier to hide the bsxfun calls, but the need to convert and then operate doesn’t save the user steps. Interesting idea with interesting trade-offs.

My guess is that unless the arrays are large, you will pay a noticeable price (relatively) for the object.

–Loren

Sorry to resurrect an old blog - I just had a thought of a way to enhance readability for bsxfun.

What about creating a bsxfun type class? You could then overload all the operators (+ - etc) to use the ‘ugly’ call to bsxfun simply.

Let’s look at a simple example for which you could use bsxfun:

% Generates an error unless you use bsxfun, or repmat etc...
A = rand(10);
B = ones(10,1);
A = A - B;

But if we designated a class:

A = rand(10);
B = ones(10,1);
% Make a variable of type bsxclass.
% Values of B are kept in the private
% data of the class.
B_exp = bsxclass(B)
% B_exp is effectively an array which
% can be expanded along a singleton
% dimension
A = A - B_exp;

… so the class definition contains the horrible calls to bsxfun, and your code contains simple operator statements.

What does everyone think? Would such a class get used? Will there be a significant functional overhead caused by overloading the method / class invokation?

.. i.e. should I sit down and write it??!

Tom

We’ll put this idea on our list to consider for future enhancements.

–Loren

I would think that an arbitrary amount of expansion would be useful.

Something along the lines:

x = rand(10,1)
y = rand(1,10)
z = rand([1,1,5])

g = bsxfun(@betainc,x,y,z);

Thanks for listening.

Stephen

My interpretation literally comes from the behavior of repmat, which means [1 2 1 2] intead of [1 1 2 2]. But I agree that scalar expansion is an intuitive concept in linear algebra, but repmat is a MATLAB-specific concept. From the ease-of-use point of view, repmat-based interpretation may not be as clear as singleton expansion, especially for new users.

Jinhui

MATLAB has a traditional for scalar expansion, hence the behavior of bsxfun. If we did allow matches like you suggest, it could mean different things. Replicate the 2 rows in order multiple times, i.e., 1 2 1 2 1 2, OR it could be replicate each “the right number of times”, i.e., 1 1 2 2. It didn’t seem worth the confusion since we didn’t know which scenario was more likely of real interest.

–Loren

I have one question on the design of the function,though. Why is the function restricted to singleton expansion instead of more general integer-multiple expansion. What I mean can be illustrated more easily through an example.

% an example not work in current implementation
a = rand(4,6);
b = rand(2,6);
c = bsxfun(@plus,a,b); % does NOT work since it violates SINGLETON requirement
Conceptually bsxfun(@plus,a,b) can have a reasonable interpretation as “a + repmat(b,[2 1]);”, here 2 comes from size(a,1)/size(b,1). The well-defined nature here comes from mod(size(a,1),size(b,1)) == 0 so that mismatched dimension is an integer multiple of the other. Obviously singleton expansion is a special case of this.

If an extension of bsxfun implements this, it will eliminate the need for repmat for more cases, which seems to be in the spirit of design of bsxfun (although we need to find a different interpretation for letter “s” in bsxfun :-)).

From my experience of C MEX programming, the implementation of integer-multiple expansion should be similar to singleton expansion which, I guess, involves a different stride for pointers. Or am I missing something?

Jinhui

Nifty.

–DA

———-
A = rand(3,3);
match_dimensions = @(varargin) bsxfun(varargin{:});
B = match_dimensions(@minus, A, mean(A))
———-

Or, because we are dealing with binary operators, we can try to mimic the infix notation:

———-
match_dimensions = @(a,op,b) bsxfun(op,a,b);
B = match_dimensions(A, @minus, mean(A))
———-

Gautam