MATLAB LanguageMATLAB भाषा के साथ शुरुआत करना


संस्करण

संस्करण रिहाई रिलीज़ की तारीख
1.0 1984/01/01
2 1986/01/01
3 1987/01/01
3.5 1990/01/01
4 1992/01/01
4.2c 1994/01/01
5.0 मात्रा 8 1996/12/01
5.1 मात्रा ९ 1997/05/01
5.1.1 R9.1 1997/05/02
5.2 R10 1998/03/01
5.2.1 R10.1 1998/03/02
5.3 R11 1999/01/01
5.3.1 R11.1 1999/11/01
6.0 R12 2000/11/01
6.1 R12.1 2001/06/01
6.5 R13 2002/06/01
6.5.1 R13SP2 2003/01/01
6.5.2 R13SP2 2003/01/02
7 R14 2006/06/01
7.0.4 R14SP1 2004/10/01
7.1 R14SP3 2005/08/01
7.2 R2006a 2006/03/01
7.3 R2006b 2006/09/01
7.4 R2007a 2007-03-01
7.5 R2007b 2007-09-01
7.6 R2008a 2008/03/01
7.7 R2008b 2008-09-01
7.8 R2009a 2009-03-01
7.9 R2009b 2009-09-01
7.10 R2010a 2010-03-01
7.11 R2010b 2010-09-01
7.12 R2011a 2011-03-01
7.13 R2011b 2011-09-01
7.14 R2012a 2012-03-01
8.0 R2012b 2012-09-01
8.1 R2013a 2013-03-01
8.2 R2013b 2013-09-01
8.3 R2014a 2014-03-01
8.4 R2014b 2014-09-01
8.5 R2015a 2015-03-01
8.6 R2015b 2015/09/01
9.0 R2016a 2016/03/01
9.1 R2016b 2016/09/14
9.2 R2017a 2017/03/08

इसे भी देखें: MATLAB ने विकिपीडिया पर इतिहास जारी किया

अनाम फ़ंक्शन और फ़ंक्शन हैंडल

मूल बातें

बेनामी फ़ंक्शन MATLAB भाषा का एक शक्तिशाली उपकरण हैं। वे ऐसे कार्य हैं जो स्थानीय रूप से मौजूद हैं, वह है: वर्तमान कार्यक्षेत्र में। हालाँकि, वे MATLAB पथ पर मौजूद नहीं हैं जैसे कि एक नियमित फ़ंक्शन, उदाहरण के लिए m-file में। यही कारण है कि उन्हें गुमनाम कहा जाता है, हालांकि उनके पास कार्यक्षेत्र में एक चर की तरह एक नाम हो सकता है।

@ संचालक

अनाम फ़ंक्शंस और फ़ंक्शन हैंडल बनाने के लिए @ ऑपरेटर का उपयोग करें। उदाहरण के लिए, sin फ़ंक्शन (साइन) के लिए एक हैंडल बनाने के लिए और इसे f रूप में उपयोग करें:

>> f = @sin
f = 
    @sin
 

अब f sin कार्य के लिए एक संभाल है। ठीक वैसे ही (वास्तविक जीवन में) एक डोर हैंडल एक तरीका है एक डोर का उपयोग करना, एक फंक्शन हैंडल एक फंक्शन का उपयोग करने का एक तरीका है। f उपयोग करने के लिए, इस पर तर्क पारित किए जाते हैं जैसे कि यह sin कार्य था:

>> f(pi/2)
ans =
     1
 

f किसी भी इनपुट तर्कों को स्वीकार करता है जो sin फ़ंक्शन को स्वीकार करता है। यदि sin एक ऐसा कार्य होगा जो शून्य इनपुट तर्कों को स्वीकार करता है (जो ऐसा नहीं करता है, लेकिन अन्य करते हैं, उदाहरण के लिए peaks कार्य), f() का उपयोग इनपुट तर्कों के बिना इसे करने के लिए किया जाएगा।

कस्टम अनाम फ़ंक्शन

एक चर के अनाम कार्य

मौजूदा फ़ंक्शन के लिए हैंडल बनाने के लिए यह स्पष्ट रूप से उपयोगी नहीं है, जैसे कि ऊपर के उदाहरण में sin । यह उस उदाहरण में बेमानी है। हालांकि, यह उन अनाम कार्यों को बनाने के लिए उपयोगी है जो कस्टम चीजें करते हैं अन्यथा उन्हें कई बार दोहराया जाना चाहिए या इसके लिए एक अलग फ़ंक्शन बनाना होगा। एक कस्टम अनाम फ़ंक्शन के उदाहरण के रूप में जो एक चर को अपने इनपुट के रूप में स्वीकार करता है, एक संकेत के साइन और कोसाइन वर्ग को योग करता है:

>> f = @(x) sin(x)+cos(x).^2
f = 
    @(x)sin(x)+cos(x).^2
 

अब f x नामक एक इनपुट तर्क को स्वीकार करता है। यह सीधे @ ऑपरेटर के बाद कोष्ठक (...) का उपयोग करके निर्दिष्ट किया गया था। f अब x : f(x) का एक अनाम फ़ंक्शन है। इसका उपयोग x से f मान को पास करके किया जाता है:

>> f(pi)
ans =
    1.0000
 

मानों का एक सदिश या एक चर भी f को पास किया जा सकता है, जब तक कि वे f भीतर एक मान्य तरीके से उपयोग किए जाते हैं:

>> f(1:3) % pass a vector to f
ans =
    1.1334    1.0825    1.1212
>> n = 5:7;
>> f(n) % pass n to f
ans =
   -0.8785    0.6425    1.2254
 

एक से अधिक वेरिएबल के अनाम कार्य

एक ही फैशन में अनाम कार्यों को एक से अधिक वेरिएबल स्वीकार करने के लिए बनाया जा सकता है। एक अनाम फ़ंक्शन का एक उदाहरण जो तीन चर को स्वीकार करता है:

>> f = @(x,y,z) x.^2 + y.^2 - z.^2
f = 
    @(x,y,z)x.^2+y.^2-z.^2
>> f(2,3,4)
ans =
    -3
 

अनाम कार्यों को परिमाणित करना

कार्यक्षेत्र में चर का उपयोग अनाम कार्यों की परिभाषा के भीतर किया जा सकता है। इसे पैरामीटरिंग कहा जाता है। उदाहरण के लिए, एक अनाम फ़ंक्शन में निरंतर c = 2 का उपयोग करने के लिए:

>> c = 2;
>> f = @(x) c*x
f = 
    @(x)c*x
>> f(3)
ans =
     6
 

f(3) प्रदान किए गए x साथ गुणा करने के लिए एक पैरामीटर के रूप में चर c उपयोग किया। ध्यान दें कि यदि c का मान इस बिंदु पर कुछ अलग करने के लिए सेट है, तो f(3) कहा जाता है, परिणाम भिन्न नहीं होगा। c का मान अनाम फ़ंक्शन के निर्माण के समय का मूल्य है:

>> c = 2;
>> f = @(x) c*x;
>> f(3)
ans =
     6
>> c = 3;
>> f(3)
ans =
     6
 

एक अनाम फ़ंक्शन के इनपुट तर्क कार्यक्षेत्र चर का संदर्भ नहीं देते हैं

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

>> x = 3 % x in main workspace
x =
     3
>> f = @(x) x+1; % here x refers to a private x variable
>> f(5)
ans =
     6
>> x
x =
     3
 

मुख्य कार्यक्षेत्र से x का मान f भीतर उपयोग नहीं किया जाता है। इसके अलावा, मुख्य कार्यक्षेत्र में x को अछूता छोड़ दिया गया था। f के दायरे के भीतर, @ ऑपरेटर के बाद कोष्ठक के बीच चर नाम मुख्य कार्यक्षेत्र चर से स्वतंत्र हैं।

बेनामी कार्यों को चर में संग्रहीत किया जाता है

एक अनाम फ़ंक्शन (या, अधिक सटीक रूप से, एक अनाम फ़ंक्शन को इंगित करने वाले फ़ंक्शन हैंडल) को वर्तमान कार्यक्षेत्र में किसी भी अन्य मान की तरह संग्रहीत किया जाता है: एक सेल सरणी ( {@(x)x.^2,@(x)x+1} में एक चर (जैसा कि हमने ऊपर किया था) में, {@(x)x.^2,@(x)x+1} ), या यहां तक कि एक संपत्ति में भी (जैसे इंटरैक्टिव ग्राफिक्स के लिए h.ButtonDownFcn )। इसका मतलब यह है कि अनाम फ़ंक्शन को किसी अन्य मान की तरह माना जा सकता है। जब इसे एक चर में संग्रहित किया जाता है, तो इसका वर्तमान कार्यक्षेत्र में एक नाम होता है और इसे चर संख्याओं की तरह ही बदला और साफ़ किया जा सकता है।

अलग तरीके से डालें: एक फ़ंक्शन हैंडल (चाहे @sin फॉर्म में या किसी अनाम फ़ंक्शन के लिए) बस एक मूल्य है जिसे एक चर में संग्रहीत किया जा सकता है, जैसे एक संख्यात्मक मैट्रिक्स हो सकता है।

उन्नत उपयोग

फ़ंक्शन को पास करना अन्य कार्यों को संभालता है

चूंकि फ़ंक्शन हैंडल को चर की तरह व्यवहार किया जाता है, उन्हें फ़ंक्शन तर्कों के लिए इनपुट तर्कों के रूप में स्वीकार किया जा सकता है।

एक उदाहरण: एक फ़ंक्शन एक एम-फ़ाइल में बनाया गया है जो एक फ़ंक्शन हैंडल और एक स्केलर नंबर स्वीकार करता है। यह तब 3 को पास करके फ़ंक्शन हैंडल को कॉल करता है और फिर परिणाम में स्केलर नंबर जोड़ता है। परिणाम वापस आ जाता है।

funHandleDemo.m सामग्री:

function y = funHandleDemo(fun,x)
y = fun(3);
y = y + x;
 

MATLAB के वर्तमान फ़ोल्डर में, पथ पर कहीं इसे सहेजें। अब funHandleDemo का उपयोग निम्नानुसार किया जा सकता है, उदाहरण के लिए:

>> f = @(x) x^2; % an anonymous function
>> y = funHandleDemo(f,10) % pass f and a scalar to funHandleDemo
y =
    19
 

एक अन्य मौजूदा फ़ंक्शन का हैंडल funHandleDemo को दिया जा सकता है:

>> y = funHandleDemo(@sin,-5)
y =
   -4.8589
 

ध्यान दें कि कैसे @sin पहली बार sin फ़ंक्शन को एक्सेस करने का एक त्वरित तरीका था, इसे f = @sin का उपयोग करके एक चर में संग्रहित किए बिना।

अनाम फ़ंक्शंस के साथ bsxfun , cellfun और इसी तरह के कार्यों का उपयोग करना

MATLAB में कुछ अंतर्निहित कार्य हैं जो एक इनपुट के रूप में अनाम कार्यों को स्वीकार करते हैं। यह कोड की न्यूनतम संख्या के साथ कई गणना करने का एक तरीका है। उदाहरण के लिए bsxfun , जो एलिमेंट-बाय-एलिमेंट बाइनरी ऑपरेशन करता है, वह है: यह एलिमेंट-बाय-एलिमेंट फैशन में दो वैक्टर या मैट्रिसेस पर एक फंक्शन लागू करता है। आम तौर पर, इसके for -loops के उपयोग की आवश्यकता होती है, जिसे अक्सर गति के for प्रचार की आवश्यकता होती है। bsxfun का उपयोग bsxfun इस प्रक्रिया को पूरा किया जाता है। निम्न उदाहरण इसे tic और toc का उपयोग करके दिखाता है, दो फ़ंक्शन जिनका उपयोग समय के लिए किया जा सकता है कि कोड कितना समय लेता है। यह मैट्रिक्स कॉलम माध्य से हर मैट्रिक्स तत्व के अंतर की गणना करता है।

A = rand(50); % 50-by-50 matrix of random values between 0 and 1

% method 1: slow and lots of lines of code
tic
meanA = mean(A); % mean of every matrix column: a row vector
% pre-allocate result for speed, remove this for even worse performance
result = zeros(size(A));
for j = 1:size(A,1)
    result(j,:) = A(j,:) - meanA;
end
toc
clear result % make sure method 2 creates its own result

% method 2: fast and only one line of code
tic
result = bsxfun(@minus,A,mean(A));
toc
 

दो आउटपुट में परिणाम के ऊपर उदाहरण चल रहा है:

Elapsed time is 0.015153 seconds.
Elapsed time is 0.007884 seconds.
 

ये पंक्तियाँ toc फ़ंक्शन से आती हैं, जो अंतिम कॉल के बाद से tic फ़ंक्शन के लिए बीता हुआ समय प्रिंट करती हैं।

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

विशेष रूप से बड़े bsxfun में बड़ी मात्रा में डेटा के लिए, bsxfun चीजों को बहुत bsxfun कर सकता है। यह कोड लुक क्लीनर भी बनाता है, हालांकि यह उन लोगों के लिए व्याख्या करना अधिक कठिन हो सकता है जो MATLAB या bsxfun नहीं जानते हैं। (ध्यान दें कि MATLAB R2016a और बाद में, कई ऑपरेशन जो पहले bsxfun उपयोग bsxfun थे, अब उनकी आवश्यकता नहीं है; A-mean(A) सीधे काम करता है और कुछ मामलों में और भी तेज हो सकता है।)

सेल सरण

