MATLAB Language => vectorization

तत्व-वार संचालन

MATLAB वैक्टर और मैट्रिसेस पर वेक्टर किए गए कार्यों का समर्थन करता है (और प्रोत्साहित करता है)।
उदाहरण के लिए, मान लें कि हमारे पास A और B , दो n -by- m मैट्रिसेस हैं और हम चाहते हैं कि C तत्संबंधी तत्वों का तत्व-वार उत्पाद हो (यानी, C(i,j) = A(i,j)*B(i,j) )।

नेस्टेड छोरों का उपयोग करते हुए संयुक्त राष्ट्र का सदिश तरीका इस प्रकार है:

C = zeros(n,m);
for ii=1:n
    for jj=1:m
        C(ii,jj) = A(ii,jj)*B(ii,jj);
    end
end

हालांकि, ऐसा करने का सदिश तरीका तत्व-वार ऑपरेटर का उपयोग करके है .* :

C = A.*B;

MATLAB में तत्व-वार गुणा के बारे में अधिक जानकारी के लिए times के प्रलेखन देखें।
सरणी और मैट्रिक्स ऑपरेशन के बीच अंतर के बारे में अधिक जानकारी के लिए MATLAB प्रलेखन में ऐरे बनाम मैट्रिक्स ऑपरेशन देखें।

सम, माध्य, ठेस और सह

एक यादृच्छिक वेक्टर दिया

v = rand(10,1);

यदि आप इसके तत्वों का योग चाहते हैं, तो लूप का उपयोग न करें

s = 0;
for ii = 1:10
    s = s + v(ii);
end

लेकिन sum() फ़ंक्शन की सदिश क्षमता का उपयोग करें

s = sum(v);

sum() , mean() , prod() और अन्य जैसे कार्य, पंक्तियों, स्तंभों या अन्य आयामों के साथ सीधे संचालित करने की क्षमता रखते हैं।

उदाहरण के लिए, एक यादृच्छिक मैट्रिक्स दिया जाता है

A = rand(10,10);

प्रत्येक कॉलम के लिए औसत है

m = mean(A,1);

प्रत्येक पंक्ति के लिए औसत है

m = mean(A,2)

उपरोक्त सभी फ़ंक्शन केवल एक आयाम पर काम करते हैं, लेकिन क्या होगा यदि आप पूरे मैट्रिक्स को योग करना चाहते हैं? आप उपयोग कर सकते हैं:

s = sum(sum(A))

लेकिन क्या होगा अगर एक एनडी-सरणी है? आवेदन करने वाले sum पर sum पर sum ... सबसे अच्छा विकल्प की तरह लग नहीं है, बजाय का उपयोग : अपने सरणी vectorize करने के लिए ऑपरेटर:

s = sum(A(:))

और यह एक संख्या में परिणाम देगा जो आपके सभी सरणी का योग है, इससे कोई फर्क नहीं पड़ता कि इसके कितने आयाम हैं।

Bsxfun का उपयोग

अक्सर, यही कारण है कि कोड को लूप के for लिखा गया है, जिसका अर्थ है 'पास' वाले लोगों से मूल्यों की गणना करना। फंक्शन bsxfun को अक्सर अधिक bsxfun में ऐसा करने के लिए इस्तेमाल किया जा सकता है।

उदाहरण के लिए, मान लें कि आप मैट्रिक्स B पर एक कॉलमवाइज़ ऑपरेशन करना चाहते हैं, इसके प्रत्येक कॉलम का मतलब घटाकर:

B = round(randn(5)*10);                  % Generate random data 
A = zeros(size(B));                      % Preallocate array
for col = 1:size(B,2);                    % Loop over columns
    A(:,col) = B(:,col) - mean(B(:,col));   % Subtract means 
end

यह विधि अक्षम है यदि B बड़ा है, अक्सर MATLAB के कारण चर की सामग्री को स्मृति में चारों ओर ले जाना है। bsxfun का उपयोग bsxfun , कोई एक ही काम बड़े करीने से और आसानी से एक ही लाइन में कर सकता है:

A = bsxfun(@minus, B, mean(B));

यहां, @minus minus ऑपरेटर ( - ) के लिए एक फ़ंक्शन हैंडल है और इसे दो मैट्रिसेस B और mean(B) तत्वों के बीच लागू किया जाएगा। अन्य फ़ंक्शन हैंडल, यहां तक कि उपयोगकर्ता-परिभाषित वाले भी संभव हैं।

