Расчет веса Хэмминга эффективно в matlab

Если это не упражнение по реализации MATLAB, вы можете просто взять свою быструю реализацию C++ и скомпилировать ее как функцию mex, один раз на целевую платформу.

EDIT: НОВОЕ РЕШЕНИЕ

похоже, что вы хотите повторить вычисление для каждого элемента в массиве 4096-by-4096 значений UINT32. Если это то, что вы делаете, я думаю, что самый быстрый способ сделать это в MATLAB-использовать тот факт, что BITGET предназначен для работы с матрицами значений. Код будет выглядеть так:

numArray = ...your 4096-by-4096 matrix of uint32 values...
w = zeros(4096,4096,'uint32');
for iBit = 1:32,
  w = w+bitget(numArray,iBit);
end

Если вы хотите сделать векторизованные версии некоторых других алгоритмов, я считаю BITAND также предназначен для работы с матрицами.

старое решение...

самый простой способ, который я могу придумать, - это использовать DEC2BIN функция, которая дает вам двоичное представление (в виде строки) неотрицательного целого числа:

w = sum(dec2bin(num) == '1');  % Sums up the ones in the string

это медленно, но это легко. =)

реализован "лучший 32-битный алгоритм" из ссылки Стэнфорда вверху. Улучшенный алгоритм сократил время обработки на 6%. Также оптимизирован размер сегмента и установлено, что 32K является стабильным и улучшает время на 15% по сравнению с 4K. Ожидайте, что время 4Kx4K будет 40% Векторизованного алгоритма Шайнера.

function w = Ham(w)
% Input uint32
% Output vector of Ham wts
 for i=1:32768:length(w)
  w(i:i+32767)=Ham_seg(w(i:i+32767));
 end
end

% Segmentation gave reduced time by 50%

function w=Ham_seg(w)
 %speed
 b1=uint32(1431655765); 
 b2=uint32(858993459);
 b3=uint32(252645135);
 b7=uint32(63); % working orig binary mask

 w = bitand(bitshift(w, -1), b1) + bitand(w, b1);
 w = bitand(bitshift(w, -2), b2) + bitand(w, b2);
 w =bitand(w+bitshift(w, -4),b3);
 w =bitand(bitshift(w,-24)+bitshift(w,-16)+bitshift(w,-8)+w,b7);

end

сделал некоторые сравнения времени на Matlab Cody. Определены сегментированный изменен Шайнер векторизация дает optimimum производительности.

имейте > уменьшение времени 50% основанное на изменении Коди 1.30 сек к 0.60 сек для вектора л=4096*4096.

function w = Ham(w)
% Input uint32
% Output vector of Ham wts

 b1=uint32(1431655765); % evaluating saves 15% of time 1.30 to 1.1 sec
 b2=uint32(858993459);
 b3=uint32(252645135);
 b4=uint32(16711935);
 b5=uint32(65535);

 for i=1:4096:length(w)
  w(i:i+4095)=Ham_seg(w(i:i+4095),b1,b2,b3,b4,b5);
 end
end

% Segmentation reduced time by 50%

function w=Ham_seg(w,b1,b2,b3,b4,b5)
 % Passing variables or could evaluate b1:b5 here


 w = bitand(bitshift(w, -1), b1) + bitand(w, b1);
 w = bitand(bitshift(w, -2), b2) + bitand(w, b2);
 w = bitand(bitshift(w, -4), b3) + bitand(w, b3);
 w = bitand(bitshift(w, -8), b4) + bitand(w, b4);
 w = bitand(bitshift(w, -16), b5) + bitand(w, b5);

end





vt=randi(2^32,[4096*4096,1])-1;
% for vt being uint32 the floor function gives unexpected values
tic
v=num_ones(mod(vt,65536)+1)+num_ones(floor(vt/65536)+1); % 0.85 sec
toc
% a corrected method is
v=num_ones(mod(vt,65536)+1)+num_ones(floor(double(vt)/65536)+1);
toc

быстрый подход-подсчет битов в каждом байте с помощью таблицы поиска, а затем суммирование этих значений; действительно, это один из подходов, предложенных на веб-странице, приведенной в вопросе. Хорошая вещь об этом подходе заключается в том, что и поиск, и сумма являются векторизуемыми операциями в MATLAB, поэтому вы можете векторизовать этот подход и вычислить вес / количество бит набора большого количества битовых строк одновременно, очень быстро. Этот подход реализуется в bitcount отправка на обмен файлами MATLAB.

попробуйте разделить работу на более мелкие части. Я предполагаю, что если вы хотите обрабатывать все данные сразу, matlab пытается выполнить каждую операцию со всеми целыми числами перед выполнением последовательных шагов, и кэш процессора недействителен с каждым шагом.

for i=1:4096,
    «process bits(i,:)»
end

Я возрождаю старую нить здесь, но я столкнулся с этой проблемой, и я написал для нее немного кода:

distance = sum(bitget(bits, 1:32));

выглядит довольно лаконично, но я боюсь, что bitget реализовано в O (n) bitshift операции. Код работает для того, что я собираюсь, но мой набор проблем не зависит от веса Хэмминга.

num_ones=uint8(zeros(intmax('uint32')/2^6,1));
% one time load of array not implemented here
tic
for i=1:4096*4096
 %v=num_ones(rem(i,64)+1)+num_ones(floor(i/64)+1); % 1.24 sec
 v=num_ones(mod(i,64)+1)+num_ones(floor(i/64)+1); % 1.20 sec
end
toc
tic
num_ones=uint8(zeros(65536,1));
for i=0:65535
 num_ones(i+1)=length( find( bitget( i, 1:32 ) ) ) ;
end
toc
% 0.43 sec to load
% smaller array to initialize
% one time load of array
tic
for i=1:4096*4096
 v=num_ones(mod(i,65536)+1)+num_ones(floor(i/65536)+1); %  0.95 sec
 %v=num_ones(mod(i,65536)+1)+num_ones(bitshift(i,-16)+1); % 16 sec for 4K*1K
end
toc
%vectorized
tic
num_ones=uint8(zeros(65536,1));
for i=0:65535
 num_ones(i+1)=length( find( bitget( i, 1:32 ) ) ) ;
end % 0.43 sec
toc
vt=randi(2^32,[4096*4096,1])-1;
tic
v=num_ones(mod(vt,65536)+1)+num_ones(floor(vt/65536)+1); % 0.85 sec
toc