MATLAB Language Handledning
Komma igång med MATLAB Language

versioner

Hej världen

Öppna ett nytt tomt dokument i MATLAB Editor (i senaste versioner av MATLAB, gör detta genom att välja fliken Hem i verktygsstripen och klicka på Nytt skript). Standardtangentgenvägen för att skapa ett nytt skript är Ctrl-n .

Alternativt kommer att skriva edit myscriptname.m att öppna filen myscriptname.m för redigering eller erbjuda att skapa filen om den inte finns på MATLAB-sökvägen.

Skriv följande i redigeraren:

disp('Hello, World!');

Välj fliken Editor i verktygsstripen och klicka på Spara som. Spara dokumentet i en fil i den aktuella katalogen som heter helloworld.m . Om du sparar en fil utan namn kommer det att visas en dialogruta för att namnge filen.

Skriv in följande i kommandofönstret MATLAB:

>> helloworld

Du bör se följande svar i kommandofönstret MATLAB:

Hello, World!

Vi ser att vi i kommandofönstret kan skriva in namnen på funktioner eller skriptfiler som vi har skrivit, eller som levereras med MATLAB, för att köra dem.

Här har vi kört "helloworld" -skriptet. Observera att det är onödigt att skriva tillägget ( .m ). Instruktionerna i skriptfilen utförs av MATLAB, här trycker du "Hej, världen!" med disp funktionen.

Skriptfiler kan skrivas på detta sätt för att spara en serie kommandon för senare (åter) användning.

Matriser och matriser

I MATLAB är den mest grundläggande datatyp den numeriska matrisen. Det kan vara en skalär, en 1-D-vektor, en 2-D-matris eller en ND-multidimensionell matris.

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

För att skapa en radvektor anger du elementen inom parentes, separerade med mellanslag eller komma:

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

För att skapa en kolumnvektor, separera elementen med semikolon:

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

För att skapa en matris, matar vi in raderna som tidigare separerade med semikolon:

% 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];

Observera att du inte kan skapa en matris med ojämn rad / kolumnstorlek. Alla rader måste vara av samma längd och alla kolumner måste ha samma längd:

% 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

För att transponera en vektor eller en matris använder vi .' mellan operatörer, eller ' till operatören ta dess Hermitian-konjugatet, som är det komplexa konjugatet av dess transponering. För riktiga matriser är dessa två desamma:

% 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]

För matriser med mer än två dimensioner finns det ingen direkt språksyntax för att skriva in dem bokstavligen. Istället måste vi använda funktioner för att konstruera dem (som ones , zeros , rand ) eller genom att manipulera andra matriser (använda funktioner som cat , reshape , permute ). Några exempel:

% 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]);

Indexera matriser och matriser

MATLAB tillåter flera metoder för att indexera (åtkomst) element i matriser och matriser:

• Prenumerationsindexering - där du anger positionen för de element du vill ha i varje dimension av matrisen separat.
• Linjär indexering - där matrisen behandlas som en vektor, oavsett dess dimensioner. Det betyder att du anger varje position i matrisen med ett enda nummer.
• Logisk indexering - där du använder en logisk matris (och matris med true och false värden) med identiska dimensioner för matrisen du försöker indexera som en mask för att ange vilket värde som ska returneras.

Dessa tre metoder förklaras nu mer detaljerat med användning av följande 3-för-3-matris M som ett exempel:

>> M = magic(3)

ans = 

       8    1    6
       3    5    7
       4    9    2

Prenumerationsindex

Den mest raka framåtmetoden för att komma åt ett element är att ange dess radkolumnindex. Till exempel, åtkomst till elementet på den andra raden och den tredje kolumnen:

>> M(2, 3)

ans =

      7

Antalet abonnemang som anges exakt matchar antalet dimensioner som M har (två i det här exemplet).

Observera att ordningen på abonnemang är densamma som den matematiska konventionen: radindex är den första. MATLAB-index börjar dessutom med 1 och inte 0 som de flesta programmeringsspråk.