इसके बाद, मान लीजिए कि आप मैट्रिक्स A में प्रत्येक पंक्ति में पंक्ति वेक्टर v जोड़ना चाहते हैं:

v = [1,  2,  3];

A = [8,  1,  6
     3,  5,  7
     4,  9,  2];

भोली दृष्टिकोण एक लूप का उपयोग करें ( ऐसा न करें ):

B = zeros(3);
for row = 1:3
    B(row,:) = A(row,:) + v;
end

एक और विकल्प यह होगा कि v को repmat साथ दोहराया repmat ( ऐसा न करें ):

>> v = repmat(v,3,1)
v =
     1     2     3
     1     2     3
     1     2     3

>> B = A + v;

इस कार्य के लिए bsxfun उपयोग करें:

>> B = bsxfun(@plus, A, v);
B =
     9     3     9
     4     7    10
     5    11     5

वाक्य - विन्यास

bsxfun(@fun, A, B)

जहाँ @fun समर्थित कार्यों में से A और दो A और B नीचे दो स्थितियों का सम्मान करते हैं।

नाम bsxfun यह समझने में मदद करता है कि फ़ंक्शन कैसे काम करता है और यह S इंग्लटन ई एक्स विस्तार के साथ B inary FUN ction के लिए खड़ा है। दूसरे शब्दों में, यदि:

दो सरणियाँ एक को छोड़कर एक ही आयाम साझा करती हैं
और असंगत आयाम एक सिंगलटन (यानी की एक आकार है 1 ) दो सरणियों में से किसी में

फिर एकल सरणी के साथ सरणी को अन्य सरणी के आयाम से मिलान करने के लिए विस्तारित किया जाएगा। विस्तार के बाद, दो सरणियों पर एक द्विआधारी कार्य को तत्व के रूप में लागू किया जाता है।

उदाहरण के लिए, A एक M -by- N K सरणी है और B एक M -by- N सरणी है। सबसे पहले, उनके पहले दो आयामों के आकार समान हैं। दूसरे, A की K परतें हैं जबकि B का केवल 1 ही निहित है, इसलिए यह एक सिंगलटन है। सभी शर्तों को पूरा किया जाता है और B को A के तीसरे आयाम से मेल खाने के लिए दोहराया जाएगा।

अन्य भाषाओं में, इसे आमतौर पर प्रसारण के रूप में संदर्भित किया जाता है और स्वचालित रूप से अजगर (सुन्न) और ऑक्टेव में होता है।

फ़ंक्शन, @fun , एक बाइनरी फ़ंक्शन होना चाहिए जिसका अर्थ है कि इसे वास्तव में दो इनपुट लेना चाहिए।

टिप्पणियों

आंतरिक रूप से, bsxfun सरणी को दोहराता नहीं है और एक कुशल लूप निष्पादित करता है।

लॉजिकल मास्किंग

MATLAB लूप के उपयोग के बिना मैट्रिक्स पर चयन करने के लिए तार्किक स्टेटिंग के उपयोग का समर्थन करता है या यदि कथन है।

एक लॉजिकल मास्क को केवल 1 और 0 बना एक मैट्रिक्स के रूप में परिभाषित किया गया है।

उदाहरण के लिए:

mask = [1 0 0; 0 1 0; 0 0 1];

पहचान मैट्रिक्स का प्रतिनिधित्व करने वाला एक तार्किक मैट्रिक्स है।

हम मैट्रिक्स को क्वेरी करने के लिए एक विधेय का उपयोग करके एक तार्किक मुखौटा उत्पन्न कर सकते हैं।

A = [1 2 3; 4 5 6; 7 8 9];
B = A > 4;

हम पहले एक 3x3 मैट्रिक्स बनाते हैं, A , जिसमें नंबर 1 होता है 9. 9 के माध्यम से। हम फिर A को उन मानों के लिए क्वेरी करते हैं जो 4 से अधिक हैं और परिणाम को B नामक एक नए मैट्रिक्स में संग्रहीत करते हैं।

B फार्म का एक तार्किक मैट्रिक्स है:

B = [0 0 0
     0 1 1
     1 1 1]

या 1 जब विधेय A > 4 सत्य था। और 0 जब यह झूठा था।

