MATLAB à la std :: वेक्टर :: आरक्षित (एन)

Question

में 0 -बहुत पहले उपयोगी है जब आपके आकार की आवश्यकताओं का कोई अंदाजा नहीं है। क्या किसी को MATLAB में एरे आवंटित करने के लिए एक समान विधि के बारे में पता है?

मैं वास्तव में निम्नलिखित की तरह hacky (लेकिन प्रभावी) तरीकों में कोई दिलचस्पी नहीं हूँ:

x = zeros(1000,1); 
for i = 1:10000 
    if i > numel(x) 
     x = [x;zeros(size(x))]; 
    end 
    x(i) = rand; 
end 
x(i+1:end) = []; 

Answer 1

"hacky" जिस तरह से यह करने के लिए एक ही रास्ता है। हालांकि, आपको < = numel (x) की जांच करने की आवश्यकता नहीं है। सरणी का विस्तार अपने रहेगी (लेकिन सरणी के बिना दोहरीकरण):

x = zeros(1000,1); 
for i = 1:10000 
    x(i) = rand; 
end 
x(i+1:end) = []; 

संपादित करें: करने के लिए यह सरल रखने, जबकि अभी भी बनाए रखना सरणी दोहरीकरण, आप एक वर्ग, या बस कुछ सहायक कार्यों (नीचे) लिख सकते हैं।

EDIT2: सहायक कार्यों का उपयोग मैन्युअल हैक की तुलना में चीजों को धीमा कर देगा। MATLAB 2010 में यह अभी भी निष्क्रिय विकास से बहुत तेज है। MATLAB 2011 में निष्पक्ष दृष्टिकोण वास्तव में तेज़ है, यह सुझाव देता है कि इस संस्करण में स्मार्ट आवंटन है। शायद यह काफी तेज़ है ताकि कोई भी हैक की आवश्यकता न हो। एंड्रयू जंक के लिए यह इंगित करने के लिए धन्यवाद।

function listtest() 
    n = 10000; 
    l = new_list(); 
    for i=1:n 
     l = list_append(l, i); 
    end 
    a = list_to_array(l); 
end 

function l = new_list() 
    l = [0 0]; 
end 
function l = list_append(l, e) 
    if l(1)+1 == length(l) 
     l(length(l)*2) = 0; 
    end 
    l(1) = l(1)+1; 
    l(l(1)+1) = e; 
end 
function a = list_to_array(l) 
    a = l(2:1+l(1)); 
end 

संपादित करें (AndrewJanke से)

यहाँ कार्यान्वयन की गति की तुलना कोड है।

function manual_reserve_example(n) 
x = zeros(1000,1); 
for i = 1:n 
    if i > numel(x) 
     x = [x;zeros(size(x))]; 
    end 
    x(i) = i; 
end 
x(i+1:end) = []; 
end 

function naive_growth(n) 
x = 0; 
for i = 1:n 
    x(i) = i; 
end 
end 

function compare_them(n) 
fprintf('Doing %d elements in Matlab R%s\n', n, version('-release')); 
tic; 
naive_growth(n); 
fprintf('%30s %.6f sec\n', 'naive_growth', toc); 
tic; 
manual_reserve_example(n); 
fprintf('%30s %.6f sec\n', 'manual_reserve', toc); 
tic; 
listtest(n); 
fprintf('%30s %.6f sec\n', 'listtest', toc); 
end 

Answer 2

MATLAB 7.6 (R2008a) में एक संरचना के लिए स्मृति preallocate को struct और REPMAT आदेशों का उपयोग कर एक तरीका नहीं है।

उदाहरण 1: एक उप क्षेत्र

s.field1.subfield के साथ एक क्षेत्र के साथ एक संरचना: दो क्षेत्रों

s.field1 s.field2

s = struct('field1',cell(1),'field2',cell(1)); 

उदाहरण 2 के साथ एक संरचना

s = struct('field1',struct('subfield',cell(1))); 

उदाहरण 3: संरचनाओं की एक सरणी

वी (1) .field1 ... वी (100) .field1

s = struct('field1',cell(1)); 
v = repmat(s,100,1); 

Answer 3

उदाहरण है कि आपके द्वारा प्रदान किए साफ समाधान पीछे की ओर को दोहराना।

for i = 10000:-1:1 
    x(i) = rand; 
end 

इस मामले हैं, जहां अंत आकार वास्तव में अज्ञात है में काम नहीं करता है, लेकिन यह मेरे लिए काम में अधिक बार की तुलना में मैं उम्मीद होता आ गया है।

---

अन्यथा मैं आमतौर पर मूल प्रश्न में दिखाए जाने वाले "ओवरफ्लो पर डबल" एल्गोरिदम लागू करता हूं।

स्वच्छ समाधान एक मैटलैब कक्षा को एक सम्मानित वेक्टर आकार बदलने वाले एल्गोरिदम के चारों ओर लपेटना है, और उसके बाद उस वर्ग का उपयोग करें। मुझे किसी भी कारण से अवगत नहीं है कि इस तरह के वर्ग का निर्माण नहीं किया जा सका, लेकिन मैंने वास्तव में कभी बैठे और एक को लागू करने की कोशिश नहीं की।(मुझे उत्सुकता है कि फ़ाइल एक्सचेंज पर कहीं भी एक उदाहरण मौजूद है।)