MATLAB Language
सामान्य गलतियाँ और त्रुटियाँ

algorithm C Language C# Language C++ Java Language GNU/Linux opencv Python Language R Language Regular Expressions
खोज…


किसी मौजूदा फ़ंक्शन नाम के साथ एक चर का नाम न दें

पहले से ही एक फ़ंक्शन sum() । परिणामस्वरूप, यदि हम एक चर का नाम उसी नाम से रखते हैं 

sum = 1+3;

और यदि हम फ़ंक्शन का उपयोग करने का प्रयास करते हैं जबकि चर अभी भी कार्यक्षेत्र में मौजूद है 

A = rand(2);
sum(A,1)

हमें गुप्त त्रुटि मिलेगी: 

Subscript indices must either be real positive integers or logicals.

clear() पहले चर और फिर फ़ंक्शन का उपयोग करें 

clear sum

sum(A,1)
ans =
       1.0826       1.0279

यदि इस संघर्ष से बचने के लिए कोई फ़ंक्शन पहले से मौजूद है तो हम कैसे जांच सकते हैं?

का प्रयोग करें which() -all ध्वज के साथ: 

which sum -all
sum is a variable.
built-in (C:\Program Files\MATLAB\R2016a\toolbox\matlab\datafun\@double\sum)   % Shadowed double method
...

यह आउटपुट हमें बता रहा है कि sum एक चर है और इसके द्वारा निम्न तरीके (कार्य) को छायांकित किया जाता है, अर्थात MATLAB पहले विधि का उपयोग करने के बजाय, हमारे सिंटैक्स को चर पर लागू करने का प्रयास करेगा।

आप जो देखते हैं वह वह नहीं है जो आपको मिलता है: कमांड विंडो में char vs cellstring

यह नए उपयोगकर्ताओं के लिए एक मूल उदाहरण है। यह char और cellstring बीच अंतर को समझाने पर ध्यान केंद्रित नहीं करता है।

ऐसा हो सकता है कि आप अपने तार में ' से छुटकारा पाना चाहते हैं, हालांकि आपने उन्हें कभी नहीं जोड़ा। वास्तव में, वे कलाकृतियां हैं जिन्हें कमांड विंडो कुछ प्रकारों के बीच अंतर करने के लिए उपयोग करती है।

एक तार छपेगा 

s = 'dsadasd'
s =
dsadasd

एक सेलस्ट्रिंग प्रिंट होगा 

c = {'dsadasd'};
c = 
    'dsadasd'

ध्यान दें कि एकल उद्धरण और इंडेंटेशन कैसे कलाकृतियां हैं जो हमें सूचित करती हैं कि c एक cellstring बजाय एक char । स्ट्रिंग वास्तव में सेल में निहित है, अर्थात 

c{1}
ans =
dsadasd

संक्रमण ऑपरेटरों

  • .' MATLAB में एक वेक्टर या मैट्रिक्स को स्थानांतरित करने का सही तरीका है।
  • ' MATLAB में एक वेक्टर या मैट्रिक्स के जटिल संयुग्म संक्रमण (उर्फ हर्मिटियन संयुग्म) को लेने का सही तरीका है।

ध्यान दें कि संक्रमण के लिए .' , एपोस्ट्रोफ के सामने एक अवधि है। यह MATLAB में अन्य तत्व-वार संचालन के लिए सिंटैक्स को ध्यान में रखते हुए है: * मेट्रिसेस को गुणा करता है .* मेट्रिसेस के तत्वों को एक साथ गुणा करता है । दोनों कमांड बहुत समान हैं, लेकिन वैचारिक रूप से बहुत अलग हैं। अन्य MATLAB आदेशों की तरह, ये ऑपरेटर "सिंटैक्टिकल शुगर" हैं जो रनटाइम में "उचित" फ़ंक्शन कॉल में बदल जाता है। जैसा कि == eq फ़ंक्शन का मूल्यांकन बन जाता है, सोचें .' transpose लिए आशुलिपि के रूप में। यदि आप केवल ' लिखेंगे ' (बिंदु के बिना), तो आप वास्तव में ctranspose कमांड का उपयोग कर रहे हैं, जो कि जटिल संयुग्मन ctranspose गणना करता है , जिसे हर्मिटियन संयुग्म के रूप में भी जाना जाता है, जिसे अक्सर भौतिकी में उपयोग किया जाता है। जब तक प्रत्यारोपित वेक्टर या मैट्रिक्स वास्तविक-मूल्यवान है, तब तक दोनों ऑपरेटर एक ही परिणाम देते हैं। लेकिन जैसे ही हम जटिल संख्याओं से निपटते हैं, हम "सही" शॉर्टहैंड का उपयोग नहीं करने पर अनिवार्य रूप से समस्याओं में चले जाएंगे। "सही" क्या आपके आवेदन पर निर्भर करता है।