Du kan indexera flera element samtidigt genom att skicka en vektor för varje koordinat istället för ett enda nummer. Till exempel för att få hela den andra raden kan vi ange att vi vill ha den första, andra och tredje kolumnen:

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

ans =

       3    5    7

I MATLAB skapas lättare vektorn [1,2,3] hjälp av kolonoperatören, dvs 1:3 . Du kan också använda detta vid indexering. För att markera en hel rad (eller kolumn) ger MATLAB en genväg genom att du bara ange : . Till exempel kommer följande kod att returnera hela den andra raden

>> M(2, :)

ans =

       3    5    7

MATLAB ger också en genväg för att ange det sista elementet i en dimension i form av end nyckelordet. Den end sökord kommer att fungera precis som om det var numret på det sista elementet i den dimensionen. Så om du vill ha alla kolumner från kolumn 2 till den sista kolumnen kan du skriva följande:

>> M(2, 2:end)

ans =

       5    7

Prenumerationsindexering kan vara begränsande eftersom det inte tillåter att extrahera enstaka värden från olika kolumner och rader; det kommer att extrahera kombinationen av alla rader och kolumner.

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

       3    7
       4    2

Exempelvis kan subkriptindexering inte bara extrahera elementen M(2,1) eller M(3,3) . För att göra detta måste vi överväga linjär indexering.

Linjär indexering

MATLAB låter dig behandla n-dimensionella matriser som en-dimensionella matriser när du indexerar med bara en dimension. Du kan direkt komma åt det första elementet:

>> M(1)

ans = 

       8

Observera att matriser lagras i kolumn-huvudordning i MATLAB vilket innebär att du kommer åt elementen genom att först gå ner i kolumnerna. Så M(2) är det andra elementet i den första kolumnen som är 3 och M(4) kommer att vara det första elementet i den andra kolumnen, dvs.

>> M(4)

ans = 

        1

Det finns inbyggda funktioner i MATLAB för att konvertera prenumerationsindex till linjära index, och vice versa: sub2ind respektive ind2sub . Du kan manuellt konvertera subskripten ( r , c ) till ett linjärt index med

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

För att förstå detta, om vi är i den första kolumnen, kommer linjära index helt enkelt att vara radindex. Formeln ovan gäller för detta eftersom för c == 1 , (c-1) == 0 . I nästa kolumner är det linjära index radnumret plus alla raderna i de föregående kolumnerna.

Notera att end nyckelordet fortfarande gäller och nu hänvisar till den allra sista element i arrayen, dvs M(end) == M(end, end) == 2 .

Du kan också indexera flera element med linjär indexering. Observera att om du gör det kommer den returnerade matrisen att ha samma form som matrisen för indexvektorer.

M(2:4) returnerar en radvektor eftersom 2:4 representerar radvektorn [2,3,4] :

>> M(2:4)

ans =

        3    4    1

Som ett annat exempel returnerar M([1,2;3,4]) en 2-by-2-matris eftersom [1,2;3,4] är en 2-by-2-matris. Se koden nedan för att övertyga dig själv:

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

ans =

       8        3
       4        1

Observera att indexering med : ensam alltid kommer att returnera en kolumnvektor:

>> M(:)

ans = 

        8
        3
        4
        1
        5
        9
        6
        7
        2

Detta exempel illustrerar också ordningen i vilken MATLAB returnerar element när man använder linjär indexering.

Logisk indexering

Den tredje metoden för indexering är att använda en logisk matris, dvs en matris som endast innehåller true eller false värden, som en mask för att filtrera bort de element du inte vill ha. Om vi till exempel vill hitta alla element i M som är större än 5 vi använda den logiska matrisen

>> M > 5

ans =

    1    0    1
    0    0    1
    0    1    0

att indexera M och bara returnera värden som är större än 5 enligt följande:

>> M(M > 5)

ans =

        8
        9
        6
        7

Om du ville att dessa nummer skulle stanna på plats (dvs behålla formen på matrisen), kan du tilldela det logiska komplimentet

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

