That makes sense. I looked at the deal code and it confirmed what you said. However, it seems that the slowdown is in the lhs expansion of the cell array because I tried using the repmat version which is:

B = repmat({0}, 10000000, 1)

In the function
A = {0}

siz = [10000000, 1]
nelems = prod(double(siz))

B(nelems) = A
B(:) = A
these lines executed in no time.

But my point is is that B(nelems) = A
is allocating a large empty cell array and it does this quickly.

Even performing the line in deal for the scalar case

B = A(ones(nelems, 1));

is done fairly quickly.

Thanks for clearing it up Loren.

I am not surprised. In your first code, you are creating a cell array, turning it into a comma-separated list and listed 10000000 elements on the lhs of the equation. Finally, you are filling each cell (with the same number). The repmat version makes one 1×1 cell, the duplicates it into the large array once, without expanding and collapsing the cell array and its contents.

If you were filling the lhs with lots of different values, where repmat wouldn’t be appropriate, you might also find the speed improved versus the case where deal uses a single scalar input. But I am not positive of that and don’t have access to MATLAB to try it now.

Thanks.
–Loren

I find deal very slow for large cell arrays. For example,

[A{1:10000000}] = deal(0);

takes ages.

It is something specific to deal since

A = repmat({0}, 10000000, 1);

Executes pretty much instantaneously and produces a 10000000 element cell array with each element being the scalar 0. (i.e. the same output as the original deal call)

In #16 array x is da
>> da

da =

Stateflow.Data: 1-by-3

From which I want to extract info to create a struct array sfData. Now I’m thinking to avoid temp ‘name’.

I don’t know where you are talking about using a loop. It’s hard to tell what your final outcome is supposed to be. For now, I can’t tell if you can avoid the temporary variable, but is it really hurting anything?

–Loren

>> name = get(da,’Name’);
>> sfData = struct(‘Name’,cell(3,1));
>> [sfData(:).Name]=name{:};

There does not seem to be any particular advantage to using deal with your data structure.

–Loren

I have Stateflow.Data in a cell,
>> dparam

dparam =

[1x1 Stateflow.Data] [2x1 Stateflow.Data]

Then I create a structure array x by

>>clear x; x=dparam{1}; x(2:3)=dparam{2};
Now I can perform
>> get(x,’Name’)

ans =

‘gain’
‘gain’
‘gain1′

I also contacted support who explained this in a little more detail.

In reality, my data will not be shared in this way, so this becomes a non-issue. Once I created a cell array with no shared cells, I got the performance characteristics I was expecting.

Many thanks,

Tom

Your test case is almost a worst-case scenario in that you are assigning all the cell values to the same array. In the guts of MATLAB, these are all pointing to the same memory which slows the {:} operation down more than if the values were distinct. In either case however there is quadratic performance as you observe (and the development team is aware of this). Alas, I do not have a timeframe for changing this runtime characteristic.

The way to work around it is with a for loop, which should give linear speed with pre-allocation. Not as pretty, but hopefully should help you out for now.

–loren