मैट्रिक्स C के निम्नलिखित उदाहरण पर विचार करें जिसमें जटिल संख्याएँ हैं: 

>> C = [1i, 2; 3*1i, 4]
C =
   0.0000 + 1.0000i   2.0000 + 0.0000i
   0.0000 + 3.0000i   4.0000 + 0.0000i

चलिए शार्टहैंड का इस्तेमाल करते हुए ट्रांज़ोज़ लेते हैं .' (अवधि के साथ)। आउटपुट अपेक्षित है, C का ट्रांसपोज़्ड रूप। 

>> C.'
ans =
   0.0000 + 1.0000i   0.0000 + 3.0000i
   2.0000 + 0.0000i   4.0000 + 0.0000i

अब, ' का उपयोग करें ' (अवधि के बिना)। हम देखते हैं, कि ट्रांसपोज़िशन के अलावा, कॉम्प्लेक्स वैल्यूज़ को उनके कॉम्प्लेक्स कंजुगेट्स में भी बदल दिया गया है। 

>> C'
ans =
   0.0000 - 1.0000i   0.0000 - 3.0000i
   2.0000 + 0.0000i   4.0000 + 0.0000i

संक्षेप में, यदि आप हर्मिटियन संयुग्म की गणना करने का इरादा रखते हैं, तो जटिल संयुग्म संक्रमण, फिर ' अवधि के बिना ' उपयोग करें। यदि आप मूल्यों के जटिल-संयुग्मन के बिना केवल ट्रांसपोज़ की गणना करना चाहते हैं, तो उपयोग करें .' (अवधि के साथ)।

प्रकार वाई के इनपुट तर्क के लिए अपरिभाषित समारोह या विधि एक्स

यह MATLAB का यह कहने का लंबा-चौड़ा तरीका है कि यह उस फ़ंक्शन को नहीं खोज सकता है जिसे आप कॉल करने का प्रयास कर रहे हैं। इस त्रुटि के कई कारण हो सकते हैं:

यह फ़ंक्शन MATLAB के आपके वर्तमान संस्करण के बाद पेश किया गया था

MATLAB ऑनलाइन प्रलेखन एक बहुत अच्छी सुविधा प्रदान करता है जो आपको यह निर्धारित करने की अनुमति देता है कि किसी दिए गए फ़ंक्शन को किस संस्करण में पेश किया गया था। यह प्रलेखन के हर पृष्ठ के नीचे बाईं ओर स्थित है:

यहाँ छवि विवरण दर्ज करें

यह निर्धारित करने के लिए कि क्या यह फ़ंक्शन आपके विशेष संस्करण में उपलब्ध है, अपने स्वयं के वर्तमान संस्करण ( ver ) के साथ इस संस्करण की तुलना करें। यदि यह नहीं है, तो अपने संस्करण में उपयुक्त विकल्प खोजने के लिए प्रलेखन के संग्रहीत संस्करणों को खोजने का प्रयास करें।

आपके पास वह टूलबॉक्स नहीं है!

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

यह देखने के लिए कि किसी दिए गए फ़ंक्शन का टूलबॉक्स किस प्रकार का है, यह देखने के लिए ऑनलाइन दस्तावेज़ीकरण के ऊपर बाईं ओर देखें कि क्या कोई विशिष्ट टूलबॉक्स उल्लेखित है।

यहाँ छवि विवरण दर्ज करें

फिर आप यह निर्धारित कर सकते हैं कि कौन सा टूलबॉक्स आपके वर्जन MATLAB के ver कमांड को जारी करके स्थापित किया गया है जो सभी इंस्टॉल किए गए बॉक्सबॉक्स की सूची को प्रिंट करेगा।

