Thank you very much!

-Mykola

Logical indexing essentially deletes the zero elements and since there are not necessarily the same number left in each column, MATLAB returns the results in a single column vector. You should read more in the documentation about logical indexing. To get the result you want, you could instead try this:

R = magic(3);
k = logical([0 1 1 ; 1 1 1; 0 0 0]);
sum(R.*k)

–Loren

m = 2139;
n = 10000;
% a vector of sums
S_stamp = single(rand(m, 1)*10);
tic
for i = 1:10
    k = rand(m, n)>0.9;
    R = S_stamp(:, ones(1, n, 'int8'));
    A = zeros(m, n, 'single');
    % I take sums, that meet the k condition
    A(k) = R(k);
    clear R k
    % than I sum them
    S.(['SS' int2str(i)]) = sum(A);
    clear A
end
toc
% std([S.SS1 S.SS2 ..]

After I read your article I did so:
I inverted k condition

z = single(0);
tic
for i = 1:10
    k = rand(m, n)<0.9;
    R = S_stamp(:, ones(1, n, 'int8'));
    %I send zeros to the sums that now don't meet the initial k condition
    R(k) = z;
    clear k
    % than I sum the sums ans don't need to generate  A = zeros ... THANK you
    % very much!
    S.(['SS' int2str(i)]) = sum(R);
    clear R
end
toc

I got

Elapsed time is 23.300569 seconds.
Elapsed time is 22.413216 seconds.
It is a VERY good time improvement for my program! Thank you, Loren!

Please, Loren, can you help me ?
Than I decided to do so

for i = 1:10
    k = rand(m, n)>0.9;
    R = S_stamp(:, ones(1, n, 'int8'));
    S.(['SS' int2str(i)]) = sum(R(k));
    clear R
end

but …

R = magic(3);
k = logical([0 1 1 ; 1 1 1; 0 0 0]);
R(k)

ans =

3
1
5
6
7

It seemed to me that R looses it’t structure
if I

sum(R(k))

I don’t get what I am looking for

Thank you very much for any tip!
Mykola

There is not a way to change the default. But you can do things like:

x(1,400) = single(0);

and write code that is agnostic with respect to what kind of floating point, e.g.,

y = zeros(1,n,class(input1));

–Loren

% Compare sinc on a random vector
x = randn(1000000, 1);
y1 = sin(pi * x) ./ (pi * x); y1(x==0) = 1;
y2 = sin(pi .* x + eps) ./ (pi .* x + eps);

% Compare sinc on a zero vector
x = zeros(size(x));
y1 = sin(pi * x) ./ (pi * x); y1(x==0) = 1;
y2 = sin(pi .* x + eps) ./ (pi .* x + eps);

gives results within eps in the first case and identical results in the second. Using the profiler, we see execution times of 0.20/0.19 seconds for the random vector, and 0.42/0.05 seconds for the zero vector. Thus in both instances the ‘add eps’ version is faster. The results would also seem to bear out Peter’s comments above, that processing with NaNs is slow.

warning(‘off’, ‘MATLAB:divideByZero’);

x = round(rand(1,1e7)); % Roughly equal number of zeros and ones
y = x + 1; % No zeros

tic; s = 1./x; toc
tic; s = 1./y; toc

The timing results on my machine come out to 2.2s for the first case, with 1/2 zeros, while the second case only takes 0.34 seconds.

Of course, your point in this was that the number of input elements that are exactly zero is very small. When I change the proportion to 10000 zeros (1%), then it’s only 0.38 vs the 0.34.

Just something to consider for other optimizations when there are many zeros. The same thing will apply to processing with NaNs.