ans = 

    8      NaN    6
    NaN    NaN    7
    NaN    9      Nan

Vi kan minska komplicerade kodblock som innehåller if och for uttalanden med hjälp av logisk indexering.

Ta det icke-vektoriserade (redan förkortat till en enda slinga med linjär indexering):

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

Detta kan förkortas till följande kod med logisk indexering:

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

Eller ännu kortare:

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

Mer om indexering

Matriser med högre dimension

Alla ovan nämnda metoder generaliseras till n-dimensioner. Om vi använder den tredimensionella matrisen M3 = rand(3,3,3) som exempel, kan du komma åt alla rader och kolumner i den andra skivan i den tredje dimensionen genom att skriva

>> M(:,:,2)

Du kan komma åt det första elementet i det andra segmentet med linjär indexering. Linjär indexering kommer att gå vidare till den andra skivan efter alla raderna och alla kolumnerna i den första skivan. Så det linjära indexet för det elementet är

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

I MATLAB är varje matris faktiskt n-dimensionell: det räcker bara att storleken på de flesta andra n-dimensioner är en. Så om a = 2 så är a(1) == 2 (som man kan förvänta sig), men också a(1, 1) == 2 , liksom a(1, 1, 1) == 2 , a(1, 1, 1, ..., 1) == 2 och så vidare. Dessa "extra" dimensioner (av storlek 1 ) kallas singleton-dimensioner . Kommandot squeeze kommer att ta bort dem, och man kan använda permute att byta ordningen på dimensionerna runt (och införa Singleton dimensioner om det behövs).