यदि आपके पास वह टूलबॉक्स स्थापित नहीं है और फ़ंक्शन का उपयोग करना चाहते हैं, तो आपको द मैथवर्क्स से उस विशेष टूलबॉक्स के लिए लाइसेंस खरीदना होगा।

MATLAB फ़ंक्शन का पता नहीं लगा सकता

अगर MATLAB अभी भी आपका फ़ंक्शन नहीं खोज सकता है, तो यह एक उपयोगकर्ता-परिभाषित फ़ंक्शन होना चाहिए। यह संभव है कि यह किसी अन्य निर्देशिका में रहता है और उस निर्देशिका को आपके कोड को चलाने के लिए खोज पथ में जोड़ा जाना चाहिए। आप जाँच सकते हैं कि क्या MATLAB आपके फ़ंक्शन का उपयोग करके पता लगा सकता है कि which स्रोत फ़ाइल को पथ वापस करना चाहिए।

फ्लोटिंग पॉइंट की अशुद्धि से अवगत रहें

फ़्लोटिंग-पॉइंट नंबर सभी वास्तविक संख्याओं का प्रतिनिधित्व नहीं कर सकते हैं। इसे फ्लोटिंग पॉइंट अशुद्धि के रूप में जाना जाता है।

वहाँ असीम कई अस्थायी अंक संख्या (जैसे हैं और वे असीम लंबी हो सकती है π ) इस प्रकार उन्हें पूरी तरह से प्रतिनिधित्व करने के लिए स्मृति की असीम राशि की आवश्यकता होगी सक्षम किया जा रहा,। यह एक समस्या थी, यह देखते हुए कि कंप्यूटर में "वास्तविक संख्या" भंडारण के लिए एक विशेष प्रतिनिधित्व डिजाइन किया गया था, IEEE 754 मानक । संक्षेप में, यह वर्णन करता है कि कैसे कंप्यूटर इस प्रकार की संख्याओं को स्टोर करते हैं, एक घातांक और मंटिसा के साथ, जैसे,

floatnum = sign * 2^exponent * mantissa

इनमें से प्रत्येक के लिए सीमित मात्रा के साथ, केवल एक परिमित परिशुद्धता प्राप्त की जा सकती है। छोटी संख्या, संभव संख्याओं (और इसके विपरीत!) के बीच का अंतर छोटा होता है। आप इस ऑनलाइन डेमो में अपने असली नंबरों को आजमा सकते हैं।

इस व्यवहार के बारे में जागरूक रहें और सभी फ्लोटिंग पॉइंट्स की तुलना और छोरों की स्थितियों को रोकने के रूप में उनके उपयोग से बचने की कोशिश करें। नीचे दो उदाहरण देखें:

उदाहरण: फ्लोटिंग पॉइंट तुलना की गई गलत: 

>> 0.1 + 0.1 + 0.1  == 0.3

ans =

  logical

   0

पूर्व उदाहरण द्वारा दिखाए गए अनुसार फ्लोटिंग पॉइंट तुलना का उपयोग करना खराब अभ्यास है। आप उनके अंतर का पूर्ण मूल्य लेकर और एक (छोटे) सहिष्णुता स्तर से तुलना करके इसे दूर कर सकते हैं।

नीचे एक और उदाहरण दिया गया है, जहां एक फ्लोटिंग पॉइंट नंबर का उपयोग लूप में एक रोक स्थिति के रूप में किया जाता है: ** 

k = 0.1;
while k <= 0.3 
  disp(num2str(k));
  k = k + 0.1;
end

% --- Output: ---
0.1
0.2

यह अंतिम अपेक्षित लूप ( 0.3 <= 0.3 ) को याद करता है।

उदाहरण: फ्लोटिंग पॉइंट तुलना की गई सही: 

x = 0.1 + 0.1 + 0.1;
y = 0.3;
tolerance = 1e-10; % A "good enough" tolerance for this case.

if ( abs( x - y ) <= tolerance )
  disp('x == y');
else
  disp('x ~= y');
end

% --- Output: ---
x == y