हम मैट्रिक्स के तत्वों का उपयोग करने के लिए तार्किक मैट्रिक्स का उपयोग कर सकते हैं। यदि तत्वों का चयन करने के लिए एक तार्किक मैट्रिक्स का उपयोग किया जाता है, तो सूचक जहां तार्किक मैट्रिक्स में 1 दिखाई देते हैं, उस मैट्रिक्स में चुना जाएगा जिसे आप चुन रहे हैं।

ऊपर से उसी B का उपयोग करते हुए, हम निम्नलिखित कर सकते हैं:

C = [0 0 0; 0 0 0; 0 0 0];
C(B) = 5;

यह C के उन सभी तत्वों का चयन करेगा जहाँ B का सूचकांक में 1 है। C में वे सूचकांक तब 5 सेट होते हैं।

हमारा C अब जैसा दिखता है:

C = [0 0 0
     0 5 5
     5 5 5]

हम तार्किक मास्क का उपयोग करके if और उसके for जटिल कोड ब्लॉक कम कर सकते हैं।

गैर-वेक्टरकृत कोड लें:

A = [1 3 5; 7 9 11; 11 9 7];
for j = 1:length(A)
  if A(j) > 5
    A(j) = A(j) - 2;
  end
end

निम्न कोड के लिए तार्किक मास्किंग का उपयोग करके इसे छोटा किया जा सकता है:

A = [1 3 5; 7 9 11; 11 9 7];
B = A > 5;
A(B) = A(B) - 2;

या इससे भी कम:

A = [1 3 5; 7 9 11; 11 9 7];
A(A > 5) = A(A > 5) - 2;

विस्तृत सरणी विस्तार (प्रसारण) [R2016b]

MATLAB R2016b ने अपने स्केलर विस्तार ^{1 , 2} तंत्र के सामान्यीकरण को प्रदर्शित किया, ताकि विभिन्न आकारों के सरणियों के बीच कुछ तत्व-वार संचालन का समर्थन किया जा सके, जब तक कि उनका आयाम संगत न हो। निहित विस्तार का समर्थन करने वाले ऑपरेटर ^{1 हैं} :

तत्व-वार अंकगणित संचालक: + , - .* .^ , .^ , ./ , ./ .\ ।
संबंधित ऑपरेटर: < , <= , > , >= , == , ~= ।
तार्किक संचालक: & | , xor
बिट-वार कार्य: bitand , bitor , bitxor ।
प्राथमिक गणित कार्य: max , min , mod , rem , hypot , atan2 , atan2d ।

उपरोक्त बाइनरी संचालन को सरणियों के बीच अनुमति दी जाती है, जब तक कि उनके पास "संगत आकार" हो। आकार को "संगत" माना जाता है जब एक सरणी में प्रत्येक आयाम या तो दूसरे सरणी में समान आयाम के बराबर होता है, या 1 बराबर होता है। ध्यान दें कि अनुगामी सिंगलटन (आकार 1 ) आयाम MATLAB द्वारा छोड़े गए हैं, भले ही सैद्धांतिक रूप से उनमें से एक अनंत राशि है। दूसरे शब्दों में - आयाम जो एक सरणी में दिखाई देते हैं और दूसरे में नहीं दिखाई देते हैं, स्वचालित रूप से विस्तार के लिए फिट होते हैं।

उदाहरण के लिए, R2016b से पहले MATLAB संस्करणों में यह होगा:

>> magic(3) + (1:3)
Error using  + 
Matrix dimensions must agree.

R2016b से शुरू होने वाला पिछला ऑपरेशन सफल होगा:

>> magic(3) + (1:3)
ans =

     9     3     9
     4     7    10
     5    11     5

संगत आकारों के उदाहरण:

विवरण	1 ^सेंट ऐरे आकार	2 ^{एन डी} सरणी आकार	परिणाम का आकार
वेक्टर और स्केलर	`[3x1]`	`[1x1]`	`[3x1]`
पंक्ति और स्तंभ वेक्टर	`[1x3]`	`[2x1]`	`[2x3]`
वेक्टर और 2 डी मैट्रिक्स	`[1x3]`	`[5x3]`	`[5x3]`
एनडी और केडी सरणियों	`[1x3x3]`	`[5x3x1x4x2]`	`[5x3x3x4x2]`

असंगत आकारों के उदाहरण:

विवरण	1 ^सेंट ऐरे आकार	2 ^{एन डी} सरणी आकार	संभव समाधान
वेक्टर्स जहां एक आयाम दूसरे सरणी में एक ही आयाम का एक से अधिक है।	`[1x2]`	`[1x8]`	`transpose`
उन आयामों के साथ आता है जो एक दूसरे के गुणक हैं।	`[2x2]`	`[8x8]`	`repmat` , `reshape`
ND सरणियाँ जिनमें सिंगलटन आयामों की सही मात्रा है लेकिन वे गलत क्रम में हैं (# 1)।	`[2x3x4]`	`[2x4x3]`	`permute`
ND सरणियाँ जिनके पास एकलोन आयामों की सही मात्रा है, लेकिन वे गलत क्रम में हैं (# 2)।	`[2x3x4x5]`	`[5x2]`	`permute`

महत्वपूर्ण:
इस सम्मेलन पर निर्भर कोड MATLAB के किसी भी पुराने संस्करण के साथ पिछड़ा-संगत नहीं है । इसलिए, bsxfun ^{1 , 2} (जो समान प्रभाव को प्राप्त करता है) के स्पष्ट आह्वान का उपयोग किया जाना चाहिए, यदि कोड को पुराने MATLAB संस्करणों पर चलाने की आवश्यकता हो। यदि ऐसी चिंता मौजूद नहीं है, तो MATLAB R2016 के रिलीज नोट उपयोगकर्ताओं को bsxfun से स्विच करने के लिए प्रोत्साहित करते हैं:

bsxfun का उपयोग करने की तुलना में, अंतर्निहित विस्तार निष्पादन की तेज गति, बेहतर मेमोरी उपयोग और कोड की बेहतर पठनीयता प्रदान करता है।

दो या अधिक तर्कों के एक फ़ंक्शन का मान प्राप्त करें

कई एप्लिकेशन में दो या अधिक तर्कों के कार्य की गणना करना आवश्यक है।

परंपरागत रूप से, हम -loops का उपयोग for । उदाहरण के लिए, अगर हमें f = exp(-x^2-y^2) गणना करने की आवश्यकता है (यदि आपको तेज सिमुलेशन की आवश्यकता है तो इसका उपयोग न करें):

% code1
x = -1.2:0.2:1.4;
y = -2:0.25:3;
for nx=1:lenght(x)
   for ny=1:lenght(y)
      f(nx,ny) = exp(-x(nx)^2-y(ny)^2);
   end
end

लेकिन वेक्टरकृत संस्करण अधिक सुरुचिपूर्ण और तेज़ है:

% code2
[x,y] = ndgrid(-1.2:0.2:1.4, -2:0.25:3);
f = exp(-x.^2-y.^2);

हम इसकी कल्पना कर सकते हैं:

surf(x,y,f)

नोट 1 - ग्रिड: आमतौर पर, मैट्रिक्स स्टोरेज को पंक्ति-दर-पंक्ति व्यवस्थित किया जाता है। लेकिन MATLAB में, यह FORTRAN की तरह कॉलम-बाय-कॉलम स्टोरेज है। इस प्रकार, दो उपर्युक्त मॉडल को लागू करने के लिए MATLAB में दो ndgrid फ़ंक्शन ndgrid और meshgrid हैं। meshgrid के मामले में फ़ंक्शन की कल्पना करने के लिए, हम उपयोग कर सकते हैं:

surf(y,x,f)

टिप्पणी 2 - स्मृति की खपत: के Let आकार x या y 1000 इस प्रकार, हम स्टोर करने के लिए की जरूरत है 1000*1000+2*1000 ~ 1e6 गैर vectorized code1 के लिए तत्वों। लेकिन हमें 3*(1000*1000) = 3e6 के मामले में 3*(1000*1000) = 3e6 तत्वों की आवश्यकता है । 3D केस में ( z का आकार x या y ), मेमोरी की खपत नाटकीय रूप से बढ़ जाती है: वेक्टर कोड 2 बनाम ~1000*1000*1000 के मामले में 4*(1000*1000*1000) (डबल्स के लिए 32GB)। ~1000*1000*1000 code1 के मामले में (सिर्फ ~ 8GB)। इस प्रकार, हमें या तो मेमोरी या गति को चुनना होगा।

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

MATLAB Language
vectorization

खोज…