एक ही वर्ग के तत्वों को अक्सर सरणियों में समेटा जा सकता है (कुछ दुर्लभ अपवादों, जैसे फ़ंक्शन हैंडल)। न्यूमेरिकल स्कैलर्स, क्लास double डिफ़ॉल्ट रूप से, एक मैट्रिक्स में संग्रहित किया जा सकता है।

>> A = [1, -2, 3.14, 4/5, 5^6; pi, inf, 7/0, nan, log(0)]
A =
   1.0e+04 *
    0.0001   -0.0002    0.0003    0.0001    1.5625
    0.0003       Inf       Inf       NaN      -Inf
 

MATLAB में वर्ण, जो वर्ग char , को भी इसी तरह के वाक्य रचना का उपयोग करके सरणी में संग्रहीत किया जा सकता है। इस तरह की एक सरणी कई अन्य प्रोग्रामिंग भाषाओं में एक स्ट्रिंग के समान है।

>> s = ['MATLAB ','is ','fun']
s =
MATLAB is fun
 

ध्यान दें कि उन दोनों के बावजूद कोष्ठक [ और ] का उपयोग किया जा रहा है, परिणाम वर्ग अलग-अलग हैं। इसलिए उन पर किए जाने वाले ऑपरेशन भी अलग-अलग होते हैं।

>> whos
  Name      Size            Bytes  Class     Attributes

  A         2x5                80  double              
  s         1x13               26  char                
 

वास्तव में, सरणी s तार की एक सरणी नहीं है 'MATLAB ' , 'is ' , और 'fun' , यह सिर्फ एक स्ट्रिंग है - 13 वर्ण की एक सरणी। यदि आपको निम्नलिखित में से किसी एक द्वारा परिभाषित किया गया है तो आपको वही परिणाम प्राप्त होंगे:

>> s = ['MAT','LAB ','is f','u','n'];
>> s = ['M','A','T','L','A','B,' ','i','s',' ','f','u','n'];
 

एक नियमित MATLAB वेक्टर आपको विभिन्न वर्गों के चर, या कुछ अलग तारों के मिश्रण को स्टोर करने की अनुमति नहीं देता है। यह वह जगह है जहाँ cell सरणी काम में आती है। यह कोशिकाओं का एक समूह है जिसमें प्रत्येक में कुछ MATLAB वस्तु हो सकती है, जिनकी कक्षा जरूरत पड़ने पर हर कोशिका में भिन्न हो सकती है। सेल सरणी में स्टोर करने के लिए तत्वों के चारों ओर घुंघराले ब्रेसिज़ { और } उपयोग करें।

>> C = {A; s}
C = 
    [2x5 double]
    'MATLAB is fun'
>> whos C
  Name      Size            Bytes  Class    Attributes

  C         2x1               330  cell 
 

किसी भी वर्ग की मानक MATLAB वस्तुओं को एक सेल सरणी में एक साथ संग्रहीत किया जा सकता है। ध्यान दें कि सेल सरणियों को अपनी सामग्री को संग्रहीत करने के लिए अधिक मेमोरी की आवश्यकता होती है।

एक सेल की सामग्री तक पहुँच घुंघराले ब्रेसिज़ { और } का उपयोग करके किया जाता है।

>> C{1}
ans =
   1.0e+04 *
    0.0001   -0.0002    0.0003    0.0001    1.5625
    0.0003       Inf       Inf       NaN      -Inf
 

ध्यान दें कि C(1) C{1} से अलग है। जबकि बाद वाला सेल की सामग्री को वापस करता है (और उदाहरण में क्लास double है), पूर्व एक सेल सरणी देता है जो सी का एक उप-सरणी C । इसी तरह, यदि D 10 बाय 5 सेल ऐरे हैं, तो D(4:8,1:3) D का एक सब-ऐरे लौटाएगा, जिसका आकार 5 बाय 3 है और जिसका क्लास cell । और सिंटैक्स C{1:2} में एक भी लौटी हुई वस्तु नहीं है, लेकिन रोटर में 2 अलग-अलग ऑब्जेक्ट्स (कई रिटर्न मानों के साथ MATLAB फ़ंक्शन के समान):

>> [x,y] = C{1:2}
x =
                         1                        -2                      3.14                       0.8                     15625
          3.14159265358979                       Inf                       Inf                       NaN                      -Inf
y =
MATLAB is fun
 

जानकारी का प्रकार

MATLAB में 16 मूलभूत डेटा प्रकार या कक्षाएं हैं। इनमें से प्रत्येक वर्ग एक मैट्रिक्स या सरणी के रूप में है। फ़ंक्शन हैंडल के अपवाद के साथ, यह मैट्रिक्स या सरणी न्यूनतम आकार में 0-बाय -0 है और किसी भी आकार के एन-आयामी सरणी तक बढ़ सकता है। एक फ़ंक्शन हैंडल हमेशा स्केलर (1-बाय -1) होता है।

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

उदाहरण:

a = 123;
b = [1 2 3];
c = '123';

>> whos
  Name      Size            Bytes  Class     Attributes

  a         1x1                 8  double              
  b         1x3                24  double              
  c         1x3                 6  char    
 

यदि चर पहले से मौजूद है, तो MATLAB मूल डेटा को नए के साथ बदल देता है और यदि आवश्यक हो तो नए संग्रहण स्थान आवंटित करता है।

मौलिक डेटा प्रकार

मौलिक डेटा प्रकार हैं: सांख्यिक, logical , char , cell , struct , table और function_handle

संख्यात्मक डेटा प्रकार :

  • फ़्लोटिंग-पॉइंट नंबर ( डिफ़ॉल्ट )

    MATLAB डबल-सटीक या एकल-सटीक प्रारूप में फ़्लोटिंग पॉइंट संख्याओं का प्रतिनिधित्व करता है। डिफ़ॉल्ट दोहरी परिशुद्धता है, लेकिन आप साधारण रूपांतरण फ़ंक्शन के साथ किसी भी संख्या में एकल परिशुद्धता बना सकते हैं:

    a = 1.23;
    b = single(a);
    
    >> whos
      Name      Size            Bytes  Class     Attributes
    
      a         1x1                 8  double              
      b         1x1                 4  single     
     
  • पूर्णांकों

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

    MATLAB पूर्णांक डेटा के लिए 1-, 2-, 4- और 8-बाइट संग्रहण का समर्थन करता है। यदि आप अपने डेटा को समायोजित करने वाले सबसे छोटे पूर्णांक प्रकार का उपयोग करते हैं, तो आप अपने कार्यक्रमों के लिए मेमोरी और निष्पादन समय बचा सकते हैं। उदाहरण के लिए, मान 100 को संग्रहीत करने के लिए आपको 32-बिट पूर्णांक की आवश्यकता नहीं है।

    a = int32(100);
    b = int8(100);
    
    >> whos
      Name      Size            Bytes  Class    Attributes
    
      a         1x1                 4  int32              
      b         1x1                 1  int8               
     

    डेटा को पूर्णांक के रूप में संग्रहित करने के लिए, आपको डबल से वांछित पूर्णांक प्रकार में बदलने की आवश्यकता है। यदि पूर्णांक में परिवर्तित की जा रही संख्या में एक आंशिक भाग है, तो MATLAB निकटतम पूर्णांक तक चक्कर लगाता है। यदि भिन्नात्मक भाग ठीक 0.5 , तो दो समान रूप से पास के पूर्णांक से, MATLAB वह चुनता है जिसके लिए परिमाण में पूर्ण मान बड़ा है।

    a  = int16(456);
     
  • char

    चरित्र सरणियाँ MATLAB में पाठ डेटा के लिए भंडारण प्रदान करती हैं। पारंपरिक प्रोग्रामिंग शब्दावली को ध्यान में रखते हुए, वर्णों की एक सरणी (अनुक्रम) को एक स्ट्रिंग के रूप में परिभाषित किया गया है। MATLAB के खुदरा रिलीज में कोई स्पष्ट स्ट्रिंग प्रकार नहीं है।

  • तार्किक: 1 या 0 के तार्किक मान, क्रमशः सही और गलत का प्रतिनिधित्व करते हैं। संबंधपरक स्थितियों और सरणी अनुक्रमण के लिए उपयोग करें। क्योंकि यह सिर्फ TRUE या FALSE है इसलिए इसका आकार 1 बाइट है।

    a = logical(1);
     
  • संरचना। एक संरचना सरणी कि विभिन्न डेटा प्रकार के समूहों चर क्षेत्रों बुलाया डेटा कंटेनरों का इस्तेमाल एक डेटा प्रकार है। प्रत्येक क्षेत्र में किसी भी प्रकार का डेटा हो सकता है। किसी संरचना के डॉट संकेतन का उपयोग करके संरचना में डेटा का उपयोग करें ।Name.fieldName।

    field1 = 'first';
    field2 = 'second';
    value1 = [1 2 3 4 5];
    value2 = 'sometext';
    s = struct(field1,value1,field2,value2);
     

    मान 1 तक पहुँचने के लिए, निम्नलिखित में से प्रत्येक वाक्यविन्यास समतुल्य है

    s.first or s.(field1) or s.('first')
     

    हम स्पष्ट रूप से एक क्षेत्र का उपयोग कर सकते हैं जिसे हम जानते हैं कि पहली विधि के साथ मौजूद होगी, या तो दूसरे उदाहरण में फ़ील्ड तक पहुंचने के लिए एक स्ट्रिंग या एक स्ट्रिंग बनाएं। तीसरा उदाहरण डेमोस्ट्रेट कर रहा है कि डॉट पेरेंटेस नोटेशन एक स्ट्रिंग लेता है, जो कि फ़ील्ड 1 चर में संग्रहीत एक ही है।

  • तालिका चर विभिन्न आकारों और डेटा प्रकारों के हो सकते हैं, लेकिन सभी चर में समान पंक्तियों की संख्या होनी चाहिए।

    Age = [15 25 54]';
    Height = [176 190 165]';
    Name = {'Mike', 'Pete', 'Steeve'}';
    T = table(Name,Age, Height);
     
  • सेल। यह बहुत उपयोगी MATLAB डेटा प्रकार है: सेल सरणी एक ऐसा सरणी है जिसका प्रत्येक तत्व विभिन्न डेटा प्रकार और आकार का हो सकता है। यह आपकी इच्छानुसार डेटा में हेरफेर करने के लिए बहुत मजबूत साधन है।

    a = { [1 2 3], 56, 'art'};
     

    या

    a = cell(3);
     
  • फंक्शन हैंडल्स एक पॉइंटर को एक फंक्शन में स्टोर करता है (उदाहरण के लिए, अनाम फ़ंक्शन के लिए)। यह आपको किसी फ़ंक्शन को किसी अन्य फ़ंक्शन को पास करने या मुख्य फ़ंक्शन के बाहर से स्थानीय फ़ंक्शन को कॉल करने की अनुमति देता है।

प्रत्येक डेटा प्रकार के साथ काम करने के लिए बहुत सारे साधन हैं और अंतर्निहित डेटा प्रकार रूपांतरण फ़ंक्शन ( str2double , table2cell ) भी हैं।

अतिरिक्त डेटा प्रकार

कई अतिरिक्त डेटा प्रकार हैं जो कुछ विशिष्ट मामलों में उपयोगी हैं। वो हैं:

  • दिनांक और समय: दिनांक, समय और अवधि का प्रतिनिधित्व करने के लिए सरणियाँ। datetime('now') 21-Jul-2016 16:30:16 रिटर्न करता है।

  • श्रेणीबद्ध सरणियाँ: यह असतत श्रेणियों के एक सेट से मूल्यों के साथ डेटा संग्रहीत करने के लिए डेटा प्रकार है। Nonnumeric डेटा (स्मृति प्रभावी) के भंडारण के लिए उपयोगी। पंक्तियों के समूहों का चयन करने के लिए एक तालिका में उपयोग किया जा सकता है।

    a = categorical({'a' 'b' 'c'});
     
  • मैप कंटेनर एक डेटा संरचना है जिसमें न केवल किसी स्केलर संख्यात्मक मानों बल्कि चरित्र वेक्टर के माध्यम से अनुक्रमण करने की अद्वितीय क्षमता है। किसी मानचित्र के तत्वों में संकेतक को कुंजी कहा जाता है। ये कुंजी, उनके साथ जुड़े डेटा मूल्यों के साथ, मानचित्र के भीतर संग्रहीत की जाती हैं।

  • टाइम सीरीज़ , समय के साथ, नियमित अंतराल पर, अक्सर डेटा वैक्टर होते हैं। यह टाइमस्टेप्स से जुड़े डेटा को स्टोर करने के लिए उपयोगी है और इसके साथ काम करने के लिए बहुत सारे उपयोगी तरीके हैं।

नमस्ते दुनिया

MATLAB संपादक में एक नया रिक्त दस्तावेज़ खोलें (MATLAB के हाल के संस्करणों में, टूलस्ट्रिप के होम टैब का चयन करके और नई स्क्रिप्ट पर क्लिक करके ऐसा करें)। एक नई स्क्रिप्ट बनाने के लिए डिफ़ॉल्ट कीबोर्ड शॉर्टकट Ctrl-n

वैकल्पिक रूप से, edit myscriptname.m को टाइप edit myscriptname.m संपादन के लिए फ़ाइल myscriptname.m खुल जाएगी, या MATLAB पथ पर मौजूद नहीं होने पर फ़ाइल बनाने की पेशकश की जाएगी।

संपादक में, निम्न टाइप करें:

disp('Hello, World!');
 

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

MATLAB कमांड विंडो में, निम्न टाइप करें:

>> helloworld
 

आपको MATLAB कमांड विंडो में निम्नलिखित प्रतिक्रिया देखनी चाहिए:

Hello, World!
 

हम देखते हैं कि कमांड विंडो में, हम फ़ंक्शन या स्क्रिप्ट फ़ाइलों के नाम टाइप करने में सक्षम हैं जो हमने लिखे हैं, या जिन्हें चलाने के लिए MATLAB के साथ भेज दिया गया है।

यहाँ, हमने 'helloworld' स्क्रिप्ट को चलाया है। ध्यान दें कि एक्सटेंशन ( .m ) टाइप करना अनावश्यक है। स्क्रिप्ट फ़ाइल में दिए गए निर्देशों को MATLAB द्वारा निष्पादित किया जाता है, यहाँ 'हैलो, वर्ल्ड!' disp समारोह का उपयोग करना।

स्क्रिप्ट फ़ाइलों को बाद में (पुनः) उपयोग के लिए आदेशों की एक श्रृंखला को बचाने के लिए इस तरह से लिखा जा सकता है।

खुद की मदद करना

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

इसे कैसे उपयोग किया जा सकता है, इसकी जानकारी टाइप करके प्राप्त की जा सकती है:

>> help help

कमांड विंडो में। यह फ़ंक्शन help के उपयोग की जानकारी लौटाएगा। यदि आपके द्वारा देखी जा रही जानकारी अभी भी अस्पष्ट है, तो आप फ़ंक्शन के दस्तावेज़ीकरण पृष्ठ को आज़मा सकते हैं। बस प्रकार:

>> doc help

कमांड विंडो में। यह फ़ंक्शन help लिए पृष्ठ पर ब्राउज़ करने योग्य दस्तावेज़ को खोल देगा जिसमें आपको यह समझने की ज़रूरत है कि 'सहायता' कैसे काम करती है।

यह प्रक्रिया सभी अंतर्निहित कार्यों और प्रतीकों के लिए काम करती है।

अपने स्वयं के कार्यों को विकसित करते समय आप फ़ंक्शन फ़ाइल के शीर्ष पर या फ़ंक्शन घोषणा के बाद टिप्पणी जोड़कर उन्हें अपना स्वयं का सहायता अनुभाग दे सकते हैं।

एक साधारण फ़ंक्शन के लिए उदाहरण multiplyby2 फ़ाइल में सहेजा गया multiplyby2.m

function [prod]=multiplyby2(num)
% function MULTIPLYBY2 accepts a numeric matrix NUM and returns output PROD 
% such that all numbers are multiplied by 2

    prod=num*2;
end
 

या

% function MULTIPLYBY2 accepts a numeric matrix NUM and returns output PROD 
% such that all numbers are multiplied by 2

function [prod]=multiplyby2(num)
    prod=num*2;
end
 

यह बहुत उपयोगी है जब आप इसे लिखने के बाद अपने कोड हफ्तों / महीनों / वर्षों को उठाते हैं।

help और doc फ़ंक्शन बहुत सारी जानकारी प्रदान करते हैं, उन विशेषताओं का उपयोग करने के लिए सीखने से आपको तेजी से प्रगति करने और MATLAB का कुशलतापूर्वक उपयोग करने में मदद मिलेगी।

अनुक्रमण मैट्रिक्स और सरणियाँ

MATLAB मैट्रिस और सरणियों के तत्वों को इंडेक्स (एक्सेस) करने के लिए कई तरीकों की अनुमति देता है:

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

इन तीन विधियों को अब एक उदाहरण के रूप में निम्नलिखित 3-बाय -3 मैट्रिक्स M का उपयोग करके अधिक विस्तार से समझाया गया है:

>> M = magic(3)

ans = 

       8    1    6
       3    5    7
       4    9    2
 

अनुक्रमणिका अनुक्रमण

किसी तत्व तक पहुँचने के लिए सबसे सीधा तरीका है, इसका पंक्ति-स्तंभ सूचकांक निर्दिष्ट करना। उदाहरण के लिए, दूसरी पंक्ति और तीसरे कॉलम में तत्व तक पहुँचना:

>> M(2, 3)

ans =

      7
 

प्रदान की जाने वाली सदस्यता की संख्या M पास (इस उदाहरण में दो) आयामों की संख्या से बिल्कुल मेल खाती है।

ध्यान दें कि सदस्यता का क्रम गणितीय सम्मेलन के समान है: पंक्ति सूचकांक पहले है। इसके अलावा, के साथ MATLAB सूचकांक शुरू होता है 1 नहीं और 0 सबसे प्रोग्रामिंग भाषाओं की तरह।

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

>> M(2, [1,2,3])

ans =

       3    5    7
 

MATLAB में, वेक्टर [1,2,3] बृहदान्त्र ऑपरेटर अर्थात 1:3 का उपयोग करके आसानी से बनाया जाता है। आप इसका उपयोग अनुक्रमण में भी कर सकते हैं। एक पूरी पंक्ति (या स्तंभ) का चयन करने के लिए, MATLAB तुम सिर्फ निर्दिष्ट की अनुमति देकर एक शॉर्टकट प्रदान करता है : । उदाहरण के लिए, निम्न कोड पूरी दूसरी पंक्ति भी लौटाएगा

>> M(2, :)

ans =

       3    5    7
 

MATLAB end कीवर्ड के रूप में एक आयाम के अंतिम तत्व को निर्दिष्ट करने के लिए एक शॉर्टकट प्रदान करता है। end कीवर्ड ठीक उसी तरह काम करेगा जैसे कि उस आयाम में अंतिम तत्व की संख्या थी। इसलिए यदि आप कॉलम 2 से अंतिम कॉलम के सभी कॉलम चाहते हैं, तो आप निम्नलिखित लिख सकते हैं:

>> M(2, 2:end)

ans =

       5    7
 

सदस्यता अनुक्रमण प्रतिबंधात्मक हो सकता है क्योंकि यह विभिन्न स्तंभों और पंक्तियों से एकल मान निकालने की अनुमति नहीं देगा; यह सभी पंक्तियों और स्तंभों के संयोजन को निकाल देगा।

>> M([2,3], [1,3])
ans =

       3    7
       4    2
 

उदाहरण के लिए सबस्क्रिप्ट इंडेक्सिंग केवल M(2,1) या M(3,3) तत्वों को नहीं निकाल सकती है। ऐसा करने के लिए हमें रैखिक अनुक्रमण पर विचार करना चाहिए।

रैखिक अनुक्रमण

MATLAB आपको केवल एक आयाम का उपयोग करते हुए अनुक्रमणिका के रूप में n- आयामी सरणियों का इलाज करने की अनुमति देता है। आप सीधे पहले तत्व का उपयोग कर सकते हैं:

>> M(1)

ans = 

       8
 

ध्यान दें कि सरणियाँ MATLAB में स्तंभ-प्रमुख क्रम में संग्रहीत की जाती हैं, जिसका अर्थ है कि आप पहले स्तंभों के नीचे जाकर तत्वों का उपयोग करते हैं। तो M(2) पहले कॉलम का दूसरा तत्व है जो 3 और M(4) दूसरा कॉलम का पहला तत्व होगा।

>> M(4)

ans = 

        1
 

MATLAB में अंतर्निहित कार्यों को उप-सूचकांकों को रैखिक सूचकांकों में परिवर्तित करने के लिए मौजूद है, और इसके विपरीत: उप sub2ind और ind2sub क्रमशः। आप मैन्युअल रूप से सदस्यता ( r , c ) को रैखिक सूचकांक में बदल सकते हैं

idx = r + (c-1)*size(M,1)
 

इसे समझने के लिए, यदि हम पहले कॉलम में हैं तो लीनियर इंडेक्स केवल रो इंडेक्स होगा। उपरोक्त सूत्र इसके लिए सही है क्योंकि c == 1 , (c-1) == 0 । अगले कॉलम में, रैखिक सूचकांक पंक्ति संख्या है और पिछले कॉलम की सभी पंक्तियाँ हैं।

ध्यान दें कि end कीवर्ड अभी भी लागू होता है और अब सरणी के बहुत अंतिम तत्व अर्थात M(end) == M(end, end) == 2 को संदर्भित करता है।

आप रैखिक अनुक्रमण का उपयोग करके कई तत्वों को अनुक्रमित भी कर सकते हैं। ध्यान दें कि यदि आप ऐसा करते हैं, तो लौटे मैट्रिक्स में सूचकांक वैक्टर के मैट्रिक्स के समान आकार होगा।

M(2:4) एक पंक्ति वेक्टर देता है क्योंकि 2:4 पंक्ति वेक्टर का प्रतिनिधित्व करता है [2,3,4] :

>> M(2:4)

ans =

        3    4    1
 

एक अन्य उदाहरण के रूप में, M([1,2;3,4]) 2-बाय -2 मैट्रिक्स लौटाता है क्योंकि [1,2;3,4] एक 2-बाय -2 मैट्रिक्स भी है। अपने आप को समझाने के लिए नीचे दिया गया कोड देखें:

>> M([1,2;3,4])

ans =

       8        3
       4        1
 

ध्यान दें कि साथ अनुक्रमण : अकेले हमेशा एक कॉलम वेक्टर लौटाएगा:

>> M(:)

ans = 

        8
        3
        4
        1
        5
        9
        6
        7
        2
 

यह उदाहरण उस क्रम को भी दिखाता है जिसमें MATLAB रैखिक अनुक्रमण का उपयोग करते समय तत्वों को लौटाता है।

तार्किक अनुक्रमण

अनुक्रमण की तीसरी विधि एक तार्किक मैट्रिक्स का उपयोग करना है, अर्थात एक मैट्रिक्स जिसमें केवल true या false मान होते हैं, उन तत्वों को फ़िल्टर करने के लिए जिन्हें आप नहीं चाहते हैं। उदाहरण के लिए, यदि हम M उन सभी तत्वों को खोजना चाहते हैं जो 5 से अधिक हैं तो हम तार्किक मैट्रिक्स का उपयोग कर सकते हैं

>> M > 5

ans =

    1    0    1
    0    0    1
    0    1    0
 

M को अनुक्रमणित करें और केवल उन मानों को लौटाएं जो 5 से अधिक हैं जो निम्नानुसार हैं:

>> M(M > 5)

ans =

        8
        9
        6
        7
 

यदि आप चाहते थे कि ये संख्या यथावत बनी रहे (यानी मैट्रिक्स का आकार बनाए रखें), तो आप तर्क की प्रशंसा कर सकते हैं

>> M(~(M > 5)) = NaN

ans = 

    8      NaN    6
    NaN    NaN    7
    NaN    9      Nan
 

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

गैर-वेक्टरकृत (पहले से ही लूप को रैखिक अनुक्रमण का उपयोग करके छोटा करें):

for elem = 1:numel(M)
  if M(elem) > 5
    M(elem) = M(elem) - 2;
  end
end
 

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

idx = M > 5;
M(idx) = M(idx) - 2;
 

या इससे भी कम:

M(M > 5) = M(M > 5) - 2;
 

अनुक्रमण पर अधिक

उच्च आयाम मेट्रिसेस

ऊपर उल्लिखित सभी विधियां n- आयामों में सामान्यीकृत करती हैं। यदि हम एक उदाहरण के रूप में तीन-आयामी मैट्रिक्स M3 = rand(3,3,3) उपयोग करते हैं, तो आप तीसरे आयाम के सभी पंक्तियों और स्तंभों को लिखकर पहुंच सकते हैं

>> M(:,:,2)
 

आप रैखिक अनुक्रमण का उपयोग करके दूसरे स्लाइस के पहले तत्व तक पहुंच सकते हैं। रैखिक अनुक्रमण सभी पंक्तियों और पहली स्लाइस के सभी स्तंभों के बाद केवल दूसरे स्लाइस पर जाएगा। तो उस तत्व के लिए रैखिक सूचकांक है

>> M(size(M,1)*size(M,2)+1)
 

वास्तव में, MATLAB में, हर मैट्रिक्स n-आयामी है: यह सिर्फ ऐसा होता है कि अन्य n- आयामों में से अधिकांश का आकार एक है। तो, यदि a = 2 तो a(1) == 2 (जैसा कि कोई अपेक्षा करेगा), बल्कि a(1, 1) == 2 , जैसा कि a(1, 1, 1) == 2 , a(1, 1, 1, ..., 1) == 2 और इसी तरह। ये "अतिरिक्त" आयाम (आकार 1 ), को सिंगलटन आयाम के रूप में जाना जाता है। कमांड squeeze उन्हें हटा देगा, और एक व्यक्ति आयाम का क्रम स्वैप करने के लिए permute का उपयोग कर सकता है (और यदि आवश्यक हो तो सिंगलटन आयामों को पेश कर सकता है)।

एक एन-आयामी मैट्रिक्स को एक एम सब्सक्रिप्शन (जहां एम <= एन) का उपयोग करके अनुक्रमित किया जा सकता है। नियम यह है कि पहला m-1 सदस्यता सामान्य रूप से व्यवहार करता है, जबकि अंतिम (m'th) सबस्क्रिप्ट शेष (n-m + 1) आयामों को संदर्भित करता है, जैसे कि एक रैखिक सूचकांक एक (n-m + 1) आयामी का संदर्भ देगा सरणी। यहाँ एक उदाहरण है:

>> M = reshape(1:24,[2,3,4]);
>> M(1,1)
ans =
     1
>> M(1,10)
ans =
    19
>> M(:,:)
ans =
     1     3     5     7     9    11    13    15    17    19    21    23
     2     4     6     8    10    12    14    16    18    20    22    24
 

तत्वों की श्रेणी लौटाना

सबस्क्रिप्ट इंडेक्सिंग के साथ, यदि आप एक से अधिक तत्वों को एक से अधिक आयामों में निर्दिष्ट करते हैं, तो MATLAB निर्देशांक की प्रत्येक संभावित जोड़ी को लौटाता है। उदाहरण के लिए, यदि आप M ([1,2], [1,3]) की कोशिश करते हैं, तो MATLAB M(1,1) और M(2,3) लौटाएगा लेकिन यह M(1,3) और M(2,1) भी लौटेगा M(2,1) । जब आप समन्वय जोड़े की सूची के लिए तत्वों की तलाश कर रहे हैं तो यह स्पष्ट नहीं लग सकता है, लेकिन एक बड़े मैट्रिक्स के उदाहरण पर विचार करें, A = rand(20) (नोट A अब 20 -बीएच- 20 ), जहां आप प्राप्त करना चाहते हैं शीर्ष दाहिना हाथ चतुर्भुज। इस मामले में उस चतुर्थांश में प्रत्येक समन्वय जोड़ी को निर्दिष्ट करने के बजाय (और यह मामला जो कि 100 जोड़े होंगे), आप बस 10 पंक्तियों और 10 कॉलमों को निर्दिष्ट करें जो आप चाहते हैं A(1:10, 11:end) । इस तरह से एक मैट्रिक्स का टुकड़ा करना समन्वित जोड़े की सूची की आवश्यकता से कहीं अधिक सामान्य है।

इस घटना में कि आप समन्वित जोड़े की एक सूची प्राप्त करना चाहते हैं, सबसे सरल समाधान रैखिक अनुक्रमण में परिवर्तित करना है। उस समस्या पर विचार करें जहां आपके पास कॉलम सूचकांकों का एक वेक्टर है जिसे आप वापस करना चाहते हैं, जहां वेक्टर की प्रत्येक पंक्ति में वह कॉलम संख्या होती है जिसे आप मैट्रिक्स की संबंधित पंक्ति के लिए वापस चाहते हैं। उदाहरण के लिए

colIdx = [3;2;1]
 

तो इस मामले में आप वास्तव में (1,3) , (2,2) और (3,1) तत्वों को वापस लाना चाहते हैं। तो रैखिक अनुक्रमण का उपयोग कर:

>> colIdx = [3;2;1];
>> rowIdx = 1:length(colIdx);
>> idx = sub2ind(size(M), rowIdx, colIdx);
>> M(idx)

ans = 

        6    5    4
 

एक तत्व को कई बार लौटाना

सबस्क्रिप्ट और लीनियर इंडेक्सिंग के साथ आप एक तत्व को कई बार वापस कर सकते हैं ताकि यह सूचकांक को दोहरा सके

>> M([1,1,1,2,2,2])

ans = 

        8    8    8    3    3    3
 

आप पहली पंक्ति और अंतिम कॉलम को दोहराने के लिए उदाहरण के लिए संपूर्ण पंक्तियों और कॉलम को डुप्लिकेट करने के लिए इसका उपयोग कर सकते हैं

>> M([1, 1:end], [1:end, end])

ans = 

        8    1    6    6 
        8    1    6    6
        3    5    7    7
        4    9    2    2
 

अधिक जानकारी के लिए, यहाँ देखें।

मेट्रिसेस और एरेस

MATLAB में, सबसे बुनियादी डेटा प्रकार संख्यात्मक सरणी है। यह एक अदिश, 1-डी वेक्टर, 2-डी मैट्रिक्स, या एक एनडी बहुआयामी सरणी हो सकता है।

% a 1-by-1 scalar value
x = 1;
 

एक पंक्ति वेक्टर बनाने के लिए, कोष्ठक के अंदर तत्वों को दर्ज करें, जो रिक्त स्थान या अल्पविराम द्वारा अलग किए गए हैं:

% a 1-by-4 row vector
v = [1, 2, 3, 4];
v = [1 2 3 4];
 

कॉलम वेक्टर बनाने के लिए, अर्धविराम वाले तत्वों को अलग करें:

% a 4-by-1 column vector
v = [1; 2; 3; 4];
 

मैट्रिक्स बनाने के लिए, हम अर्धविराम द्वारा अलग किए गए पंक्तियों को दर्ज करते हैं:

% a 2 row-by-4 column matrix
M = [1 2 3 4; 5 6 7 8];

% a 4 row-by-2 column matrix
M = [1 2; ...
     4 5; ...
     6 7; ...
     8 9];
 

ध्यान दें कि आप असमान पंक्ति / स्तंभ आकार के साथ एक मैट्रिक्स नहीं बना सकते हैं। सभी पंक्तियों की लंबाई समान होनी चाहिए, और सभी स्तंभों की लंबाई समान होनी चाहिए:

% an unequal row / column matrix
M = [1 2 3 ; 4 5 6 7]; % This is not valid and will return an error

% another unequal row / column matrix
M = [1 2 3; ...
     4   5; ...
     6 7 8; ...
     9   10];     % This is not valid and will return an error
 

वेक्टर या मैट्रिक्स को स्थानांतरित करने के लिए, हम इसका उपयोग करते हैं .' -ओपरेटर, या ' ऑपरेटर अपने हर्मिटियन संयुग्म को लेने के लिए, जो कि इसके संक्रमण का जटिल संयुग्म है। वास्तविक विवाह के लिए, ये दोनों समान हैं:

% create a row vector and transpose it into a column vector
v = [1 2 3 4].';              % v is equal to [1; 2; 3; 4];

% create a 2-by-4 matrix and transpose it to get a 4-by-2 matrix
M = [1 2 3 4; 5 6 7 8].';     % M is equal to [1 5; 2 6; 3 7; 4 8]

% transpose a vector or matrix stored as a variable
A = [1 2; 3 4];
B = A.';                      % B is equal to [1 3; 2 4]
 

दो से अधिक आयामों के सरणियों के लिए, उन्हें शाब्दिक रूप से दर्ज करने के लिए कोई प्रत्यक्ष भाषा वाक्यविन्यास नहीं है। इसके बजाय हम कार्यों उन्हें निर्माण करने के लिए (जैसे का उपयोग करना चाहिए ones , zeros , rand ) या अन्य सरणियों जोड़ तोड़ द्वारा (जैसे कार्यों का उपयोग कर cat , reshape , permute )। कुछ उदाहरण:

% a 5-by-2-by-4-by-3 array (4-dimensions)
arr = ones(5, 2, 4, 3);

% a 2-by-3-by-2 array (3-dimensions)
arr = cat(3, [1 2 3; 4 5 6], [7 8 9; 0 1 2]);

% a 5-by-4-by-3-by-2 (4-dimensions)
arr = reshape(1:120, [5 4 3 2]);
 

इनपुट और लेखन आउटपुट पढ़ना

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

इससे पहले कि आप अपनी फ़ाइल में लोड करने का प्रयास करें, आपको अपने आप से पूछना चाहिए कि आप क्या चाहते हैं कि डेटा बन जाए और आप कैसे उम्मीद करते हैं कि कंप्यूटर आपके लिए डेटा को व्यवस्थित करेगा। कहो कि आपके पास निम्नलिखित प्रारूप में एक txt / csv फ़ाइल है:

Fruit,TotalUnits,UnitsLeftAfterSale,SellingPricePerUnit
Apples,200,67,$0.14
Bananas,300,172,$0.11
Pineapple,50,12,$1.74
 

हम देख सकते हैं कि पहला कॉलम स्ट्रिंग्स के प्रारूप में है, जबकि दूसरा, तीसरा न्यूमेरिक है, अंतिम कॉलम करेंसी के रूप में है। मान लें कि हम चाहते हैं कि आज हम मटलब का उपयोग करके कितना राजस्व अर्जित करें और पहले हम इस txt / csv फ़ाइल में लोड करना चाहते हैं। लिंक की जाँच करने के बाद, हम देख सकते हैं कि स्ट्रिंग और न्यूमेरिक प्रकार की txt फाइलें textscan द्वारा नियंत्रित की जाती हैं। तो हम कोशिश कर सकते हैं:

fileID = fopen('dir/test.txt'); %Load file from dir
C = textscan(fileID,'%s %f %f %s','Delimiter',',','HeaderLines',1); %Parse in the txt/csv
 

जहाँ %s सुझाव है कि तत्व एक स्ट्रिंग प्रकार है, %f सुझाव देता है कि तत्व एक फ्लोट प्रकार है, और यह कि फ़ाइल "," द्वारा सीमांकित है। HeaderLines विकल्प पहले N लाइनों को छोड़ने के लिए Matlab को कहता है जबकि 1 के तुरंत बाद इसका मतलब पहली पंक्ति (शीर्ष लेख) को छोड़ना है।

अब C वह डेटा है जो हमने लोड किया है जो 4 कोशिकाओं के सेल एरे के रूप में है, प्रत्येक में txt / csv फ़ाइल में डेटा का कॉलम है।

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

sold = C{2} - C{3}; %C{2} gives the elements inside the second cell (or the second column)
 

अब हम इस वेक्टर को मूल्य प्रति इकाई से गुणा करना चाहते हैं, इसलिए पहले हमें स्ट्रिंग्स के उस कॉलम को संख्याओं के एक कॉलम में बदलना होगा, फिर इसे Matlab के cell2mat का उपयोग करते हुए एक न्यूमेरिक मैट्रिक्स में परिवर्तित करना होगा पहली चीज जिसे हमें cell2mat करना cell2mat "$" संकेत से, ऐसा करने के कई तरीके हैं। सबसे सीधा तरीका एक सरल रीगेक्स का उपयोग कर रहा है:

D = cellfun(@(x)(str2num(regexprep(x, '\$',''))), C{4}, 'UniformOutput', false);%cellfun allows us to avoid looping through each element in the cell.
 

या आप एक लूप का उपयोग कर सकते हैं:

for t=1:size(C{4},1)
   D{t} = str2num(regexprep(C{4}{t}, '\$',''));
end

E = cell2mat(D)% converts the cell array into a Matrix
 

str2num फ़ंक्शन स्ट्रिंग को बदल देता है जिसमें "$" संकेत सांख्यिक प्रकारों में छीन लिए गए थे और cell2mat संख्याओं के एक मैट्रिक्स में संख्यात्मक तत्वों के सेल को बदल देता है

अब हम प्रति यूनिट लागत द्वारा बेची गई इकाइयों को गुणा कर सकते हैं:

revenue = sold .* E; %element-wise product is denoted by .* in Matlab

totalrevenue = sum(revenue);
 

लिपियों और कार्यों

MATLAB कोड को पुन: उपयोग किए जाने वाले m-files में सहेजा जा सकता है। m-files में .m एक्सटेंशन होता है जो स्वचालित रूप से MATLAB से जुड़ा होता है। एक एम-फाइल में स्क्रिप्ट या फ़ंक्शंस हो सकते हैं।

स्क्रिप्ट

लिपियां केवल प्रोग्राम फाइलें हैं जो MATLAB कमांड की एक श्रृंखला को पूर्वनिर्धारित क्रम में निष्पादित करती हैं।

लिपियां इनपुट स्वीकार नहीं करती हैं, न ही स्क्रिप्ट आउटपुट देती हैं। कार्यात्मक रूप से, स्क्रिप्ट सीधे MATLAB कमांड विंडो में कमांड टाइप करने और उन्हें फिर से चलाने में सक्षम होने के बराबर हैं।

एक स्क्रिप्ट का एक उदाहरण:

length = 10;
width = 3;
area = length * width;
 

यह स्क्रिप्ट वर्तमान कार्यक्षेत्र में क्रमशः 10 , 3 , और 30 साथ length , width और area को परिभाषित करेगी।

जैसा कि पहले कहा गया है, उपरोक्त स्क्रिप्ट कार्यात्मक रूप से समान कमांड को सीधे कमांड विंडो में टाइप करने के बराबर है।

>> length = 10;
>> width = 3;
>> area = length * width;
 

कार्य

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

सभी कार्यों को एक ही हेडर प्रारूप के साथ परिभाषित किया गया है:

function [output] = myFunctionName(input)
 

function कीवर्ड हर फंक्शन हेडर को शुरू करता है। आउटपुट की सूची इस प्रकार है। आउटपुट की सूची भी वापसी के लिए चर की अल्पविराम से अलग की गई सूची हो सकती है।

function [a, b, c] = myFunctionName(input)
 

अगला उस फ़ंक्शन का नाम है जिसका उपयोग कॉलिंग के लिए किया जाएगा। यह आमतौर पर फ़ाइल नाम के समान नाम है। उदाहरण के लिए, हम इस फ़ंक्शन को myFunctionName.m रूप में myFunctionName.m

फ़ंक्शन नाम के बाद इनपुट की सूची है। आउटपुट की तरह, यह अल्पविराम से अलग की गई सूची भी हो सकती है।

function [a, b, c] = myFunctionName(x, y, z)
 

हम पहले की तरह पुन: प्रयोज्य कार्य के रूप में उदाहरण स्क्रिप्ट को फिर से लिख सकते हैं:

function [area] = calcRecArea(length, width)
   area = length * width;
end
 

हम अन्य कार्यों से या यहां तक कि स्क्रिप्ट फ़ाइलों से फ़ंक्शन कॉल कर सकते हैं। यहां हमारे उपरोक्त फ़ंक्शन का एक स्क्रिप्ट फ़ाइल में उपयोग किया जा रहा है।

l = 100;
w = 20;
a = calcRecArea(l, w);
 

पहले की तरह, हम क्रमशः 100 , 20 और 2000 के मान के साथ कार्यक्षेत्र में l , w और a बनाते हैं।