ध्यान देने योग्य कई बातें:

  • जैसा कि अपेक्षित था, अब x और y को समकक्ष माना जाता है।
  • ऊपर के उदाहरण में, सहिष्णुता का चुनाव मनमाने ढंग से किया गया था। इस प्रकार, चुना गया मान सभी मामलों के लिए उपयुक्त नहीं हो सकता है (विशेषकर जब बहुत कम संख्या के साथ काम करते हुए)। बाउंड को समझदारी से चुनना eps फंक्शन यानी N*eps(max(x,y)) का उपयोग करके किया जा सकता है, जहाँ N कुछ समस्या-विशिष्ट संख्या है। N लिए एक उचित विकल्प, जो पर्याप्त रूप से अनुमत है, 1E2 (हालांकि, उपरोक्त समस्या में N=1 भी पर्याप्त होगा)।

आगे की पढाई:

फ़्लोटिंग अशुद्धि के बारे में अधिक जानकारी के लिए ये प्रश्न देखें:

पर्याप्त इनपुट तर्क नहीं

अक्सर MATLAB डेवलपर्स शुरुआत में MATLAB के संपादक का उपयोग कोड लिखने और संपादित करने के लिए करेंगे, विशेष रूप से इनपुट और आउटपुट के साथ कस्टम कार्यों में। शीर्ष पर एक रन बटन है जो MATLAB के हाल के संस्करणों में उपलब्ध है:

यहाँ छवि विवरण दर्ज करें

एक बार जब डेवलपर कोड के साथ समाप्त हो जाता है, तो उन्हें अक्सर रन बटन पुश करने के लिए लुभाया जाता है। कुछ कार्यों के लिए यह ठीक काम करेगा, लेकिन दूसरों के लिए उन्हें एक Not enough input arguments त्रुटि प्राप्त होगी और त्रुटि क्यों होती है, इसके बारे में हैरान हो जाना चाहिए।

यह त्रुटि नहीं हो सकती है, इसका कारण यह है कि आपने MATLAB स्क्रिप्ट या एक फ़ंक्शन लिखा है जो बिना किसी इनपुट तर्क के लेता है। रन बटन का उपयोग एक परीक्षण स्क्रिप्ट चलाएगा या कोई इनपुट तर्क मानकर एक फ़ंक्शन चलाएगा। यदि आपके फ़ंक्शन को इनपुट तर्कों की आवश्यकता होती है, तो Not enough input arguments त्रुटि नहीं होगी क्योंकि आपने एक फ़ंक्शन लिखा है जो फ़ंक्शन के अंदर जाने के लिए इनपुट की अपेक्षा करता है। इसलिए, आप फ़ंक्शन को केवल रन बटन दबाकर चलाने की अपेक्षा नहीं कर सकते।

इस समस्या को प्रदर्शित करने के लिए, मान लें कि हमारे पास एक फ़ंक्शन mult जो बस दो मैट्रिसेस को एक साथ गुणा करता है: 

function C = mult(A, B)
    C = A * B;
end

MATLAB के हाल के संस्करणों में, यदि आप इस फ़ंक्शन को लिखते हैं और रन बटन को धक्का देते हैं, तो यह आपको वह त्रुटि देगा जिसकी हम अपेक्षा करते हैं: 

>> mult
Not enough input arguments.

Error in mult (line 2)
    C = A * B;

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

विधि # 1 - कमांड प्रॉम्प्ट के माध्यम से

केवल कमांड प्रॉम्प्ट में आपके द्वारा आवश्यक इनपुट बनाएं, फिर आपके द्वारा बनाए गए इनपुट का उपयोग करके फ़ंक्शन चलाएं: 

A = rand(5,5);
B = rand(5,5);
C = mult(A,B);

विधि # 2 - संपादक के माध्यम से इंटरएक्टिवली

रन बटन के नीचे एक गहरा काला तीर है। यदि आप उस तीर पर क्लिक करते हैं, तो आप वे चर निर्दिष्ट कर सकते हैं जिन्हें आप MATLAB कार्यक्षेत्र से प्राप्त करना चाहते हैं जिस तरह से आप फ़ंक्शन को कॉल करना चाहते हैं ठीक उसी तरह जैसे आपने विधि # 1 में देखा है। सुनिश्चित करें कि फ़ंक्शन के अंदर आप जिन चरों को निर्दिष्ट कर रहे हैं, वे MATLAB कार्यक्षेत्र में मौजूद हैं:

सरणी आकार परिवर्तनों के लिए देखें

