Matlab: Konwersja podwójną tablicę wektor do macierzy komórkowej strun

Question

map1 = containers.Map({'212','2','12','44'},[4,5,6,7]); 
keyset = str2double(keys(map1)); 

Teraz robię zestaw operacji na Keyset który odda

Keyset= [203,2,12,39]; 

Próbowałam następujące:

num2cell(num2str(keyset)); 
num2cell(num2str(keyset,1)); 
num2cell(num2str(keyset,'%11.0g')); 
num2cell(num2str(keyset,3)); 

wszystkie powyższe dały dziwne wyniki w końcowej macierzy komórek. Potrzebuję tylko liczb całkowitych do użycia jako klucze do innej mapy kontenera.

Answer 1

I zaproponowanie 5 dodatkowych rozwiązań, z których trzy są 4-5x szybciej niż dotychczas proponowane rozwiązania. Wnioski wyciągnięte z tego są:

• num2str jest powolny
• cellfun i arrayfun można dodać poważnych trudności
• Istnieje wiele sposobów, aby przekonwertować tablicę numeryczną do macierzy komórkowej strun.

trzech roztworów najwyższej wydajności są bardzo podobne pod względem osiągów:

zapętlenie przypisanie elementów komórkowych

n4 = length(Keyset); 
tmp4 = cell(n4,1); 
for i4 = 1:n4 
    tmp4{i4} = sprintf('%i',Keyset(i4)); 
end 

konwersji wszystkich ciąg i wywołanie textscan

tmp6 = textscan(sprintf('%i\n',Keyset'),'%s'); 
tmp6 = tmp6{1}; 

Konwertowanie wszystkich na ciągi i wywoływanie regexp.

tmp3 = regexp(sprintf('%i ',Keyset),'(\d+)','match'); 

---

Oto pełny kod testu z synchronizacją:

function t = speedTest 

t=zeros(7,1); 
for ii=1:100, 
    Keyset=randi(1,10,100); % random keys 
    tic; 
    eval([ 'tmp1 = { ', sprintf(' %d ', Keyset), ' }; ']); 
    t(1)=t(1)+toc; 
    tic; 
    tmp2=arrayfun(@num2str, Keyset, 'Uniform', false); 
    t(2)=t(2)+toc; 

    tic; 
    tmp3 = regexp(sprintf('%i ',Keyset),'(\d+)','match'); 
    t(3) = t(3)+toc; 

    tic; 
    n4 = length(Keyset); 
    tmp4 = cell(n4,1); 
    for i4 = 1:n4 
     tmp4{i4} = sprintf('%i',Keyset(i4)); 
    end 
    t(4) = t(4)+toc; 

    tic; 
    n5 = length(Keyset); 
    tmp5 = cell(n5,1); 
    for i5 = 1:n5 
     tmp4{i5} = num2str(Keyset(i5)); 
    end 
    t(5) = t(5)+toc; 

    tic; 
    tmp6 = textscan(sprintf('%i\n',Keyset'),'%s'); 
    tmp6 = tmp6{1}; 
    t(6) = t(6)+toc; 

    tic; 
    tmp7 = num2cell(Keyset); 
    tmp7 = cellfun(@(x)sprintf('%i',x),tmp7,'uni',false); 
    t(7) = t(7)+toc; 


end; 
t 

t = 

    1.7820 
    21.7201 
    0.4068 
    0.3188 
    2.2695 
    0.3488 
    5.9186 

Answer 2

Jak o:

eval([ 'NewKeySetStr = { ', sprintf(' %d ', Keyset), ' }; ']); 
NewKeySetStr 

nie jestem pewien, że to jest najbardziej elegancki sposób, aby osiągnąć pożądane rezultaty, ale wydaje się działać ...

Porównując czas pracy za pomocą roztworu Eitan:

t=zeros(2,1); 
for ii=1:100, 
    Keyset=randi(1,10,100); % random keys 
    tic; 
    eval([ 'NewKeySetStr = { ', sprintf(' %d ', Keyset), ' }; ']); 
    t(1)=t(1)+toc; 
    tic; 
    tmp=arrayfun(@num2str, Keyset, 'Uniform', false); 
    t(2)=t(2)+toc; 
end; 
t 

Plony:

t = 
    0.3986 
    2.2527 

Wygląda na to, że proponowane rozwiązanie jest szybsze.

Uwaga: wygląda na to, że obecna implementacja cellfun nie jest zoptymalizowana pod kątem prędkości. Mówi się, że w przyszłych wersjach Mathworks zamierza wprowadzić lepszą implementację cellfun. Tak więc rozwiązanie Eitana może nie być optymalne w obecnej wersji, ale wydaje się, że jest to dobra praktyka umiejętności Matlaba.

Answer 3

Jak o:

arrayfun(@num2str, Keyset, 'Uniform', false)' 

który powinien dawać tablicy 4-1 przez komórki dla przykładu:

ans = 
    '203' 
    '2' 
    '12' 
    '39' 

Answer 4

zorientowali się, jak poprawić rozwiązanie dla dużych liczb całkowitych regexp, wykorzystując funkcję podziału. Również zostałem wprowadzony w błąd przez jedno z rozwiązań Jonasa, które nie oceniało wszystkich połączeń sprintf w pętli for. Edycja: dodano także nową funkcję sznurka 2016 sugerowaną w komentarzach.

t = speedTest() 

function t = speedTest 

t=zeros(5,1); 
for ii=1:100 
    Keyset=randi(10000000,10,1000); % random keys 

    tic; 
    n4 = numel(Keyset); % changed to numel (length only gives number of columns) 
    tmp1 = cell(n4,1); 
    for i4 = 1:n4 
     tmp1{i4} = sprintf('%i',Keyset(i4)); 
    end 
    t(1) = t(1)+toc; 

    tic; 
    tmp2 = regexp(sprintf('%i ',Keyset),'(\d+)','match'); 
    t(2) = t(2)+toc; 

    tic; 
    tmp3 = regexp(sprintf('%i ',Keyset),' ','split'); 
    tmp3(end) = []; 
    t(3) = t(3)+toc; 

    tic; 
    tmp4 = string(Keyset(:)); 
    t(4) = t(4)+toc; 

    # test in case you want to go back to characters 
    tic; 
    tmp5 = char(string(Keyset(:))); 
    t(5) = t(5)+toc; 
end 
end 

Rozwiązanie regexp z rentowności podzielone nieco lepszej wydajności i metody strun jest jeszcze szybsze:

t = 

    6.1916 
    1.1292 
    0.8962 
    0.6671 
    0.7523