En n-dimensionell matris kan också indexeras med hjälp av ett m-underskript (där m <= n). Regeln är att de första m-1-subskripten uppträder vanligtvis medan det sista (m'th) subskriptet refererar till de återstående (n-m + 1) dimensioner, precis som ett linjärt index skulle hänvisa till en (n-m + 1) dimension array. Här är ett exempel:

>> 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

Återvändande intervall av element

Om du anger mer än ett element i mer än en dimension med subkriptindexering, returnerar MATLAB varje möjligt par koordinater. Om du till exempel försöker M ([1,2], [1,3]) kommer MATLAB att returnera M(1,1) och M(2,3) men det kommer också att returnera M(1,3) och M(2,1) . Detta kan verka ointuitivt när du letar efter elementen för en lista med koordinatpar, men tänk på exemplet på en större matris, A = rand(20) (anmärkning A är nu 20 by- 20 ), där du vill få övre högra kvadrant. I det här fallet istället för att behöva ange varje koordinatpar i den kvadranten (och det här fallet som skulle vara 100 par), anger du bara de 10 raderna och de 10 kolumner du vill ha så A(1:10, 11:end) . Skivning av en matris som denna är mycket vanligare än att kräva en lista med koordinatpar.

Om du vill få en lista med koordinatpar är den enklaste lösningen att konvertera till linjär indexering. Tänk på problemet där du har en vektor med kolumnindex som du vill returnera, där varje rad i vektorn innehåller kolumnnumret du vill returnera för motsvarande rad i matrisen. Till exempel

colIdx = [3;2;1]

Så i det här fallet vill du faktiskt få tillbaka elementen på (1,3) , (2,2) och (3,1) . Så med hjälp av linjär indexering:

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

ans = 

        6    5    4

Återvända ett element flera gånger

Med subscript och linjär indexering kan du också returnera ett element flera gånger genom att upprepa indexet så

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

ans = 

        8    8    8    3    3    3

Du kan använda detta för att duplicera hela rader och kolumn till exempel för att upprepa den första raden och den sista kolumnen

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

ans = 

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

För mer information, se här .

Hjälpa dig själv

MATLAB kommer med många inbyggda skript och funktioner som sträcker sig från enkel multiplikation till verktygslådor för bildigenkänning. För att få information om en funktion du vill använda, typ: help functionname i kommandoraden. Låter ta help fungera som ett exempel.

Information om hur du använder den kan erhållas genom att skriva:

>> help help

i kommandofönstret. Detta kommer att returnera information om användningen av funktions help . Om informationen du letar efter fortfarande är oklar kan du prova dokumentationssidan för funktionen. Skriv bara:

>> doc help

i kommandofönstret. Detta kommer att öppna sökbara dokumentation på sidan för funktions help ger all information du behöver för att förstå hur 'Hjälp' verk.

Den här proceduren fungerar för alla inbyggda funktioner och symboler.

När du utvecklar dina egna funktioner kan du låta dem ha sin egen hjälpavsnitt genom att lägga till kommentarer högst upp i funktionsfilen eller strax efter funktionsdeklarationen.

Exempel för en enkel funktion multiplyby2 sparad i filen 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

eller

% 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

Detta är mycket användbart när du hämtar din kod veckor / månader / år efter att du har skrivit den.

help och doc funktionen ger mycket information, genom att lära dig hur du använder dessa funktioner hjälper du att utvecklas snabbt och använda MATLAB effektivt.

Läsa inmatning & skrivutgång

Precis som alla programmeringsspråk är Matlab designad för att läsa och skriva i ett stort antal olika format. Det ursprungliga biblioteket stöder ett stort antal text-, bild-, video-, ljud-, dataformat med fler format som ingår i varje versionuppdatering - kolla här för att se hela listan över filformat som stöds och vilken funktion som ska användas för att importera dem.

Innan du försöker ladda in din fil måste du fråga dig själv vad vill du att data ska bli och hur du förväntar dig att datorn ska ordna uppgifterna åt dig. Säg att du har en txt / csv-fil i följande format:

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

Vi kan se att den första kolumnen är i formatet Strängar, medan den andra, tredje är numerisk, den sista kolumnen är i form av Valuta. Låt oss säga att vi vill hitta hur mycket intäkter vi gjorde idag med Matlab och först vill vi ladda i den här txt / csv-filen. Efter att ha kontrollerat länken kan vi se att sträng och numerisk typ av txt-filer hanteras av textscan . Så vi kan försöka:

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

där %s föreslår att elementet är en strängtyp föreslår %f att elementet är en Float-typ och att filen är avgränsad av ",". Alternativet HeaderLines ber Matlab att hoppa över de första N-linjerna medan 1 omedelbart efter det betyder att hoppa över den första raden (rubrikraden).

Nu är C de data vi har laddat som är i form av en celluppsättning med 4 celler, var och en innehåller kolumnen med data i txt / csv-filen.

Så först vill vi beräkna hur många frukter vi sålde idag genom att subtrahera den tredje kolumnen från den andra kolumnen, detta kan göras med:

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

Nu vill vi multiplicera denna vektor med Priset per enhet, så först måste vi konvertera den kolumnen Strängar till en kolumn med siffror, sedan konvertera den till en numerisk matris med hjälp av cell2mat Det första vi behöver göra är att strip- av "$" -tecknet finns det många sätt att göra detta. Det mest direkta sättet är att använda en enkel regex:

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

Eller så kan du använda en slinga:

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 funktionen förvandlar strängen som hade "$" -tecken strippade till numeriska typer och cell2mat förvandlar cellen med numeriska element till en matris med siffror

Nu kan vi multiplicera de sålda enheterna med kostnaden per enhet:

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

totalrevenue = sum(revenue);

Celluppsättningar

Element i samma klass kan ofta sammankopplas till matriser (med några få sällsynta undantag, t.ex. funktionshandtag). Numeriska skalar, som standard för klass double , kan lagras i en matris.

>> 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

Tecken, som är av char i MATLAB, kan också lagras i array med liknande syntax. En sådan matris liknar en sträng på många andra programmeringsspråk.

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

Observera att trots att båda använder parenteser [ och ] är resultatklasserna olika. Därför är de operationer som kan göras på dem också olika.

>> whos
  Name      Size            Bytes  Class     Attributes

  A         2x5                80  double              
  s         1x13               26  char                

I själva verket, matrisen s är inte en samling av strängarna 'MATLAB ' , 'is ' och 'fun' , det är bara en sträng - en samling av 13 tecken. Du skulle få samma resultat om det definierades av något av följande:

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

En vanlig MATLAB-vektor låter dig inte lagra en blandning av variabler i olika klasser, eller några olika strängar. Det är där den cell array kommer väl till pass. Detta är en matris med celler som var och en kan innehålla ett MATLAB-objekt, vars klass kan vara olika i varje cell om det behövs. Använd lockiga hängslen { och } runt elementen för att lagra i en celluppsättning.

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

  C         2x1               330  cell 

Standard MATLAB-objekt i alla klasser kan lagras tillsammans i en celluppsättning. Observera att celluppsättningar kräver mer minne för att lagra innehållet.

Åtkomst till innehållet i en cell görs med lockiga hängslen { och } .

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

Observera att C(1) skiljer sig från C{1} . Medan den senare returnerar cellens innehåll (och har klass double i exemplet), returnerar den förstnämnda en celluppsättning som är en deluppsättning av C På liknande sätt, om D var en 10 med 5-celluppsättning, skulle D(4:8,1:3) returnera en deluppsättning av D vars storlek är 5 av 3 och vars klass är cell . Och syntaxen C{1:2} har inte ett enda returnerat objekt, men raterar det returnerar 2 olika objekt (liknande en MATLAB-funktion med flera returrelaterade värden):

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

Skript och funktioner

MATLAB-kod kan sparas i m-filer som kan återanvändas. m-filer har .m förlängningen som automatiskt associeras med MATLAB. En m-fil kan innehålla antingen ett skript eller funktioner.

skript

Skript är helt enkelt programfiler som kör en serie MATLAB-kommandon i en fördefinierad ordning.

Skript accepterar inte ingång, och skript returnerar inte heller utdata. Funktionellt är skript likvärdiga med att skriva kommandon direkt i MATLAB-kommandofönstret och kunna spela upp dem igen.

Ett exempel på ett manus:

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

Detta skript definierar length , width och area i det aktuella arbetsområdet med värdet 10 , 3 respektive 30 .

Som nämnts tidigare är skriptet ovan funktionellt ekvivalent med att skriva samma kommandon direkt i kommandofönstret.

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

funktioner

Funktioner, jämfört med skript, är mycket mer flexibla och utdragbara. Till skillnad från skript kan funktioner acceptera inmatning och returnera utdata till den som ringer. En funktion har sin egen arbetsyta, det betyder att interna funktioner för funktionerna inte kommer att ändra variablerna från den som ringer.

Alla funktioner definieras med samma rubrikformat:

function [output] = myFunctionName(input)

function börjar varje funktionshuvud. Listan över utgångar följer. Listan med utgångar kan också vara en kommaseparerad lista med variabler som ska returneras.

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

Nästa är namnet på den funktion som kommer att användas för att ringa. Detta är vanligtvis samma namn som filnamnet. Vi sparar till exempel den här funktionen som myFunctionName.m .

Följande funktionsnamn är listan över ingångar. Liksom utgångarna kan detta också vara en kommaseparerad lista.

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

Vi kan skriva om exemplet från tidigare skript som en återanvändbar funktion som följande:

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

Vi kan ringa funktioner från andra funktioner, eller till och med från skriptfiler. Här är ett exempel på att funktionen ovan används i en skriptfil.

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

Som tidigare skapar vi l , w och a i arbetsområdet med värdena 100 , 20 respektive 2000 .

Datatyper

Det finns 16 grundläggande datatyper eller klasser i MATLAB. Var och en av dessa klasser har formen av en matris eller matris. Med undantag för funktionshandtag är denna matris eller matris minst 0-by-0 i storlek och kan växa till en n-dimensionell matris av valfri storlek. Ett funktionshandtag är alltid skalärt (1-vid-1).

Det viktiga ögonblicket i MATLAB är att du inte behöver använda någon typdeklaration eller dimensioner. När du definierar en ny variabel skapar MATLAB den automatiskt och fördelar lämpligt minnesutrymme.

Exempel:

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    

Om variabeln redan finns, ersätter MATLAB originalinformationen med en ny och tilldelar vid behov nytt lagringsutrymme.

Grundläggande datatyper

Grundläggande datatyper är: numeriska, logical , char , cell , struct , table och function_handle .

Numeriska datatyper :

• Flyttalsnummer ( standard )

  MATLAB representerar flytpunktsnummer i antingen dubbelprecision eller enkelprecisionsformat. Standardvärdet är dubbel precision, men du kan göra valfri enstaka precision med en enkel konverteringsfunktion:

  a = 1.23;
  b = single(a);
  
  >> whos
    Name      Size            Bytes  Class     Attributes
  
    a         1x1                 8  double              
    b         1x1                 4  single     
  

• heltal

  MATLAB har fyra signerade och fyra osignerade heltalsklasser. Undertecknade typer gör att du kan arbeta med negativa heltal såväl som positiva, men kan inte representera ett så brett antal siffror som de osignerade typerna eftersom en bit används för att beteckna ett positivt eller negativt tecken för numret. Osignerade typer ger dig ett bredare antal siffror, men dessa nummer kan bara vara noll eller positiva.

  MATLAB stöder 1-, 2-, 4- och 8-byte lagring för heltal data. Du kan spara minne och körningstid för dina program om du använder den minsta heltalstypen som rymmer dina data. Till exempel behöver du inte ett 32-bitars heltal för att lagra värdet 100.

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

  För att lagra data som ett heltal måste du konvertera från dubbel till önskad heltalstyp. Om antalet som konverteras till ett heltal har en bråkdel avrundas MATLAB till närmaste heltal. Om bråkdelen är exakt 0.5 , väljer MATLAB från de två lika närliggande heltala den för vilken det absoluta värdet är större i storlek.

  a  = int16(456);
  

• char

  Teckenuppsättningar ger lagring för textdata i MATLAB. I enlighet med traditionell programmeringsterminologi definieras en matris (sekvens) med tecken som en sträng. Det finns ingen uttrycklig strängtyp i detaljhandelsreleaser av MATLAB.

• logiskt: logiska värden på 1 eller 0, representerar sant respektive falskt. Används för relationella förhållanden och arrayindexering. Eftersom det bara är SANT eller FALSE har det storlek 1 byte.

  a = logical(1);
  

• strukturera. En strukturuppsättning är en datatyp som grupperar variabler av olika datatyper med datahållare som heter fält . Varje fält kan innehålla alla typer av data. Få åtkomst till data i en struktur med punktnotation av formuläret structName.fieldName.

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

  För att få åtkomst till värde1 är var och en av följande syntaxer ekvivalenta

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

  Vi kan uttryckligen komma åt ett fält som vi vet kommer att existera med den första metoden, eller antingen passera en sträng eller skapa en sträng för att komma åt fältet i det andra exemplet. Det tredje exemplet är att demonstrera att noteringen av dot parenthases tar en sträng, vilket är samma som lagras i variabeln field1.

• tabellvariabler kan ha olika storlekar och datatyper, men alla variabler måste ha samma antal rader.

  Age = [15 25 54]';
  Height = [176 190 165]';
  Name = {'Mike', 'Pete', 'Steeve'}';
  T = table(Name,Age, Height);
  

• cell. Det är mycket användbart MATLAB-datatyp: celluppsättning är en matris som varje element i den kan ha av olika datatyp och storlek. Det är ett mycket starkt instrument för att manipulera data som du vill.

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

  eller

  a = cell(3);
  

• funktion hanterar lagrar en pekare till en funktion (till exempel till anonym funktion). Det låter dig överföra en funktion till en annan funktion eller ringa lokala funktioner utanför huvudfunktionen.

Det finns en hel del instrument för att arbeta med varje datatyp och även inbyggd datatypskonvertering funktioner ( str2double , table2cell ).

Ytterligare datatyper

Det finns flera ytterligare datatyper som är användbara i vissa specifika fall. Dom är:

• Datum och tid: matriser för att representera datum, tid och varaktighet. datetime('now') returnerar 21-Jul-2016 16:30:16 .

• Kategoriska arrayer: det är datatyp för att lagra data med värden från en uppsättning diskreta kategorier. Användbar för att lagra nolltaliga data (minneeffektivt). Kan användas i en tabell för att välja grupper av rader.

  a = categorical({'a' 'b' 'c'});
  

• Kartbehållare är en datastruktur som har unik förmåga att indexera inte bara genom några skalbara numeriska värden utan teckenvektor. Index för elementen på en karta kallas nycklar. Dessa nycklar, tillsammans med de datavärden som är associerade med dem, lagras på kartan.

• Tidsserier är datavektorer som samlas in över tid, i ordning, ofta med regelbundna intervall. Det är användbart att lagra data som är kopplade till tidssteg och det har många användbara metoder att arbeta med.

Anonyma funktioner och funktionshandtag

Grunderna

Anonyma funktioner är ett kraftfullt verktyg på MATLAB-språket. Det är funktioner som finns lokalt, det vill säga: i det aktuella arbetsområdet. De finns emellertid inte på MATLAB-vägen som en vanlig funktion, t.ex. i en m-fil. Det är därför de kallas anonyma, även om de kan ha ett namn som en variabel i arbetsområdet.

@ -Operatören

Använd operatören @ att skapa anonyma funktioner och funktionshandtag. Till exempel för att skapa ett handtag till sin (sinus) och använda den som f :

>> f = @sin
f = 
    @sin

Nu är f ett handtag för sin . Precis som (i verkligheten) ett dörrhandtag är ett sätt att använda en dörr, är ett funktionshandtag ett sätt att använda en funktion. För att använda f överförs argument till det som om det var sin :

>> f(pi/2)
ans =
     1

f accepterar alla inmatningsargument som sin accepterar. Om sin skulle vara en funktion som accepterar noll inmatningsargument (vilket den inte gör, men andra gör, t.ex. peaks ), skulle f() användas för att kalla det utan inmatningsargument.

Anpassade anonyma funktioner

Anonyma funktioner för en variabel

Det är uppenbart inte användbart att skapa ett handtag till en befintlig funktion, som sin i exemplet ovan. Det är lite överflödigt i det exemplet. Det är dock användbart att skapa anonyma funktioner som gör anpassade saker som annars skulle behöva upprepas flera gånger eller skapa en separat funktion för. Som ett exempel på en anpassad anonym funktion som accepterar en variabel som sin ingång, summera sinus och kosinus kvadrat för en signal:

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

Nu accepterar f ett inmatningsargument som heter x . Detta specificerades med hjälp av parenteser (...) direkt efter operatören @ . f nu är en anonym funktion av x : f(x) . Det används genom att överföra ett värde av x till f :

>> f(pi)
ans =
    1.0000

En vektor med värden eller en variabel kan också överföras till f , så länge de används på ett giltigt sätt inom 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

Anonyma funktioner med mer än en variabel

På samma sätt kan anonyma funktioner skapas för att acceptera mer än en variabel. Ett exempel på en anonym funktion som accepterar tre variabler:

>> 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

Parametera anonyma funktioner

Variabler i arbetsområdet kan användas inom definitionen av anonyma funktioner. Detta kallas parameterisering. För att använda en konstant c = 2 i en anonym funktion:

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

f(3) använde variabeln c som en parameter för att multiplicera med den medföljande x . Observera att om värdet på c är inställt på något annat vid denna punkt, då f(3) kallas, skulle resultatet inte bli annorlunda. Värdet på c är värdet vid skapandet av den anonyma funktionen:

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

Inmatningsargument till en anonym funktion hänvisar inte till arbetsyta variabler

Observera att använda namnet variabler på arbetsytan som en av ingångs argument en anonym funktion (dvs använda @(...) ) kommer inte att använda dessa variabler värderingar. Istället behandlas de som olika variabler inom ramen för den anonyma funktionen, det vill säga: den anonyma funktionen har sitt privata arbetsområde där ingångsvariablerna aldrig refererar till variablerna från huvudarbetsområdet. Det huvudsakliga arbetsområdet och den anonyma funktionens arbetsyta vet inte om varandras innehåll. Ett exempel för att illustrera detta:

>> 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

Värdet på x från det huvudsakliga arbetsområdet används inte inom f . I huvudområdet var x orörd. Inom ramen för f är variabelnamnen mellan parenteser efter operatören @ oberoende av de huvudsakliga arbetsytvariablerna.

Anonyma funktioner lagras i variabler

En anonym funktion (eller mer precist, funktionshandtaget som pekar på en anonym funktion) lagras som något annat värde i det aktuella arbetsområdet: I en variabel (som vi gjorde ovan), i en celluppsättning ( {@(x)x.^2,@(x)x+1} ), eller till och med i en egenskap (som h.ButtonDownFcn för interaktiv grafik). Detta betyder att den anonyma funktionen kan behandlas som alla andra värden. När du lagrar den i en variabel har den ett namn i det aktuella arbetsområdet och kan ändras och rensas precis som variabler som innehåller nummer.

Sagt på ett annat sätt: Ett funktionshandtag (vare sig det är i @sin formen eller för en anonym funktion) är helt enkelt ett värde som kan lagras i en variabel, precis som en numerisk matris kan vara.

Avancerad användning

Vidarebefordra funktion hanterar till andra funktioner

Eftersom funktionshandtag behandlas som variabler kan de överföras till funktioner som accepterar funktionshandtag som inmatningsargument.

Ett exempel: En funktion skapas i en m-fil som accepterar ett funktionshandtag och ett skalartal. Den ringer sedan till funktionshandtaget genom att skicka 3 till det och lägger sedan till det skalära numret till resultatet. Resultatet returneras.

Innehållet i funHandleDemo.m :

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

Spara den någonstans på banan, t.ex. i MATLABs nuvarande mapp. Nu kan funHandleDemo användas enligt följande, till exempel:

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

Handtaget för en annan befintlig funktion kan skickas till funHandleDemo :

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

Lägg märke till hur @sin var ett snabbt sätt att få åtkomst till sin utan att först lagra den i en variabel med f = @sin .

Använda bsxfun , cellfun och liknande funktioner med anonyma funktioner

MATLAB har några inbyggda funktioner som accepterar anonyma funktioner som input. Detta är ett sätt att utföra många beräkningar med ett minimalt antal kodrader. Till exempel bsxfun , som utför binära operationer element-för-element, det vill säga: den tillämpar en funktion på två vektorer eller matriser på ett element-för-element-sätt. Normalt skulle detta kräva användning av for -loops, som ofta kräver preallocation för hastighet. Med hjälp av bsxfun denna process. Följande exempel illustrerar detta med hjälp av tic och toc , två funktioner som kan användas för att ställa in hur lång tid kod tar. Den beräknar skillnaden för varje matriselement från matriskolumnens medelvärde.

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

Att köra exemplet ovan resulterar i två utgångar:

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

Dessa rader kommer från toc funktionerna, som skriver ut den förflutna tiden sedan det senaste samtalet till tic funktionen.

bsxfun samtalet tillämpar funktionen i det första inmatningsargumentet på de andra två inmatningsargumenten. @minus är ett långt namn på samma operation som minustecknet skulle göra. En annan anonym funktion eller handtag ( @ ) än någon annan funktion kunde ha specificerats, så länge den accepterar A och mean(A) som ingångar för att generera ett meningsfullt resultat.

Speciellt för stora mängder data i stora matriser kan bsxfun påskynda saker mycket. Det gör också att koden ser renare ut, även om det kan vara svårare att tolka för personer som inte känner till MATLAB eller bsxfun . (Observera att i MATLAB R2016a och senare, många operationer som tidigare använde bsxfun inte längre behöver dem; A-mean(A) fungerar direkt och kan i vissa fall vara ännu snabbare.)