MATLAB में कुछ सामान्य संचालन, जैसे भेदभाव या एकीकरण , आउटपुट परिणाम जिसमें इनपुट डेटा की तुलना में तत्वों की एक अलग मात्रा होती है। इस तथ्य को आसानी से अनदेखा किया जा सकता है, जो आमतौर पर त्रुटियों का कारण होगा जैसे कि Matrix dimensions must agree । निम्नलिखित उदाहरण पर विचार करें: 

t = 0:0.1:10;        % Declaring a time vector
y = sin(t);          % Declaring a function

dy_dt = diff(y);     % calculates dy/dt for y = sin(t)

मान लें कि हम इन परिणामों की साजिश करना चाहते हैं। हम सरणी आकारों पर एक नज़र डालते हैं और देखते हैं: 

size(y) is 1x101
size(t) is 1x101

परंतु: 

size(dy_dt) is 1x100

सरणी एक तत्व छोटा है!

अब कल्पना करें कि आपके पास समय के साथ पदों का माप डेटा है और जर्क (टी) की गणना करना चाहते हैं, आपको समय सारणी की तुलना में सरणी 3 तत्व कम मिलेंगे (क्योंकि झटका स्थिति 3 बार विभेदित है)। 

vel = diff(y);       % calculates velocity vel=dy/dt for y = sin(t)  size(vel)=1x100
acc = diff(vel);     % calculates acceleration acc=d(vel)/dt         size(acc)=1x99
jerk = diff(acc);    % calculates jerk jerk=d(acc)/dt                size(jerk)=1x98

और फिर संचालन जैसे: 

x = jerk .* t;          % multiplies jerk and t element wise

वापसी त्रुटियां, क्योंकि मैट्रिक्स आयाम सहमत नहीं हैं।

ऊपर जैसे ऑपरेशन की गणना करने के लिए आपको छोटे वाले को फिट करने के लिए बड़े सरणी आकार को समायोजित करना होगा। आप अपने डेटा के लिए एक बहुपद प्राप्त करने के लिए अपने डेटा के साथ एक प्रतिगमन ( polyfit ) भी चला सकते हैं।

डायमेंशन मिसमैच एरर्स

आयाम बेमेल त्रुटियाँ आमतौर पर तब दिखाई देती हैं:

  • फ़ंक्शन / विधि कॉल से लौटे चर के आकार पर ध्यान नहीं दे रहा है। कई इनबिल्ट MATLAB फ़ंक्शंस में, गणना की गति बढ़ाने के लिए मैट्रिस को वैक्टर में परिवर्तित किया जाता है, और लौटे हुए चर अभी भी मैट्रिक्स के बजाय एक वेक्टर हो सकते हैं जिसकी हमें उम्मीद थी। यह भी एक सामान्य परिदृश्य है जब तार्किक मास्किंग शामिल है।
  • अंतर्निहित सरणी विस्तार को लागू करते समय असंगत सरणी आकारों का उपयोग करना।

काल्पनिक इकाई के रूप में "i" या "j" का उपयोग, लूप इंडेक्स या सामान्य चर।

सिफ़ारिश करना

क्योंकि i और j के प्रतीक MATLAB में काफी भिन्न चीजों का प्रतिनिधित्व कर सकते हैं, लूप सूचकांकों के रूप में उनके उपयोग ने MATLAB उपयोगकर्ता समुदाय को युगों से विभाजित किया है। हालांकि कुछ ऐतिहासिक प्रदर्शन कारण संतुलन को एक तरफ करने में मदद कर सकते हैं, अब यह मामला नहीं है और अब चुनाव पूरी तरह से आप पर निर्भर करता है और कोडिंग प्रथाओं का पालन करने के लिए चुनते हैं।

Mathworks से वर्तमान आधिकारिक सिफारिशें हैं:

  • चूंकि i एक फ़ंक्शन है, इसलिए इसे ओवरराइड किया जा सकता है और एक चर के रूप में उपयोग किया जा सकता है। हालांकि, अगर आप उन्हें जटिल अंकगणित में उपयोग करने का इरादा रखते हैं तो चर नामों के लिए i और j उपयोग से बचना सबसे अच्छा है।
  • जटिल अंकगणित में गति और बेहतर मजबूती के लिए, i और j बजाय 1i और 1j उपयोग करें।

चूक

MATLAB में, डिफ़ॉल्ट रूप से, i और j अक्षर अंतर्निहित function नाम हैं, जो दोनों जटिल डोमेन में काल्पनिक इकाई को संदर्भित करते हैं।

तो डिफ़ॉल्ट रूप से i = j = sqrt(-1) । 

>> i
ans =
   0.0000 + 1.0000i
>> j
ans =
   0.0000 + 1.0000i

और जैसा कि आपको उम्मीद करनी चाहिए: 

>> i^2
ans =
    -1

उन्हें एक चर के रूप में उपयोग करना (लूप इंडेक्स या अन्य चर के लिए)

MATLAB एक मानक चर के रूप में अंतर्निहित फ़ंक्शन नाम का उपयोग करने की अनुमति देता है। इस स्थिति में उपयोग किया जाने वाला प्रतीक बिल्ट-इन फ़ंक्शन को इंगित नहीं करेगा, बल्कि आपके स्वयं के उपयोगकर्ता परिभाषित चर को। हालाँकि, यह अभ्यास आम तौर पर अनुशंसित नहीं होता है क्योंकि इससे भ्रम, कठिन डिबगिंग और रखरखाव हो सकता है ( अन्य उदाहरण do-not-name-a-variable-with-मौजूदा-फ़ंक्शन-नाम देखें )।

यदि आप सम्मेलनों और सर्वोत्तम प्रथाओं का सम्मान करने के बारे में अल्ट्रा पांडित्य हैं, तो आप उन्हें इस भाषा में लूप इंडेक्स के रूप में उपयोग करने से बचेंगे। हालांकि, यह संकलक द्वारा और पूरी तरह कार्यात्मक है, इसलिए आप पुरानी आदतों को रखने और उन्हें लूप पुनरावृत्तियों के रूप में उपयोग करने के लिए चुन सकते हैं। 

>> A = nan(2,3);
>> for i=1:2        % perfectly legal loop construction
       for j = 1:3
        A(i, j) = 10 * i + j;
       end
   end

ध्यान दें कि लूप इंडेक्स लूप के अंत में दायरे से बाहर नहीं जाते हैं, इसलिए वे अपना नया मूल्य रखते हैं। 

>> [ i ; j ]
ans =
     2
     3

मामले में आप उन्हें चर के रूप में उपयोग करते हैं, सुनिश्चित करें कि वे उपयोग किए जाने से पहले आरंभिक हैं। MATLAB के ऊपर लूप में उन्हें लूप तैयार करते समय स्वचालित रूप से प्रारंभ करें, लेकिन यदि ठीक से इनिशियलाइज़ नहीं किया गया है, तो आप जल्दी से देख सकते हैं कि आप अनजाने में अपने परिणाम में complex संख्याओं को जोड़ सकते हैं।

यदि बाद में, आपको अंतर्निहित फ़ंक्शन के छायांकन को पूर्ववत करने की आवश्यकता है (= जैसे आप काल्पनिक इकाई को फिर से प्रस्तुत करने के लिए i और j चाहते हैं), तो आप चर clear कर सकते हैं: 

>> clear i j

यदि आप उन्हें जटिल अंकगणित में उपयोग करने का इरादा रखते हैं, तो आप उन्हें लूप सूचक के रूप में उपयोग करने के बारे में मठ आरक्षण को समझते हैं। आपके कोड को वैरिएबल इनिशियलाइज़ेशन और clear कमांड्स के साथ रिड्यूल्ड किया जाएगा, जो सबसे गंभीर प्रोग्रामर को भ्रमित करने का सबसे अच्छा तरीका है ( हाँ आप वहां! ... ) और प्रोग्राम एक्सीडेंट होने की प्रतीक्षा कर रहे हैं।

यदि कोई जटिल अंकगणित अपेक्षित नहीं है, तो i और j का उपयोग पूरी तरह कार्यात्मक है और कोई प्रदर्शन दंड नहीं है।

उन्हें काल्पनिक इकाई के रूप में उपयोग करना:

यदि आपके कोड को complex संख्याओं से निपटना है, तो i और j निश्चित रूप से काम आएंगे। हालांकि, विघटन के लिए और यहां तक कि प्रदर्शन के लिए, शॉर्टहैंड सिंटैक्स के बजाय पूर्ण रूप का उपयोग करने की सिफारिश की जाती है। पूर्ण रूप 1i (या 1j ) है। 

>> [ i ; j ; 1i ; 1j]
ans =
   0.0000 + 1.0000i
   0.0000 + 1.0000i
   0.0000 + 1.0000i
   0.0000 + 1.0000i

वे समान मान sqrt(-1) प्रतिनिधित्व करते हैं, लेकिन बाद के रूप में:

  • अधिक स्पष्ट है, एक अर्थपूर्ण तरीके से।
  • अधिक सुपाच्य है (कोई व्यक्ति आपके कोड को देख रहा है बाद में यह जानने के लिए कोड को पढ़ना नहीं होगा कि क्या i या j एक चर या काल्पनिक इकाई था)।
  • तेज़ है (स्रोत: मैथवर्क्स)।

ध्यान दें कि पूर्ण सिंटैक्स 1i प्रतीक से पहले किसी भी संख्या के साथ मान्य है: 

>> a = 3 + 7.8j
a =
   3.0000 + 7.8000i

यह एकमात्र फ़ंक्शन है जिसे आप उनके बीच एक ऑपरेटर के बिना संख्या के साथ चिपका सकते हैं।

नुकसान

हालांकि काल्पनिक इकाई या चर के रूप में उनका उपयोग पूरी तरह से कानूनी है, यहां सिर्फ एक छोटा सा उदाहरण है कि दोनों को कैसे प्राप्त किया जा सकता है, यह कितना भ्रमित हो सकता है:

आइए ओवरराइड i और यह एक चर बनाने: 

>> i=3
i =
     3

अब i एक वैरिएबल है (मान 3 पकड़कर), लेकिन हम केवल काल्पनिक इकाई के शॉर्टहैंड अंकन से अधिक हैं, पूर्ण रूप की व्याख्या अभी भी सही ढंग से की गई है: 

>> 3i
ans =
   0.0000 + 3.0000i

जो अब हमें सबसे अस्पष्ट योगों का निर्माण करने देता है। मैं आपको निम्नलिखित सभी निर्माणों की पठनीयता का आकलन करने देता हूं: 

>> [ i ; 3i ; 3*i ; i+3i ; i+3*i ]
ans =
   3.0000 + 0.0000i
   0.0000 + 3.0000i
   9.0000 + 0.0000i
   3.0000 + 3.0000i
  12.0000 + 0.0000i

जैसा कि आप देख सकते हैं, उपरोक्त सरणी में प्रत्येक मान एक अलग परिणाम देता है। जबकि प्रत्येक परिणाम मान्य है (बशर्ते कि शुरुआती मंशा थी), आप में से अधिकांश यह स्वीकार करेंगे कि इस तरह के निर्माणों के साथ कोडित कोड को पढ़ना एक उचित दुःस्वप्न होगा।

बहुआयामी सरणियों के लिए `लंबाई` का उपयोग करना

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

वैक्टर के लिए, length के वापसी मूल्य के दो अलग-अलग अर्थ हैं:

  1. वेक्टर में तत्वों की कुल संख्या।
  2. वेक्टर का सबसे बड़ा आयाम।

वैक्टरों के विपरीत, उपरोक्त मान एक से अधिक नॉन-सिंगलटन (यानी जिसका आकार 1 से अधिक) के आयामों के बराबर नहीं होगा। यही कारण है कि मैट्रिस के लिए length का उपयोग अस्पष्ट है। इसके बजाय, निम्नलिखित में से किसी एक कार्य का उपयोग करने पर भी प्रोत्साहित किया जाता है, यहां तक कि वैक्टर के साथ काम करते समय, कोड का इरादा पूरी तरह से स्पष्ट करने के लिए:

  1. size(A) - एक पंक्ति वेक्टर देता है जिसके तत्वों में A के संगत आयाम के साथ तत्वों की मात्रा होती है।
  2. numel(A) - में तत्वों की संख्या देता है A । prod(size(A)) बराबर prod(size(A)) ।
  3. ndims(A) - सरणी A में आयामों की संख्या लौटाता है। संख्या के बराबर numel(size(A)) ।

"भविष्य-प्रूफ", वेक्टरकृत लाइब्रेरी फ़ंक्शंस लिखते समय यह विशेष रूप से महत्वपूर्ण है, जिनके इनपुट पहले से ज्ञात नहीं हैं, और विभिन्न आकार और आकार हो सकते हैं।



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow