Środowisko MATLAB-a rozwijało się w wielu kierunkach. Oprogramowanie, którego głównym celem było początkowo ułatwienie dostępu do bibliotek procedur numerycznych algebry macierzowej LINPACK i EISPACK, dzięki konsekwentnej rozbudowie zarówno w zakresie podstaw informatycznych, jak i funkcji zorientowanych na określone typy problemów, jest dziś wykorzystywane na bardzo różne sposoby w odległych nieraz dziedzinach zastosowań.

dziedziny zastosowań :

*Obliczenia matematyczne

ponad 500 funkcji w MATLAB-ie realizujących podstawowe algorytmy numeryczne, operacje na macierzach, wielomianach, metody interpolacji i aproksymacji,  transformacje Fouriera, algorytmy całkowania równań różniczkowych i wiele innych

implementacja specjalizowanych algorytmów dla macierzy rzadkich (sparse matrices)

standardowe metody numeryczne - NAG Foundation Toolbox

procedury optymalizacji - Optimization Toolbox

metody statystyki matematycznej wraz z interaktywnym interfejsem graficznym - Statistics Toolbox

całkowanie numeryczne równań różniczkowych cząstkowych - Partial Differential Equation (PDE) Toolbox

interpolacja sklejana - Spline Toolbox

efektywne algorytmy manipulacji na wyrażeniach symbolicznych z jądra pakietu Maple V - Symbolic Math Toolboxes (różniczkowanie i całkowanie symboliczne, podstawianie, upraszczanie i rozwijanie wyrażeń, działania na szeregach formalnych, symboliczne rozwiązywanie równań algebraicznych i różniczkowych, algorytmy kombinatoryczne i wiele innych)

*Grafika komputerowa i wizualizacja

szeroki zestaw procedur graficznych w MATLAB-ie obejmujący: generację wykresów funkcji 1 i 2 zmiennych, wykresów kołowych, paskowych, konturowych, cieniowanych i wielu innych, wizualizację odwzorowań 2- i 3-wymiarowych (izolinie i izopowierzchnie, pola kierunków), animację, map bitowych, obiektów wielokątnych i wielościennych

generacja kodu OpenGL dla akceleratorów sprzętowych

bogate ośrodki opisu tekstowego, definiowanie różnych czcionek, symboli specjalnych, strzałek itp.

specjalizowane procedury komputerowej analizy i przetwarzania obrazów w module Image Processing Toolbox

specjalizowane procedury kartograficznej wizualizacji danych w module Mapping Toolbox

*Prototypowanie algorytmów

bogate biblioteki algorytmów standardowych w MATLAB-ie i procedur specjalizowanych w modułach rozszerzeń (MATLAB Application Toolboxes i Simulink Blocksets)

zintegrowane narzędzia rozwijania oprogramowania w języku MATLAB-a (m-kodu) - MATLAB Editor/Debugger - wyposażone we własny interfejs graficzny

MATLAB Profiler - narzędzie monitorowania czasów wykonania poszczególnych segmentów m-kodu z możliwością generowania raportów w formacie HTML

MATLAB Workspace Browser - przeglądarka przestrzeni roboczej MATLAB-a z podglądem warto¶ci i możliwością edytowania wartości zmiennych, w tym tablic

*Programowanie i tworzenie aplikacji

¶środowisko GUIDE umożliwia projektowanie i implementację własnych interfejsów graficznych do aplikacji MATLAB-a w oparciu o elementy aktywne grafiki uchwytów (Handle Graphics) i technikę wywołań zwrotnych (callbacks)

Kompilator MATLAB-a - MATLAB Compiler, na podstawie kodu MATLAB-a generuje kod C lub C++ zgodny ze standardem ANSI

MATLAB C  Math Library - około 300 funkcji wbudowanych MATLAB-a, w postaci binarnej, do wł±czania do wygenerowanych za pomocą kompilatora MATLAB-a lub własnych aplikacji użytkownika

MATLAB C++  Math Library - około 300 funkcji wbudowanych MATLAB-a, w postaci binarnej, do włączania do wygenerowanych za pomocą kompilatora MATLAB-a lub własnych aplikacji użytkownika, składnia wywoływań zbliżona do oryginalnej składni MATLAB-a

MATLAB Runtime Server - umożliwia tworzenie i rozpowszechnianie niezależnych aplikacji MATLAB-a

udostępnianie aplikacji MATLAB-a poprzez Internet - MATLAB Web Server

MATLAB Report Generator i Simulink Report Generator - automatyczna generacja raportów wybranym formacie, np.: HTML, RTF, XML lub SGML

*Analiza danych

funkcje manipulacji na zbiorach danych w środowisku MATLAB-a - interpolacja, ekstrapolacja, decymacja, skalowanie, wygładzanie, filtracja, wybór podzbiorów danych za pomoc± warunków logicznych i inne

standardowe i zaawansowane procedury analizy statystycznej wraz z wizualizacją±  - Statistics Toolbox

wszechstronne narzędzia analizy i przetwarzania sygnałów (modele liniowe) w module Signal Processing Toolbox, eksploaracja za pomocą przeglądarki Signal Browser, projektowanie filtrów - interfejsy graficzne: Filter Designer i Filter Viewer, analiza widmowa - interfejs graficzny: Spectrum Viewer

zaawansowane metody analizy sygnałów: analiza falkowa - Wavelet Toolbox, widma wyższego rzędu - Higher Order Spectral Analysis Toolbox

Excel Link - moduł udostępniający funkcje MATLAB-a w pakiecie Microsoft Excel

zestaw funkcji realizujących zaawansowane algorytmy analizy danych finansowych (m. in. zarządzanie ryzykiem) - Financial Toolbox

dwustronna komunikacja z bazami danymi za pomoc± protokołu ODBC/JDBC - Database Toolbox

*Modelowanie i symulacja

modelowanie procesów fizyko-chemicznych na podstawie danych pomiarowych (szeregów czasowych) - moduł System Identification Toolbox, oraz w dziedzinie częstotliwości - moduł Frequency Domain Identification Toolbox

biblioteka procedur modelowania wykorzystującego sieci neuronowe - Neural Network Toolbox

biblioteka procedur modelowania wykorzystującego logikę rozmytą - Fuzzy Logic Toolbox

modelowanie i analiza procesów stochastycznych - moduł Statistics Toolbox

interaktywna symulacja ciągłych, dyskretnych i mieszanych procesów dynamicznych zadanych w postaci hierarchicznych schematów blokowych - Simulink

Stateflow - zintegrowane z Simulinkiem środowisko symulacji procesów ze zdarzeniami i systemów reaktywnych z wykorzystaniem reprezentacji graficznej w postaci diagramów stanu (state charts)

Power System Blockset - biblioteka specjalizowanych bloków Simulinka do symulacji sieci elektroenergetycznych, układów elektroniki przemysłowej, maszyn elektrycznych, układów pomiarowych (modele dla prądu stałego, zmiennego, układów trójfazowych)

automatyczna generacja kodu C do przyspieszonej symulacji lub niezależnego lub współbieżnego wykonania na zewnętrznym komputerze (także zdalnym) - Real Time Workshop, RTW Ada Coder i Stateflow Coder

*Projektowanie układów sterowania

przyspieszenie projektowania przez integrację: symulacji wykorzystującej schematy blokowe - Simulink, projektowania warstwy logicznej sterowników - Stateflow, automatycznej generacji kodu - Real-Time Workshop i Stateflow Coder oraz specjalizowanych procedur zawartych w modułach rozszerzeń np. Control System Toolbox, Fuzzy Logic Toolbox, Neural Network Toolbox i in.

biblioteka standardowych procedur analizy i syntezy układów sterowania - Control System Toolbox wraz z interaktywnymi interfejsami np. za pomocą przeglądarki modeli liniowych - LTI Viewer, czy narzędzia do syntezy metod± linii pierwiastkowych - Root Locus Design Tool

biblioteki zaawansowanych procedur projektowania układów sterowania: Robust Control Toolbox, mu-Analysis and Synthesis Toolbox, Model Predictive Control Toolbox, LMI (Linear Matrix Inequality) Control Toolbox, QFT (Quantitative Feedback Theory) Control Toolbox

Nonlinear Control Design Blockset - rozszerzenie Simulinka umożliwiające optymalizację przebiegów przejściowych w przestrzeni parametrów modelowanego układu sterowania

narzędzia szybkiego protytopowania sterowników i symulacji w czasie rzeczywistym wykorzystujące platformę PC - Real-Time Windows Target, lub skrajne architektury projektowania - VxWorks/Tornado i dSPACE

*Projektowanie aplikacji dla procesorów sygnałowych (DSP)

przyspieszenie projektowania przez integrację: symulacji wykorzystującej schematy blokowe w Simulinku, automatycznej generacji kodu za pomoc± Real-Time Workshop i algorytmów z modułów zorientowanych na określone dziedziny zastosowań, zwłaszcza Signal Processing Toolbox

biblioteki specjalizowanych bloków Simulinka - DSP Blockset i Fixed Point Blockset

modele zorientowane na zastosowania w telekomunikacji w module Communications Toolbox

Wprowadzenie do pracy w środowisku pakietu Matlab

MATLAB - program przeznaczony do wykonywania różnorodnych obliczeń numerycznych. Dostępny na różnych platformach sprzętowych oraz systemowych (DOS, Windows, UNIX).

Elementy pakietu MATLAB:

	interpreter języka programowania wraz z bibliotekami podstawowych działań i obliczeń na macierzach (odwracanie macierzy, rozkłady macierzy, wartości własne itp.);
	standardowe biblioteki procedur napisanych w języku programu MATLAB (procedury realizujące przekształcenia macierzy, obliczanie wartości funkcji elemnetarnych i specjalnych, całkowanie numeryczne, rozwiązywanie układów równań różniczkowych zwyczajnych, podstawowe obliczenia statystyczne);
	biblioteki dodatkowe zawierające procedury wspomagające obliczenia numeryczne w różnych stosowaniach Processing Toolbox - cyfrowe przetwarzanie sygnału, Control Toolbox - projektowanie układów sterowania, Optimization Toolbox - metody optymalizacji,Neural networks Toolbox - sieci neuronowe itp.);
	nakładki - dodatkowe programy napisane w języku MATLAB, które ułatwiają realizację obliczeń określonego rodzaju; (np.Simulink- umożliwia definiowanie i symulację układu sterowania);

  

MATLAB a jego otoczenie:

Organizacja pracy w oknie poleceń MATLAB-a:
clc	wyczyszczenie okna poleceń i umieszczenie kursora w jego lewym górnym rogu
home	umieszczenie wiersza poleceń i kursora w lewym górnym rogu okna poleceń
format	określa postać wyświetlania liczb na ekranie
echo on/off	włączają/wyłączają wysyłanie na ekran treści wykonywanych poleceń
more on/off	włącza/wyłącza stronicowanie tekstów wysyłanych na ekran
diary 'nazwa pliku'	polecenia i teksty (bez grafiki) wysyłane na ekran będą zapisywane w pliku o podanej nazwie
Polecenia plikowe i systemowe:
clock	podaje aktualną datę i czas w postaci wektora [rok miesiąc dzień godzina minuta sekunda]
path	modyfikuje ścieżki dostępu do żądanych katalogów
dir, ls	wyświetlenie plików w aktualnym lub podanym katalogu (dozwolone użycie znaków masek: *,?)
cd nazwa_katalogu	zmiana aktualnego katalogu
del nazwa_ pliku	usunięcie pliku o podanej nazwie
pwd	wyświetlenie pełnej ścieżki określającej aktualny katalog
Zapis i odczyt danych:
save	zapisanie zmiennych w pliku matlab.mat
load	wczytanie zmiennych z pliku matlab.mat
Zarządzanie pamięcią:
clear	usunięcie z pamięci podanych obiektów
pack	przeprowadzenie defragmentacji pamięci
who	wyświetlenie nazw zmiennych lokalnych znajdujących się pamięci
whos	wyświetlenie listy zmiennych lokalnych wraz z dodatkowymi informacjami na ich temat

Najczęściej wykorzystywane polecenia pakietu Matlab:

UWAGI:

• Jeśli nie została wskazana inna zmienna to wynik operacji przechowywany jest w standardowej zmiennej pakietu ans.

• Średnik po poleceniu powoduje, że wartość będąca wynikiem jego wykonania nie będzie wyświetlana na ekranie.

• Większe fragmenty programów umieszcza się w zbiorach tekstowych zwanych skryptami ( standardowe rozszerzenie m.)

a=4.3467	utworzenie zmiennej a o wartości 3.1459
sin(a)	obliczenie wartości funkcji sinus dla zmiennej a i wyświetlenie jej na ekranie
A=[1 2 3;1 0 9;8 8 7] lub  A=[1 2 3 1 0 9 8 8 7]	zdefiniowanie macierzy stopnia trzeciego
A^(-1) lub inv(A)	obliczenie i wyprowadzenie na ekran odwrotności macierzy A
c=[3;4;6] lub c=[3 4 6]'	zdefiniowanie macierzy kolumnowej
b=[2 0 7]	zdefiniowanie wektora wierszowego
!polecenie systemu	wykonanie polecenia systemu operacyjnego
help nazwa_polecenia	odwołanie się do podręcznej pomocy na temat polecenia

Liczby i wyrażenia arytmetyczne:

Przykłady poprawnego zapisu liczb w pakiecie Matlab:

1	-93	9.3456787	1.98763E-20
5.62413e23	2i	-3.14159i	3e5i

Zakres wartości liczb dodatnich na komputerach klasy PC określa przedział: (10^-308 ; 10³⁰⁸).
Dokładne wartości zakresu w zależności od różnych platform sprzętowych określane są za pomocą funkcji realmin i realmax.

Wartości specjalne pakietu Matlab:

Funkcja	Opis
[+,-] Inf	nieskończoność (ang.infinity). Jest rezultatem operacji, która przekracza z góry (+) lub z dołu (-) zakres arytmetyki komputera - np. 10/0
NaN	nie liczba (ang. Not a Number).Jest wynikiem matematycznie niezdefiniowanych operacji - np. Inf/Inf lub 0/0, dzięki temu podejściu dzielenie przez zero nie prowadzi do przerwania operacji, lecz wyświetlany jest odpowiedni komunikat a zmiennej nadawana jest wartość specjalna
pi	Daje w wyniku liczbę zmiennoprzecinkową najbliższą wartości zmiennej ¶
eps	względna dokładność zmiennoprzecinkowa (eps = 2.22e-16)

 Liczby i macierze zespolone oraz operatory:

Tworzenie liczb zespolonych:	Tworzenie macierzy zespolonych:
z = 3 + 4*j z = 4*i + 2 w = r*exp(i*theta) ii=sqrt(-1) z=3 + r*ii	A = [1 2;3 4] + i*[5 6;7 8] lub A = [1+5i  2+6i ; 3+7i  4+8i]

Dostępne operatory porównania:

Wyrażenie w Matlabie:	Relacja:
a == b a ~= b a < b a > b a <= b a >= b	a = b a jest różne od b a < b a > b a jest mniejsze lub równe b a jest większe lub równe b

Dostępne operatory logiczne:

Operator:	Funkcja logiczna:
a | b a & b ~ a	alternatywa koniunkcja negacja	a lub b a i b nie a

Formaty liczb:

Do określania postaci liczb wyświetlanych na ekranie służy polecenia format.

Dostępne formaty liczb:

Nazwa formatu:	Reprezentacja według formatu liczy ^2/3
short	0.6667
short e	6.6667e-001
long	0.66666666666667
long e	6.666666666666666e-001
hex	3fe5555555555555 - wartość szesnastkowa
+	drukowany jest znak + dla liczb dodatnich
bank	0.67 - format walutowy (pełna część całkowita, do dwóch miejsc po przecinku
compact	wyłączenie dodawania dodatkowych pustych wierszy
loose	włączenie dodawania dodatkowych pustych wierszy
rat	^2/3 - przybliża liczbę ułamkami małych liczb całkowitych

Wybrane funkcje matematyczne:

Najważniejszą zasadą jest fakt, iż wszystkie zmienne traktowane są jako macierze (argumentem każdej funkcji jest macierz). Liczba rzeczywista traktowana jest jako macierz o wymiarze 1 x 1.

Najbardziej przydatne funkcje matematyczne:

trygonometryczne:	sin(z), cos(z), tan(z)
cyklometryczne:	asin(z), acos(z), atan(z)
hiperboliczne:	sinh(z), cosh(z), tanh(z)
odwrotne do hiperbolicznych:	asinh(z), acosh(z), atanh(z)
logatytmiczne, wykładnicze i potęgowe:	sqrt(z)	macierz pierwiastków kwadratowych elementów macierzy z
		exp(z)	macierz o elementach równych e^z
		log(z)	macierz o elementach równych logarytmom naturalnym elementów macierzy z
		log2(z)	log2 z
		log10(z)	log10 z
	funkcje argumentów zespolonych:	abs(z)	macierz modułów elementów macierzy z
		angle(z)	macierz argumentów elementów macierzy z
		real(z)	macierz części rzeczywistych elementów macierzy z
		imag(z)	macierz części urojonych elementów macierzy z
		conj(z)	macierz o elementach sprzężonych z odpowiednimi elementami macierzy z
	inne funkcje:	ceil(z)	zaokrągla w górę elementy macierzy z
		floor(z)	zaokrągla w dół elementy macierzy z
		round(z)	zaokrągla elementy macierzy z do najbliższej liczby całkowitej
		fix(z)	zaokrągla elementy macierzy z: dodatnie w dół, ujemne w górę
		rem(x,y)	oblicza resztę z dzielenia odpowiadających sobie elementów macierzy x i y według wzoru: rem(x,y) = x - ny, gdzie n=fix(x./y)
		max(x)	dla wektora zwraca jego maksymalny element, a dla macierzy zwraca wektor maksymalnych elementów z poszczególnych kolumn macierzy x
		min(x)	dla wektora zwraca jego minimalny element, a dla macierzy zwraca wektor minimalnych elementów z poszczególnych kolumn macierzy x
		sum(x)	dla wektora zwraca sumę jego ementów, a dla macierzy zwraca wektor sum elementów z poszczególnych kolumn macierzy x
		prod(x)	dla wektora zwraca iloczyn jego ementów, a dla macierzy zwraca wektor iloczynów elementów z poszczególnych kolumn macierzy x

Operacje na macierzach:

Definiowanie macierzy:

	Przykłady:
przez wymienienie elementów	A=[2 3 4 6;1 2 3 4] lub A=[2 3 4 6       1 2 3 4] B=[3 4 5 6 7 8 8 9]
przez zbudowanie z innych macierzy	mając zdefiniowane macierze: A=[1 4 1;2 0 1]; B=[3 1;4 1]; C=[1 2 2 0 1;2 4 7 1 0] po wydaniu polecenia: D=[A B;C] otrzymamy nową macierz:
przez wygenerowanie elementów wykorzystując ogólne wyrażenie: minimum:krok:maximum	wydanie polecenia: A=[1:5;1:2:9] spowoduje wygenerowanie macierzy: A=[1 2 3 4 5]       1 3 5 7 9]
przez mieszanie technik:	mając określoną macierz A=[1 2 3;4 5 6] polecenie: D=[A,[1;2];1:4] spowoduje utworzenie macierzy:
przez usuwanie wektora z macierzy	mając macierz A=[1 2 3 4; 4 5 6 7] i wydając polecenie: A=(:,4)=[] spowodujemy usunięcie 4-ej kolumny macierzy A, natomiast polecenie: A=(:,1:2)=[] usunie dwie pierwsze kolumny macierzy A

Funkcje wspomagające konstruowanie macierzy:

eye(n)	tworzy macierz jednostkową o wymiarze nxn (jedynki na przekątnej)
eye(m,n)	tworzy macierz jednostkową o wymiarze mxn np: X=eye(size(X))
ones(n)	tworzy macierz o wymiarze nxn o wszystkich elementach równych 1
ones(m,n)	tworzy macierz o wymiarze mxn o wszystkich elementach równych 1
zeros(n)	tworzy macierz o wymiarze nxn o wszystkich elementach równych 0
zeros(m,n)	tworzy macierz o wymiarze mxn o wszystkich elementach równych 0
rand(n)	tworzy macierz o wymiarze nxn wypełnioną liczbami pseudolosowymi z przedziału <0, 1>
rand(m,n)	tworzy macierz o wymiarze mxn wypełnioną liczbami pseudolosowymi z przedziału <0, 1>

Rozmiar macierzy i jego wyrównanie:

disp(A)	wysyła macierz A do okna poleceń Matlaba
[n,m]=size(A)	zwraca liczbę wierszy n i liczbę kolumn m macierzy A
n=size(A,1)	zwraca liczbę wierszy n macierzy A
m=size(A,2)	zwraca liczbę kolumn macierzy A
n=length(X)	podaje wymiar n wektora X (dla macierzy zwraca dłuższy z jej wymiarów)

Dostęp do elementów macierzy:

Mając daną macierz A=[1 2 3 4 5 6; 0 9 8 7 6 5; 1 2 0 0 2 2]
odwołania do poszczególnych elementów mają postać: x=A(2,4); y=A(3,3);
natomiast odwołania do podmacierzy wyglądają następująco:

A(1:2,1:2)	odwołanie do macierzy rozpiętej na elementach od (1,1) do (2,2) tzn. do macierzy postaci: [1 2; 0 9]
A(2,1:6) lub A(2,:)	odwołanie do drugiego wiersza macierzy A
A([1 3].:)	odwołanie do 1 i 3 wiersza macierzy A
A(:,[1:3 5])	odwołanie do kolumn 1, 2, 3 i 5 macierzy A
A([1 3],1:2:5)	utworzenie macierzy z elementów leżących na przecięciu wierszy 1 i 3 z kolumnami 1,3 i 5

Operatory macierzowe i tablicowe: Niech będą dane macierze:



Efekty działania operatorów macierzowych i tablicowych:

Operatory	macierzowe	tablicowe
dodawanie		analogicznie
odejmowanie		analogicznie
mnożenie
dzielenie	-
potęgowanie
transpozycja		-

Przy mnożeniu macierzowym macierzy należy pamiętać aby liczba kolumn pierwszej z nich była równa liczbie wierszy drugiej, ponieważ w przeciwnym wypadku mnożenie nie jest wykonalne i pojawi się komunikat o błędzie.

Funkcje przekształcające macierze:

Y=rot90(X)	obrócenie macierzy X o 90º w kierunku przeciwnym do ruchu wskazówek zegara.
Y=reshape(X,n,m)	utworzenie macierzy Y o n wierszach i m kolumnach z elementów branych kolejno kolumnami z macierzy X. Jeśli X nie zawiera mxn elementów to pojawia się komunikat o błędzie.

Łańcuchy:

Każdy łańcuch przechowywany jest w pamięci jako wektor liczb zmiennoprzecinkowych o wartościach całkowitych będących kodami ASCI poszczególnych jego znaków.
Do podstawowych operacji na łańcuchach należą następujące polecenia:

s='Matlab'	zdefiniowanie łańcucha o nazwie s
blanks(n)	utworzenie łańcucha składającego się z n znaków spacji
size(s)	podanie rozmiaru łańcucha s; wynikiem tego polecenia będzie: ans=         1 6 czyli 6 znaków (Matlab) w 1 wierszu
disp(s)	wyświetlenie łańcucha s
input	pobranie wartości od użytkownika np. f=input('Podaj nazwę pliku z danymi:','s') powoduje zapamiętanie w zmiennej f łańcucha znaków pobranego od użytkownika

Programowanie w Matlabie - instrukcje, m-skrypty, funkcje

Instrukcje:

	Instrukcja warunkowa: pierwsza postać: if wyrażenie       ciąg instrukcji end	druga postać: if wyrażenie_warunkowe1        ciąg_instrukcji1 elseif wyrażenie_warunkowe2        ciąg_instrukcji2 else        ciąg_instrukcji3 end
	Instrukcja for: for zmienna_iterowana=macierz_warości        ciąg_instrukcji end W praktyce macierz_wartości ma jedną z postaci: wartość_początkowa : wartość_końcowa wartość_początkowa : krok : wartość_końcowa Zmienna krok może być zarówno dodatnia jak i ujemna, natomiast zmienna_iterowana nie musi przyjmować wartości całokowitych.
	Instrukcja while: while wyrażenie_warunkowe              ciąg_instrukcji end Ciąg instrukcji jest wykonywany, aż wyrażenie_warunkowe przyjmie wartość prawda.
	Instrukcja break powoduje przerwanie wykonywania pętli, przy czym opuszczany jest tylko jeden poziom zagłębienia pętli.
	Instrukcja return powoduje bezwarunkowe opuszczenie danej funkcji lub m-skryptu i powrót do miejsca wywołania.

If

 Utworzyć macierz a o elementach określonych wzorem:


przy założeniu, że wcześniej określono wymiar macierzy a.

Rozwiązanie:

if i  = =  j
    a(i,j) = 2;
elseif abs(i-j)  = =  1
        a(i,j) = -1;
    else
        a(i,j) = 0;
end

for

Utworzyć macierz A o wymiarze 5x4 taką, że:



Rozwiązanie:

n = 5;
m = 4;
for i = 1:n,
    for j = 1:m,
        a(i,j) = 1/(i+j-1);
    end
end

while

Zrealizować iterację postaci x_n+1=Ax_n , aż do momentu gdy norma wektora x będzie mniejsza lub równa 1 lub przekroczona zostanie maksymalna liczba iteracji.

Rozwiązanie:

a = [0.775 -0.05; 0.0625 0.925];
x=[100 200]'
maxn = 1;
maxit = 100;
n = 0;
while (norm(x)>maxn & n<maxit),
    x = a * x;
    n = n + 1;
end

 M - skrypty:

M-skrypt jest zbiorem tekstowym o rozszerzeniu .m zawierającym polecenia i instrukcje Matlaba. Może on być utworzony w dowolnym edytorze plików tekstowych. Komentarze w m-skrypcie poprzedza się znakiem %. Istnieje możliwość tworzenia helpów (objaśnień) do własnych m-skryptów. Polega to na umieszczeniu komentarzy w pierwszych liniach m-skryptu. Objaśnienie zostanie wyświetlone na ekranie po wywołaniu polecenia: help nazwa_m-skryptu.

 M-skrypty:
Przykład 1

Napisać m-sktypt, który w określonych punktach oblicza wartości funkcji x=sin(2t)+sin(t), a następnie kreśli wykres tej funkcji w przedziale <0; 2pi>. M-skrypt zachować w pliku p1.m.

%Przykładowy m-skrypt1
%Rysowanie wykresu funkcji x=sin(2t)+sin(t)
t=[0:0.01:2*pi]    %utworzenie wektora t o wartościach od 0 do 2*pi co 0,01
A=[1 1]                %tworzymy pomocniczy wektor A
x=A*[sin(2*t); sin(t)]    %obliczenie wartości funkcji jako iloczyn dwóch wektorów
%prawidłowe byłoby również podstawienie bezpośrednie:
%x=sin(2*t)+sin(t)
plot(t,x)    %narysowanie wykresu funkcji
%koniec przykładowego m-skryptu

Wywołaniem powyższego skryptu będzie po prostu:
p1
natomiast wynikiem działania będzie okno graficzne z wykresem funkcji x=sin(2t)+sin(t) w przedziale <0; 2*pi>,
z kolei polecenie
help p1
wyświetli informację:
Przykładowy m-skrypt1
Rysowanie wykresu funkcji x=sin(2t)+sin(t)

Przykład 2

Napisać m-skrypt z komentarzem wczytujący dwie liczby a i b, oraz obliczający wartość wyrażenia: sin(a)*cos(b).

%Przykładowy m-skrypt2
%Obliczenie wyrażenia sin(a)*cos(b)
%gdzie a i b są wczytanymi liczbami.
a=input('Podaj liczbę a:')    %przypisanie zmiennej a wartości podanej przez użytkownika
b=input('Podaj liczbę b:')    %przypisanie zmiennej b wartości podanej przez użytkownika
disp('Wartość wyrażenia sin(a)*cos(b) wynosi : ')    %wyświetlenia komunikatu
sin(a)*cos(b)    %wypisanie wartości wyrażenia
%wyświetlanie wyniku może być również uzyskane przez: disp(sin(a)*cos(b))

M-skrypt nie posiada mechanizmu hermetyzacji, tzn. dane utworzone w m-skrypcie zostaną dołączone do danych już instniejących.

 

Funkcje:

Matlab umożliwia tworzenie własnych funkcji. Ich definicję umieszcza się w pliku o nazwie identycznej z nazwą funkcji i o rozszerzeniu .m (m-skrypcie). Ogólna postać funkcji wygląda następująco:

function [wartość_funkcji1, wartość_funkcji2, ...] = nazwa_funkcji(parametr1, parametr2, ...)
%opis funkcji w formie komentarza
ciąg instrukcji

Funkcje:
Przykład 1

Zdefiniować funkcję f1, która oblicza średnią arytmetyczną i geometryczną ciągu o elementach umieszczonych w wektorze x.

function [sreda, sredg] = f1(x)
%wynikiem działania funkcji o jednym argumencie w postaci
%wektora x, są dwie wartości sreda i sredg
%funkcja musi być zachowana w pliku o nazwie funkcji czyli f1.m
    n=length(x);    %wyznaczenie długości wektora x
    serda=sum(x)/n;    %polecenia sum(x) oblicza sumę elementów wektora x
    sredg=(prod(x))^(1/n);    %polecenie prod(x) oblicza iloczyn elementów wektora x
%koniec funcji

Jeżeli np. x=[2 8] to wywołanie funkcji f1 może mieć postać:
[a g]=f1(x)
a wynikiem działania będzie:
a =
     5
g =
     4

Polecenia help f1 wyświetli informację:
wynikiem działania funkcji o jednym argumencie w postaci
wektora x, są dwie wartości sreda i sredg
funkcja musi być zachowana w pliku o nazwie funkcji czyli f1.m


Przykład 2

Zdefiniować funkcję funkw, która oblicza wartości funkcji kwadratowej w przedziale [-10; 10].

function y = funkw(x)
%wynikiem działania funkcji o jednym argumencie w postaci
%wektora x, jest wektor wartości funkcji kwadratowej
%funkcja musi być zachowana w pliku o nazwie funkcji czyli funkw.m
global a b c    %zadeklarowanie parametrów funkcji jako zmiennych globalnych tzn. widocznych dla wszystkich skryptów
y = a.* x.* x + b.* x + c    %obliczenie wartości funkcji dla każdego argumentu
%koniec funcji

Wykorzystanie funkcji w innym m-skrypcie może mieć postać:

%początek m-skryptu obliczającego warości
%funkcji kwadratowej y = x^2 + 2*x + 3*x
%w przedziale [-10; 10]
global a b c    %zadeklarowanie parametrów funkcji jako zmiennych globalnych tzn. widocznych dla wszystkich skryptów
a=1;    %przypisanie wartości parametrowi funkcji 
b=2;    %przypisanie wartości parametrowi funkcji 
c=3;    %przypisanie wartości parametrowi funkcji 
x=[-10:0.1:10];    %zdyskteryzowanie przedziału od -10 do 10 co 0,1
y=funkw(x);    %wywołanie funkcji funkw
%koniec m-skryptu

Polecenia help funkw wyświetli informację:
wynikiem działania funkcji o jednym argumencie w postaci
wektora x, jest wektor wartości funkcji kwadratowej
funkcja musi być zachowana w pliku o nazwie funkcji czyli funkw.m

Funkcje posiadają mechanizm hermetyzacji, tzn. dane utworzone w funkcji nie  zostaną dołączone do danych już istniejących.
Należy zwrócić uwagę na fakt, iż komentarze w funkcjach umieszcza się rozpoczynając od drugiej linijki (po nagłówku funkcji), a nie od pierwszej tak jak w przypadku m-skryptu.

Zmienne globalne i lokalne:

Zmienne utworzone w trakcie wykonywania funkcji są zmiennymi lokalnymi.
 Zmienne utworzone w m-skryptach (nie zawierających definicji funkcji) i w bezpośrednich poleceniach są przechowywane we wspólnym obszarze pamięci ale nie są dostępne w ciele funkcji.
Umieszczenie polecenia global A B C powoduje, że zmienne A,B, C są traktowane jako globalne.
Powtórzenie tego samego polecenia w funkcji powoduje, że są one dostępne także w tej funkcji.

Przykład

Napisać funkcję f2.m, która dla danych x, y, z oblicza wartość wyrażenia: w=a*x + b*y + c*z. Funkcję wykorzystać w m-skrypcie obliczw.m do obliczenia wartości w dla x, y, z zmieniających się jednostajnie w przedziale [-2; 2]. Wartości parametrów a, b, c należy zadeklarować w m-skrypcie plik.m (np. a=-1; b=1; c=3).

Zawartość każdego z plików może mieć postać:

plik f2.m	plik obliczw.m
function w=f2(x,y,z) global a b c; w=a*x+b*y+c*z	global a b c; a=-1; b=1; c=3; x=[-2:2]; y=[-2;2] z=[-2:2] w=f2(x,y,z)

  

Parametry funkcyjne:

Polecenie feval(nazwa_funkcji,x1,...,xn) oblicza wartość funkcji o nazwie określonej łańcuchem znakowym dla argumentów x1,...,xn.
Pierwszy parametr może określać zarówno standardową funkcję Matlab'a (np. sqrt) jak i dowolną funkcję napisaną przez użtkownika.

Przykłady:

	Wyrażenia: y=feval('exp',10) i y=exp(10) są równoważne.
	Obliczyć wartości funkcji sin(x) w zadanych punktach z przedziału [0; 2*pi]: y=feval('sin',[0:0.01:2*pi]
	Obliczyć średnią geometryczną i arytmetyczną ciągu x=[1 5 7 10] wykorzystując funkcję f1 z przykładu 1 w rozdziale Funkcje. x=[1 5 7 10]; [sra,srg]=feval('f1',x);

Z przykładu 1 :

  function [sreda, sredg] = f1(x)
%wynikiem działania funkcji o jednym argumencie w postaci
%wektora x, są dwie wartości sreda i sredg
%funkcja musi być zachowana w pliku o nazwie funkcji czyli f1.m
    n=length(x);    %wyznaczenie długości wektora x
    serda=sum(x)/n;    %polecenia sum(x) oblicza sumę elementów wektora x
    sredg=(prod(x))^(1/n);    %polecenie prod(x) oblicza iloczyn elementów wektora x
%koniec funcji

Wczytywanie danych i wyświetlanie wyników:

Najczęściej wykorzystywane polecenia:

a = input ('Podaj wartość a=')	przypisanie zmiennej a wartości podanej przez użytkownika
f1 = input ('Podaj nazwę pliku:','s');	zapamiętanie w zmiennej f1 łańcucha znaków podanego przez użytkownika. Parametr 's' informuje, że wprowadzona informacje jest traktowana jako łańcuch znaków i nie podlega przetwarzaniu numerycznemu przez interpreter poleceń Matlaba
disp (A)	wyświetlenie zawartości tablicy A
disp ('Komunikat')	wyświetlenie tekstu podanego w apostrofach, np.: disp('Wartość wyrażenia wynosi: '), disp(x)

Operacje na plikach w pakiecie Matlab

 Funkcje I/O pozwalają czytać dane zapisane w innym formacie lub zapisywać dane generowane przez MATLABa w żądanym formacie. Funkcje I/O MATLABa są oparte na funkcjach I/O z języka C.

 Otwieranie i zamykanie plików:

Przed przystąpieniem do zapisu lub odczytu danych należy otworzyć plik za pomocą komendy fopen z parametrami:

pl = fopen('pen.dat', 'r')	otwarcie pliku do odczytu (jeśli operacja otwarcia powiodła się to zmiennej pl przyporządkowany zostanie plik pen.dat, jeśli nie to pl = -1
[pl, inf] = fopen('pen.dat', 'r')	jeśli pl = -1 to inf jest łańcuchem znaków: np. No such file or directory.

W poleceniu fopen można stosować następujące parametry:

'r'	otwarcie pliku do odczytu
'w'	otwarcie pliku do zapisu
'a'	otwarcie pliku w celu dopisywania elementów
'r+'	otwarcie pliku do odczytu i zapisu

Po zakończeniu operacji na pliku należy go zamknąć za pomocą polecenia fclose, np.

status = fclose(pl)	zamknięcie pliku skojarzonego ze zmienną pl
status = fclose('all')	zamknięcie wszyskich otwartych plików

  Pliki binarne:

Do odczytywania plików binarnych służy polecenie fread np:

pl = fopen('pen.dat','r'); A = fread(pl); status = fclose(pl);	wczytanie wszystkich danych z pliku pen.dat do macierzy A
pl = fopen('pen.dat','r'); A = fread(pl,100); status = fclose(pl);	wczytanie pierwszych stu wartości z pliku pen.dat do wektora kolumnowego A
pl = fopen('pen.dat','r'); A = fread(pl,[10,10]); status = fclose(pl);	wczytanie pierwszych stu wartości z pliku pen.dat do macierzy A o wymiarze 10x10

 Sposoby interpretacji wczytywanych danych w zależności od parametru polecenia fread:

'char'	typ znakowy (8 bitów)
'short' lub 'long'	typ całkowity (16 lub 32 bity)
'float' lub 'double'	typ rzeczywisty (32 lub 64 bity)

np. polecenie:
A = fread(pl,10,'float) - wczyta 10 liczb rzeczywistych do wektora kolumnowego A

W celu zapisania danych do pliku binarnego należy skorzystać z polecenia fwrite, np.:

plzap = fopen('p1.bin','w'); licz = fwrite(plzap,eye(5),'long'); status = fclose(plzap);

stworzenie 100 bajtowego binarnego pliku p1.bin, który zawiera 25 elementów macierzy jednostkowej 5x5, zgromadzonych w postaci 4-bajtowych liczb całkowitych (zmienna licz = 25)

Sformatowane pliki tekstowe:

Zapisywanie danych do sformatowanego pliku tekstowego:

Wykorzystując polecenie fprintf można przeprowadzić konwersję danych do postaci łańcuchów znakowych i wyprowadzić je na ekran lub do pliku.
Rodzaje konwersji (poprzedzone znakiem %) dla polecenia fprintf:

%d	dla zapisu liczb całkowitych
%f	dla zapisu liczb rzeczywistych w formacie stałoprzecinkowym
%g	automatyczny dobór krótszego formatu (%e lub %f)
%e	dla zapisu liczb rzeczywistych w formacie zmiennoprzecinkowym

Przykład 1

Napisać m-skrypt tworzący plik tekstowy o nazwie pl.txt zawierający tablicę wartości funkcji exp(x) dla danych wartości x wiedząc, że pierwsza linia pliku ma zawierać tytuł, a następne linie po dwie kolumny liczb zapisane w odpowiednim formacie.

Rozwizanie:

x = 0:0.1:1;
y = [x; exp(x)];
pl = fopen('pl,txt','w');
fprintf(pl,'funkcja exp\n\n');
fprintf(pl,'%6.2f  %12.8f\n',y);
status = fclose(pl);


Przykład 2

Napisać m-skrypt generujący przykładowy wektor zespolony:
b = [6+2i 2-i 5i],
a następnie zapisujący go w pliku tekstowym w postaci:

RE	IM
6	2
2	-1
0	5

Rozwiązanie:

s1 = input('Podaj nazwę pliku','s');
pl = fopen(s1,'w');    %otwarcie pliku do zapisu
b = [6+2*sqrt(-1) 2-i 5*j];
rb = real(b);
ib = imag(b);
zb = [rb;ib];
fprintf(pl,'RE                            IM\n');
fprintf(pl,'%e %e\n',zb);
status = fclose(pl);    %zamknięcie pliku

Odczyt danych ze sformatowanego pliku tekstowego:

Do odczytu plików tekstowych i łańcuchów służy polecenie fscanf.
Rodzaje konwersji (poprzedzone znakiem %) dla polecenia fprintf:

%s	do odczytu łańcucha znaków
%d	do odczytu liczb całkowitych
%f	do odczytu liczb rzeczywistych w formacie stałoprzecinkowym
%e	do odczytu liczb rzeczywistych w formacie zmiennoprzecinkowym

Przykład 1

Odczytać sformatowany plik tesktowy pl.txt, w którym w pierwszej linii znajduje się tytuł, a w następnych w dwóch kolumnach liczby: całkowite i rzeczywiste.

Rozwiązanie:

pl = fopen('pl.txt','r');    %otwarcie pliku do odczytu
tytuł = fscanf(pl,'%s');    %wczytanie linii z tytułem
[tab, licz] = fscanf(pl,'%d %f');    %wczytanie do tablicy tab wartości z pliku
status = fclose(pl);    %zamknięcie pliku


Możliwe są operacje:

A = fscanf(pl,'%5d',100);	wczytanie 100 wartości całkowitych do wektora kolumnowego A
A = fscanf(pl,'%5d',[10,10]);	wczytanie 100 wartości całkowitych do macierzy A o wymiarze 10x10

Grafika w pakiecie Matlab

Polecenia do organizacji pracy w trybie graficznym:

Podział funkcji graficznych Matlaba:

	funkcje przeznaczone do prezentacji danych w postaci wykresów dwu- i trójwymiarowych
	podstawowe funkcje umożliwiające usuwanie rysunku, zmianę skali, dodawanie napisów
	funkcje jakie zwykle występują w bibliotekach języków programowania pozwalające rysować linie, wielokąty itd.
	funkcje niskiego poziomu pozwalające na praktycznie dowolne kształtowanie wyglądu tworzonego rysunku, na operowanie na jego składowych

Okna graficzne:
Matlab pozwala posługiwać się kilkoma oknami graficznymi jednocześnie. Pierwsze okno powstaje automatycznie po wywołaniu dowolnej funkcji graficznej. Następne okna można tworzyć wywołując funkcję figure.
Jedno z okien graficznych jest zawsze aktywne, wywołanie dowolnej funkcji graficznej będzie wpływało na zawartość tego właśnie okna. Oknem aktywnym jest zwykle to okno, które zostało utworzone jako ostatnie. Numer okna pojawia się w jego nagłówku - Figure No.1, Figure No.2, ..., Figure No.n.

Polecenia do operacji na oknach graficznych:

figure	tworzy nowe okno graficzne
figure(n)	uaktywnia okno graficzne o numerze n
close	zamyka aktywne okno graficzne
close(n)	zamyka n-te okno graficzne; (można też podać wektor lub macierz zawierającą numery okien, które mają być zamknięte)
clg lub clf	wyczyszczenie aktywnego okna

Zarządzanie wieloma rysunkami:

	subplot(m, n, p)	pozwala umieścić kilka wykresów w jednym oknie graficznym, gdzie: m - liczba wykresów, które mają się zmieścić w pionie (0<m<10) n - liczba wykresów, które mają się zmieścić w poziomie (0<n<10) p - numer wykresu, który zostanie narysowany przy najbliższym wywołaniu funkcji plot; (wykresy są numerowane w wierszach od lewej do prawej, a wiersze od góry do dołu)
		przykład: subplot(2,1,1)    %ustalenie podziału na dwa okna w pionie i uaktywnienie pierwszego z nich plot(x,f1(x))    %narysowanie wykresu (f1(x) w pierwszym oknie subplot(2,1,2)    %uaktywnienie drugiego okna  plot(x,f2(x))    %narysowanie wykresu f2(x) w drugim oknie
	subplot('position',[lewy dolny szerokość wysokość])	tworzy w obrębie aktywnego rysunku nowe okienko, zawarte wewnątrz prostokąta o podanym położeniu i wymiarach; parametry szerokość=wysokość=1 oznaczają układ o rozmiarach rysunku; położenie jest podawane względem lewego, dolnego rogu rysunku.

Skalowanie i nakładanie rysunków:

	axis - zmiana skali wykresu
		dostępne konfiguracje:
		axis([xmin xmax ymin ymax])	zakres skal na osiach x i y
		axis('auto')	skalowanie automatyczne
		axis('manual')	wyłącza tryb automatycznego formatowania pozostawiając aktualne rozmiary rysunku
		axis('ij')	zmiana układu współrzędnych na macierzowy
		axis('xy')	przywraca układ kartezjański
		axis('equal')	odcinki na obu osiach mają ten sam rozmiar na ekranie
		axis('square')	obie osie mają tyle samo jednostek długości
		axis('normal')	przywraca standardowe ustawienia
		axis('off')	urywa osie wraz z ich nazwami
		axis('on')	przywraca wyświetlanie osi
		[s1,s2,s3]=axis('state')	opisuje aktualne ustawienia układu: s1 - auto lub manual s2 - osie wyświetlane (on) lub nie (off) s3 - typ układu: xy lub ij
	hold on/off	wyłącza (on) lub włącza (off) czyszczenie okien z poprzednimi rysunkami
	ishold	ma wartość 1 gdy jest aktywne hold on, w przeciwnym razie 0

Kody kolorów i rodzaje linii:

Kody kolorów		Rodzaje linii:
y - żółty m - karmazynowy c - turkusowy r - czerwony g - zielony b - niebieski w - biały k - czarny		. (kropka)	punkty
				o (mała litera o)	kółeczka w punktach
				x (mała litera x)	iksy w punktach
				+ (znak +)	krzyżyki w punktach
				* (znak mnożenia)	gwiazdki w punktach
				- (znak minus)	linia ciągła
				-- (minus minus)	linia kreskowana
				: (znak dwukropka)	linia kropkowana
				-. (minus kropka)	linia kreska-kropka

Mapy kolorów:

Mapa:	Opis:
hsv	standardowa mapa kolorów w systemie HSV (Hue Saturation Value) - kolory zapisane są w postaci trójek liczb z przedziału <0;1> opisujących: odcień, nasycenie, jaskrawość; nasycenie zerowe oznacza, że kolory będą odcieniami szarości)
gray	mapa odcieni szarości
hot	mapa kolorów ciepłych
cool	mapa kolorów zimnych
pink	mapa odcieni kolorów różowych

Podstawowe operacje na mapach kolorów:

colormap	pozwala odczytać lub zmienić mapę kolorów przypisaną aktywnemu rysunkowi; np.: m = colormap    %wynikiem jest aktualna mapa kolorów colormap(m)    %zmiana mapy kolorów colormap('default')    %przywrócenie standardowej mapy kolorów
contrast	pozwala zwiększyć kontrast obrazów czarno - białych
brighten	zmienia jaskrawość kolorów w aktualnej mapie
m2 = hsv2rgb(m1)	dokonuje konwersji mapy m1 w systemie HSV na mapę m2 w systemia RGB (Red Green Blue - określenie intensywności trzech podstawowych kolorów: czerwonego, zielonego i niebieskiego)

Ustalanie koloru tła:
Standardowym kolorem tła dla rysunków Matlaba jest kolor czarny. Możliwość zmiany tego koloru oferuje funkcja whitebg:

whitebg	zmienia tło aktywnego rysunku na białe i modyfikuje odpowiednio inne własności rysunku
whitebg(id)	zmienia tła rysunków o podanych w wektorze id identyfikatorach
whitebg(id,kod_koloru)	zmiana tła rysunku (-ów) na inny kolor; np.: whitebg('y')

 Grafika dwuwymiarowa:

Wykresy dowolnych krzywych i funkcji:

	dostępne konfiguracje polecenia:	opis działania:
plot	plot(y)	rysuje wykres ciągu elementów wektora y względem ich indeksów (gdy y jest macierzą to dla każdej kolumny rysowany jest oddzielny wykres
		plot(x,y)	wykres y(x)
		plot(x,y,s)	wykres y(x) z określeniem koloru i rodzaju linii; s - łańcuch znaków, np.: 'r-' - linia ciągła koloru czerwonego
		plot(x1,y1,x2,y2,...)	rysowanie wielu wykresów jednocześnie
		plot(x1,y1,s1,x2,y2,s2,...)	rysowanie wielu wykresów jednocześnie z określeniem rodzaju i koloru linii, np.: s1='r:', s2='g-', s3='wo'
	fplot	fplot(f,granice,s,eps)	f - łańcuch znaków zawierający nazwę pliku z definicją pliku, granice - przedział, w którym ma być narysowany wykres, s - łańcuch znaków określający rodzaj i kolor linii eps - względny błąd, domyślna warość: 2e-3
		[x,y]=fplot(f,granice,s,eps)	nie rysuje wykresu tylko zwraca wektory x i y do narysowania wykresu f
	linspace	linspace(x1,x2,N)	generuje wierszowy wektor N liczb rozłożonych równomiernie w przedziale od x1 do x2
		linspace(x1,x2)	generuje domyślnie 100 liczb z przedziału od x1 do x2

Przykład 1

Narysować wykres funkcji f(x)=cos(x)-1 w przedziale [0;2*pi]
Rozwiązanie:
fplot('cos(x)',[0 2*pi],'r') lub plot(0:0.1:2*pi,cos(0:0.1:2*pi)-1,'r-')




Narysować na zielono wykres funkcji:


Rozwiązanie:
W m-skrypcie o nazwie funkcji czyli fgr1.m należy zdefiniować funkcję:

function y = fgr1(x)
y = sin(1./(x^2+1));

a następnie wydać polecenie:
fplot('fgr1',[0 4*pi],'g')




Narysować dwa powyższe wykresy na jednym rysunku.

Rozwiązanie:
Należy wydać ciąg poleceń lub zapisać je jako m-skrypt:

hold on    %włączenie opcji nie czyszczącej okna graficznego przy rysowaniuem kolejnych wykresów
fplot('cos(x)',[0 4*pi],'r')
fplot('fgr1',[0 4*pi],'g')
hold off




Opisywanie wykresów:

xlabel('podpis osi x')	tekst opisujący oś x aktywnego okna
ylabel('podpis osi y')	tekst opisujący oś y aktywnego okna
title('Tytuł rysunku')	tekst opisujący tytuł aktywnego wykresu
text(x,y,'tekst')	wypisanie tekstu w miejscu określonym przez współrzędne x i y
grid on/off	włączenie/wyłączenie pomocniczej siatki współrzędnych

Przykład 2

Zdefiniować funkcję y = cos(10e^x) i narysować jej wykres w przedziale [-2; 2] za pomocą polecenia plot i fplot.

Rozwiązanie:

Jeżeli w pliku fgr1.m zdefiniowano potrzebną funkcję:

function y = fgr1(x)
y = cos(10*exp(x));

to zestaw poleceń z m-sktyptu pozwala uzyskać odpowiednie wykresy:

x = -2:0.1:2;  y = fgr1(x)
subplot(2,1,1)
plot(x,y,'r')
title('Wykres funkcji za pomocą polecenia plot:')
subplot(2,1,2)
fplot('fgr1',[-2 2],'r')
title('Wykres funkcji za pomocą polecenia fplot:')

Uzyskane wykresy:



Przykład 3

Narysować wykres funkcji y = sin²(x) dla x = 1:12 oznaczając punkty jako "o" i jednocześnie łącząc je ciągłą linią. Na wykresie umieścić także siatkę, podpisy pod osiami: x - "Miesiące", y - "Dochód w mln zł" oraz tytuł - "Wyniki finansowe".

Rozwiązanie:

x = 1:12;
y = sin(x).^2;
plot(x,y,'ro',x,y,'r-');
grid on;
xlabel('Miesiące');
ylabel('Dochód w mln zł');
title('Wyniki finansowe');

Efekt działania powyższego m-skryptu:




 Wykresy w biegunowym układzie współrzędnych:

polar(t,r) lub polar(t,r,s)

rysuje wykres w układzie (Ø,r) parametry polecenia: t - wektor kątów dla poszczególnych punktów, r - wektor zawierający odległości poszczególnych punktów od początku układu, s - ciąg znaków, jak w poleceniu plot

Przykład 4

Narysować w układzie biegunowym wykres funkcji y = sin(3t) dla t z przedziału <-pi; pi>.

Rozwiązanie:

W wyniku działania poleceń

t = -pi:0.1:pi;
polar(t,sin(3*t),'y*');

otrzymamy wykres:




Wykresy danych dyskretnych:

bar(y)	rysuje słupki o wysokości kolejnych elementów wektora y
bar(x,y)	rysuje słupki o wysokości kolejnych elementów wektora y, w miejscach określonych przez elementy wektora x (elementy wektora x muszą być uporządkowane rosnąco)
bar(y,s) lub bar(x,y,s)	parametr s będący łańcuchem znaków określa rodzaj linii (tak jak w poleceniu plot)
stem(y), stem(x,y), stem(y,s), stem(x,y,s)	rysuje wykres podobny do słupkowego ale zamiast słupków wstawia odcinki
stairs(y), stairs(x,y)	rysuje wykres podobny do słupkowego ale zamiast słupków wstawia 'schodki'

Przykład 5

Napisać m-skrypt, który demonstruje efekty działania poleceń: bar, stem, stairs w jednym oknie graficznym.

Rozwiązanie:

clear all;
krok = 0.5;
x = -pi:krok:pi;
y = cos(x);
whitebg    %ustalenie koloru tła wykresu na biały
subplot(3,1,1)
bar(x,y)
title('bar')
subplot(3,1,2)
stem(x,y)
title('stem')
subplot(3,1,3)
stairs(x,y)
title('stairs')

Efekt działania:




Wykresy danych zespolonych:

plot(z,s)	jeżeli z jest macierzą zespoloną to zostanie narysowany wykres plot(real(z),imag(z))
compass(z,s) lub compass(x,y,s)	rysuje wykres, na którym elementy macierzy z są przedstawione w postaci strzałek o wspólnym początku i grotach opisanych przez współrzędne x = real(x), y = imag(z)
feather(z,s) lub feather(x,y,s)	rysuje wykres, na którym elementy macierzy z są przedstawione w postaci strzałek o początkach rozmieszczonych równomiernie na osi x; długości strzałek są równe modułom elementów macierzy z, a kąty nachylenia strzałek ich argumentom

We wszystkich powyższych poleceniach parametr s będący łańcuchem znaków określa rodzaj linii (tak jak w poleceniu plot).
Przykład 6

Przy pomocy poleceń compass i feather narysować w jednym oknie graficznym wykres funkcji z = x+jy, gdzie y = cos(x), x należy do przedziału <-3;3>.

Rozwiązanie:

x = -3:0.5:3;
subplot(2,1,1)
compass(x,cos(x));
title('compass')
subplot(2,1,2)
feather(x,cos(x))
title('feather')

Efekt działania:




Wykresy w skali logarytmicznej:

loglog(x,y,s)	rysuje wykres, używając skal logarytmicznych na obu osiach
semilogx(x,y,s)	rysuje wykres, używając skali logarytmicznej tylko na osi x
semilogy(x,y,s)	rysuje wykres, używając skali logarytmicznej tylko na osi y
logspace(x1,x2)	generuje wektor wierszowy 50 liczb, rozmieszczonych logarytmicznie między wartościami 10^x1 a 10^x2
logspace(x1,x2,N)	działa jak wyżej, ale generuje wektor wierszowy N liczb

Przykład 7

Używając skali logarytmicznej na osi x narysować wykres funkcji y = e^sin(x), dla x z przedziału <10^-1; 10³>.

Rozwiązanie:

x = logspace(-1;3,100)
semilogx(x,exp(sin(x)))

Efekt działania:




Rysowanie linii i wypełnianie kształtów:

Funkcje wymienione poniżej dodają jedynie pewne elementy do istniejącego rysunku:

line(x,y)	rysuje linie złożoną z odcinków o końcach określonych przez elementy wektorów x i y
fill(x,y,c) lub fill(x1,y1,c1,x2,y2,c2,...)	wypełnia wielokąt o wierzchołkach w punktach wyznaczonych przez elementy wektorów x i y kolorem określonym przez jednoznakowy łańcuch znaków c

Grafika trójwymiarowa:

Grafika trójwymiarowa (3D) rozumiana jest jako przedstawienie na płaszczyźnie ekranu monitora rzutów figur trójwymiarowych. W Matlabie grafika dwuwymiarowa (2D) rozumiana jest jako szczególny przypadek grafiki trójwymiarowej.

Przygotowanie danych do wykresu:
Przed utworzeniem wykresu 3D należy wygenerować specjalną siatkę na płaszczyźnie (x,y) w tych węzłach, w których będą wartości funkcji w osi z:

[X,Y] = meshgrid(x,y)	transformuje obszar opisany przez wektory x i y do dwóch macierzy X i Y, wiersze macierzy X są kopiami wektora x, natomiast kolumny macierzy Y są kopiami wektora y
[X,Y] = meshgrid(x)	równoważne wywołaniu meshgrid(x,x)

Przykład 1

Przygotować dane do wykresu funkcji:


dla x i y należących do [-5;5].

Rozwiązanie:

[X,Y] = meshgrid(-5:0.5:5,-5:0.5:5);
Z = (X-Y).*(X+Y)+exp(sqrt(X.^2+Y.^2));

Wykreślanie powierzchni:
Wykres powierzchni jest reprezentowany w postaci trzech macierzy. Płaszczyzna jest składana z czworokątów, których wierzchołki leżą w punktach o współrzędnych opisanych macierzami x,y,z.

mesh(x,y,z,c)	rysuje powierzchnię opisaną przez macierze x, y, z w postaci kolorowej siatki o oczkach wypełnionych kolorem tła, elementy macierzy c określają kolory obwódek poszczególnych oczek, zakresy osi są domyślnie określone przez zakres wektorów x i y
mesh(x,y,z)	przyjmowane jest c=z
mesh(z,c) mesh(z)	wykres wartości elementów macierzy z na siatce prostokątnej
meshc(x,y,z,c)	rysuje siatkę identyczną jak funkcja mesh i umieszcza pod nią wykres poziomicowy (łączy działanie mesh i contour), działanie ograniczone do powierzchni zdefiniowanych na regularnych siatkach prostokątnych
meshz(z,y,z,c)	podobnie jak mesh, z tym, że dodatkowo w dół od krawędzi wykresu rysowane są linie określające płaszczyzny odniesienia, działanie ograniczone do powierzchni zdefiniowanych na regularnych siatkach prostokątnych
surf(x,y,z,c)	rysuje różnokolorową powierzchnię opisaną macierzami x, y, z
surfc(x,y,z,c)	połączenie funkcji surf i contour
surfl(x,y,z,s,k)	rysuje powierzchnię z uwzględnieniem odbić światła, s - określa kierunek, z którego pada światło, k - wektor określający współczynniki odbicia i rozproszenia
waterfall(x,y,z,c)	podobnie jak meshz, z tym, że nie są rysowane linie odpowiadające kolumnom macierzy

Przykład 2

Narysować wykres powierzchni:


dla x,y należącymi do przedziału [-5;5]

Rozwiązanie:

[X,Y] = meshgrid(-5:0.5:5,-5:0.5:5);
Z = (X-Y).*(X+Y)+exp(sqrt(X.^2+Y.^2));
%po przygotowaniu danych do wykresu powierzchnię
%można wykreślić na następujące sposoby:
mesh(X,Y,Z)




mesh(Z)



Przykład 3

Narsować wykres funkcji: f(x,y) = sin(x)*cos(x) kolejno za pomocą poleceń mesh, meshc, meshz, każdy w oddzielnym oknie graficznym.

Rozwiązanie:

Funkcja zdefiniowana jest w pliku fgr2.m jako:

function z = fgr2(x,y)
z = sin(x).*cos(y)

Po przygotowaniu danych do wykresu:

[x,y] = meshgrid((-1:0.1:2)*pi,(-1:0.1:2)*pi);
z = fgr2(x,y);

można kreślić powierzchnie korzystając z wybranych poleceń:

mesh(x,y,z);
 




figure(2);
meshc(x,y,z);




figure(3);
meshz(x,y,z);



Przykład 4

Napisać m-skrypt, który rysuje wykresy funkcji:


w jednym oknie graficznym kolejno za pomocą poleceń: mesh, surf, waterfall.

Rozwiązanie:

Funkcja zdefiniowana jest w pliku fgr4.m jako:

function z = fgr4(x,y)
z = exp(-(x-1).^2-y.^2)+exp(-(x+1).^2-y.^2);

M-skrypt powinien zawierać polecenia:

close all;       %zamknięcie wszystkich okien graficznych
[x,y] = meshgrid(-3:0.3:3,-3:0.3:3);    %przygotowanie danych do wykresu
z = fgr4(x,y);
mesh(x,y,z); title('mesh'); pause
figure(1)    %uaktywnienie pierwszego okna graficznego (domyślnie tworzy się nowe okno)
surf(x,y,z); title('surf'); pause
figure(1)
waterfall(x,y,z); title('waterfall'); pause

Efektem wykonania m-skryptu będzie narysowanie kolejno (w tym samym oknie graficznym) wykresów:










Opisywanie wykresów:

zlabel('podpis osi z')	tekst opisujący oś z aktywnego okna
title('Tytuł rysunku')	tekst opisujący tytuł aktywnego wykresu
text(x,y,z,'tekst')	wypisanie tekstu w miejscu określonym przez współrzędne x,y,z

Zmiany już narysowanych wykresów: 

view(az,el)	parametry az i el określają odpowiednio: azymut i elewację (kąt podniesienia) położenia obserwatora, kąty podawane są w stopniach. Azymut jest to kąt odmierzany w płaszczyźnie x,y rosnący w kierunku przeciwnym do kierunku ruchu wskazówek zegara. Parametr az = 0 oznacza, że obserwator znajduje się w płaszczyźnie (y,z) po ujemnej stronie osi y. Elewacja jest to kąt między płaszczyzną (x,y) a prostą łączącą oko obserwatora z początkiem układu. Przyjmuje on wartości dodatnie jeśli obserwator znajduje się powyżej płaszczyzny (x,y).
view(2)	przyjmowany jest kierunek obserwacji jak dla wykresów dwuwymiarowych tzn.: az=0, el=90°.
view(3)	przyjmowany jest standardowy kierunek obserwacji dla wykresów trójwymiarowych
[az,el] = view	podaje aktualne ustawienia dla az i el
hidden on/off	ustawienie off powoduje, że nie są usuwane zasłonięte linie wykresu, natomiast on włącza zasłanianie
shading	zmienia sposób wypełnienia kolorem obiektów typu surface i patch
axis([xmin xmax ymin ymax zmin zmax])	skalowanie wykresu trójwymiarowego

Rysowanie brył i wielokątów:

cylinder(r,n) cylinder(n) cylinder	rysuje figurę obrotową o jednostkowej wysokości powstałą przez obrót krzywej wyznaczonej przez wektor r w płaszczyźnie zawierającej oś z. Elementy wektora r określają odległość krzywej od osi z w punktach równomiernie rozmieszczonych na jednostkowej wysokości. Parametr n określa liczbę punktów na obwodzie figury. Domyślnie r=[1,1], n=20
sphere(n) sphere	rysuje sferę o promieniu jednostkowym, parametr n określa liczbę `południków' i `równoleżników' sfery, domyslnie n=20
fill3(x1,y1,z1,c1,x2,y2,z2,c2,...)	wypełnia wielokąt o współrzędnych wierzchołków (xi,yi,zi) kolorem określonym przez jednoznakowy ciąg ci

Wykresy funkcji trzech zmiennych:

slice(x,y,z,v,xi,yi,zi,n) slice(v,xi,yi,zi,n)

rysuje zestaw przekrojów poziomych, pionowych i poprzecznych dokonanych w płaszczyznach wyznaczonych przez elementy macierzy xi, yi, zi oznaczając kolorem na każdym przekroju wartość funkcji opisanej elelementami macierzy v w kolejnych punktach przestrzeni. Macierz v opisuje wartość funkcji w punktach o współrzędnych x, y, z (domyślnie x=1:n, y=1:m,z=1:p, gdzie m,n,p - wymiary macierzy v)

Prezentacja funkcji dwóch zmiennych na płaszczyźnie:
Czasami gdy zachodzi potrzeba odczytania konkretnych wartości liczbowych oraz wykresy wykonane za pomocą funkcji mesh dają nieczytelny rezultat, dużo lepsze mogą być funkcje:

contour(z)	rysuje wykres poziomicowy elementów macierzy z traktując ich wartości jako wysokość nad płaszczyzną odniesienia
contour(x,y,z)	wektory x, y (muszą mieć wymiar zgodny z wymiarami macierzy z) określają położenie poziomych i pionowych linii siatki
contour(z,n) contour(z,s)	n - liczba poziomic (przy braku parametru dobierana automatycznie),s - łańcuch znaków określający rodzaj i kolor linii
contour3(z)	rysuje na trójwymiarowym wykresie poziomice powierzchni opisywanej przez elementy macierzy z umieszczając je na odpowiadających im wysokościach nad poziom odniesienia
contour3(z,n) contour3(x,y,z) contour(x,y,z,n)	domyślnie n=10
pcolor(c) pcolor(x,y,c)	rysuje wykres pseudokolorowy (`szachownicowy') macierzy liczbowej c. Wartości elementów macierzy decydują o kolorach poszczególnych pól szachownicy. Największemu i najmniejszemu elementowi macierzy są przypisywane odpowiednio ostatni i pierwszy kolor w aktywnej mapie kolorów. Opcjonalne wektoryx i y definiują siatkę wykresu określając kształt i położenia poszczególnych pól
quiver(x,y,u,v) quiver(x,y,u,v,s)	rysuje wektory o współrzędnych opisanych przez elementy macierzy u i v jako strzałki zaczepione w punktach o współrzędnych wyznaczonych przez elementy macierzy x i y. Macierze x,y,u,v muszą mieć identyczne wymiary

Przykład 5
Napisać m-skrypt który rysuje wykresy funkcji:


dla x,y є [-π;π] w tym samym oknie graficznym kolejno za pomocą poleceń:
contour, contour3 i mesh.

Rozwiązanie:

Funkcja zdefiniowana jest w pliku fgr4.m:

function z = fgr4(x,y)
z = exp(cos(x)).*exp(cos(y));

M-skrypt powinien zawierać polecenia:

close all;    %zamknięcie wszystkich okien graficznych
[x,y] = meshgrid(-pi:0.2:pi);    %przygotowanie danych do wykresu
z = fgr4(x,y);
contour(x,y,z); title('contour'); pause
figure(1);    %uaktywnienie pierwszego okna (domyślnie tworzy się nowe okno)
contour3(x,y,z); title('contour3'); pause
figure(1);
mesh(x,y,z); title('mesh'); pause

Efektem wykonania powyższych poleceń będzie narysowanie kolejno (w tym samym oknie graficznym) wykresów:










Przykład 6

Zakładając, że w pliku tekstowym image1.txt zapisana jest macierz:

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

napisać m-skrypt obrazujący wykresy macierzy w kilku wybranych mapach kolorów z wykorzystaniem polecenia pcolor.

Rozwiązanie:

clear all;
load image1.txt
c = image1;
mapa = str2mat('hsv','gray','hot','pink');
for i=1:4;
    figure(i);
    s = mapa(i,:);
    colormap(s);
    pcolor(c);
    axis('equal')
    axis('ij');
    title(mapa(i,:));
end;

Wynikiem wykonania m-skryptu będzie obraz macierzy w wybranych mapach kolorów. Dla mapy 'pink' otrzymamy:



Przykład 7

Narysować wykres sił pola elektrycznego pochodzącego od dwóch ładunków.

Rozwiązanie:

[x,y] = meshgrid(-3:0.4:3);
z = -1./sqrt((x-2.2).^2+y.^2)-1./sqrt((x+2.2).^2+y.^2);
[px,py] = gradient(z);
quiver(x,y,px,py);

Efektem wykonania powyższych poleceń będzie wykres:




Grafika rastrowa:

Podstawę grafiki systemu MATLAB stanowi grafika wektorowa - tworzone obrazy składają się z linii, punktów i wielokątów o określonych współrzędnych. Przydatne są jednak operacje na pojedynczych punktach rastra. MATLAB umożliwia to oferując zestaw funkcji grafiki rastrowej.

Obrazy statyczne:

image(c) image(x,y,c)

wyświetla w aktywnym układzie współrzędnych obraz opisany macierzą c - każdemu elementowi macierzy c odpowiada jeden punkt, elementy macierzy c są traktowane jako indeksy kolorów w mapie kolorów

Animacje:
Możliwość generacji filmów animowanych umożliwia zestaw poniższych poleceń:

m = movie(n,id,prostokąt)	tworzy macierz potrzebną do przechowania sekwencji rysunków; n- liczba rysunków, id opcjonalny identyfikator obiektu graficznego, z którego ma być zapamiętany rysunek (domyślnie rysunek aktywny), prostokat - czteroelementowy wektor [lewy dolny szrokosc wysokosc] opisujący prostokąt, który ma być zapamiętany (domyślnie cały obiekt)
m = getframe	zapamiętuje w macierzy maktualny rysunek
m = getframe(id)	zapamiętuje w macierzy m aktualny rysunek o identyfikatorze id
m = getframe(id,prostokąt)	zapamiętuje w macierzy maktualny wybrany obszar prostokątny z rysunku o identyfikatorze id
movie(m)	odtwarza film zapamiętany w macierzy m
movie(m,n)	n razy odtwarza film zapamiętany w macierzy m (jeśli n<0 to film jest odtwarzany n razy: raz w przód raz w tył)

Przykład 8

Napisać m-skrypt symulujący animację ruch strzałki na wykresie wektorowym, otrzymanym przy pomocy polecenia compass.

Rozwiązanie:

clear all;
clg;
m = moviein(13);    %przygotowanie miejsca w pamięci na 13 obrazów
for i=1:13,
    x = -3+(i-1)*0.5; y = cos(x);
    compass(x,y);    %rysowanie wykresu wektorowego
    axis([-3 3 -1 1])    %ustalenie zakresów osi
    m(:,i) = getframe;    %zapamiętanie bieżącego wykresu w postaci klatki filmu
                                     %w kolejnej kolumnie macierzy m
end
clg
movie(m,-5);    %odtworzenie filmu 5 razy: w przód i w tył

Graficzny interfejs użytkownika w pakiecie Matlab

Obiektowy system graficzny:

Każdy fragment rysunku stanowi pewien obiekt graficzny. Obiekt ma przypisany swój unikatowy identyfikator . Każdy obiekt zawiera strukturę danych - rekord, w którym przechowywane są jego parametry i związane z nim dane. Struktura ta zawiera pola, w których można umieścić identyfikatory innych obiektów - przodków i potomków danego obiektu. W ten sposób obiekty sa uporządkowane w postaci drzewa. Korzeń drzewa (root) (identyfikator 0) nie stanowi widocznego obiektu graficznego, chociaż można go utożsamiać z ekranem komputera. Potomkami korzenia są okna graficzne - rysunki (figures). Rysunki mają potomków w postaci układów współrzędnych (axis). Potomkami układów mogą być linie (lines), powierzchnie (surfaces), teksty (text), obrazy (images) i płaty (patches).

Poszczególne typy obiektów można scharakteryzować jako:

	rysunki	oddzielne okna systemu operacyjnego, zawierają wszystkie pozostałe obiekty graficzne; ich identyfikatorami są liczby całkowite
	układy	określają obszary wewnątrz rysunków
	linie	podstawowe obiekty graficzne
	powierzchnie	obiekty 3D składające się z wielu wypełnionych czworokątów
	napisy	łańcuchy znaków
	obrazy	element grafiki rastrowej
	płaty (wycinki)	wypełnione wielokąty

Hierarchia obiektów graficznych przedstawia schemat:



Na obiektach graficznych dozwolone są dwie grupy operacji:

	operacje tworzenia i usuwania obiektów
	operacje dokonujące zmian w rekordzie danych związanych z obiektem

Pola rekordu związanego z obiektem nazywane są własnościami obiektu. Własność jest to zmienna określająca parametr wyglądu obiektu. Własności mogą mieć postać:

	macierzy
	łańcuch znaków
	zmiennej typu wyliczeniowego

 Tworzenie obiektów:
Odpowiednie obiekty tworzone są w momencie wywołania funkcji graficznej wysokiego poziomu lub za pomocą nazw funkcji, analogicznych jak nazwy poszczególnych typów obiektowych:

id = figure	tworzy nowy rysunek (okno graficzne) i nadaje mu identyfikator id
axes(id)	uaktywnia układ współrzędnych o identyfikatorze id
id = axes('position',[lewy,dolny,wysokość szerokość])	tworzy układ o podanych wymiarach
id = line(x,y), id = line(x,y,z)	tworzy obiekt typu line w aktywnym układzie współrzędnych
id = text(x,y,'tekst'), id = text(x,y,z,'tekst')	tworzy obiekt typu text w aktywnym układzie współrzędnych

Poszukiwanie obiektów według własności:

id =gco	wyznacza identyfikator id aktywnego obiektu w bieżącym oknie (gco - get current object); obiekt aktywny to obiekt ostatnio kliknięty myszką
id =gco(idf)	wyznacza identyfikator id aktywnego obiektu w oknie o podanym identyfikatorze idf
id =gcf	wyznacza identyfikator aktywnego rysunku (gcf - get current figure)
id =gca	wyznacza identyfikator aktywnego układu (gca - get current axes)

Odczytywanie i zmiana własności obiektów:

	wartość = get(id,nazwa_własności)	służy do odczytu własności obiektu: id - identyfikator obiektu lub wektor identyfikatorów, nazwa_własności - ciąg znaków zawierający nazwę odczytywanej własności
		get(id)	wyświetla listę własności obiektu i ich wartości
		get(0)	wyświetl informację o wszystkich własnościach korzenia (root)
		get(0,'ScreenSize')	wyświetl bieżące ustawienia dla własności 'ScreenSize'
		get(0,'Units')	wyświetl bieżące ustawienia dla własności 'Units'
		set(id,nazwa_własności,wartość)	służy do zmiany własności obietu; id - identyfikator obiektu lub wektor identyfikatorów nazwa_własności - ciąg znaków zawierający nazwę odczytywanej własności, wartość - wartość, jaka ma być nadana zmienianej własności
		set(id)	wyświetla listę własności obiektu, które mogą być zmienione
		set(1,'MenuBar','none')	ukryj pasek menu na rysunku o identyfikatorze 1
	reset(id)	przywraca standardowe wartości własności obiektu (lub obiektów) id

Usuwanie obiektu:

delete(id)	usunięcie obiektu o identyfikatorze id oraz wszystkich jego potomków
close	zamknięcie aktywnego rysunku (okna)
close(id)	zamknięcie okna o identyfikatorze id
clf	usunięcie aktywnego rysunku (clf - clear figure)
cla	usunięcie wszystkich obiektów z aktywnego układu (cla - clear axes)

Niektóre własności wybranych obiektów:

Własność type (łańcuch znaków będący nazwą typu obiektu):

	root - korzeń
	figure - rysunek
	axes - układ współrzędnych
	line - linia
	patch - płat
	surface - powierzchnia
	text - napis
	image - obraz
	uicontrol - element graficzny systemu komunikacji z użytkownikiem
	uimenu - element menu

Własności obiektu typu axes:

AspectRatio	określa proporcje osi układu współrzędnych
Box on/off	decyduje czy osie rysowane są na wszystkich czterech krawędziach układu (on) czy tylko na lewej i dolnej (domyślnie off)
Color	określa kolor tła prostokąta obejmowanego przez układ współrzędnych
FontName, FontSize, FontAngle	określają parametry czcionki, jaka zostanie użyta do wyświetlania wartości liczbowych na osiach, tytule wykresu i etykietach osi.
GridLineStyle	określa typ linii, jaką zostanie narysowana siatka pomocnicza
LineWidth	określa grubość linii osi układu
XTick, YTick, ZTick	określają położenie oznaczeń wartości na odpowiednich osiach

Własności obiektu typu line:

Color	określa kolor linii
LineStyle	określa typ linii
LineWidth	określa szerokość linii w punktach

Własności obiektu typu text:

Color	określa kolor liter
FontAngle	określa nachylenie czcionki (normal - nie pochylona, italic - pochylona, oblique - ukośna
FontName	określa nazwę czcionki (np.: Times, Arial, Courier)
FontSize	określa rozmiar czcionki w punktach
FontWeight	określa grubość liter (light - czcionka delikatna, normal - normalna, demi - lekko pogrubiona, bold - pogrubiona)
HorizontalAlignment	określa w jaki sposób napis jest umieszczany względem punktu ustalonego przez własność Position (np.: left - na prawo od punktu tzn. wyrównany w lewo do punktu, center, right)
Position	określa położenie tekstu w układzie współrzędnych
Rotation	określa kąt o jaki jest obrócony wyświetlany tekst

Przykład 1

Przy pomocy polecenia mesh narysować wykres 3D funkcji z(x,y) = sin(x)+2cos(y) w przedziale x,y є [-π;π]. Dodać siatkę. Zakres skali na obu osiach ustalić od -2π do 2π. Zmienić własność obiektu gca:

1. GridLineStyle (typ linii siatki) na linię ciągłą ('-')

2. Xtick,Ytick przyjąć jako: [-2π, -π, 0, π, 2π].

Rozwiązanie:
Odpowiedni m-skrypt może mię postać:

clg;
[x,y] = meshgrid(-2*pi:0.2:2*pi);
z = sin(x)+2*cos(y);
mesh(x,y,z);
grid on;
axis = ([-2*pi, 2*pi, -2*pi, 2*pi]);
xt = -2*pi:pi:2*pi;
yt = -2*pi:pi:2*pi;
set(gca,'GridLineStyle','-')
set(gca,'Xtick',xt);
set(gca,'Ytick',yt);

Efektem wykonania powyższych poleceń będzie wykres:




 Graficzny system komunikacji z użytkownikiem:

Koncepcja graficznego systemu komunikacji z użytkownikiem w Matlabie realizuje dwie funkcje:

	budowanie wyglądu aplikacji ze standardowych elementów graficznych (takich jak przyciski, przełączniki, suwaki) rysowanych na ekranie i obsługiwanych myszką
	tworzenie aplikacji o działaniu sterowanym zdarzeniami (czyli procedurami przypisanymi do każdego z elementów i przekazanie odpowiedzialności za ich wywołanie na system operacyjny)

Tworzenie obiektów w graficznym systemie komunikacji z użytkownikiem:

uicontrol uicontrol('Własność1',wartość1,'Własność2',wartość2,...) id=uicontrol('Własność1',wartość1,'Własność2',wartość2,...) id=uicontrol(idf,'Własność1',wartość1,'Własność2',wartość2,...)	tworzy przyciski, przełączniki, suwaki, pola edycyjne, pola tekstowe; argumentami funkcji są pary: nazwa własności obiektu graficznego i jej wartość, opcjonalny parametr id określa identyfikator tworzonego obiektu, parametr idf określa nazwę innego obiektu wewnątrz którego zostanie stworzony nowy obiekt graficzny
uimenu uimenu('Własność1',wartość1,'Własność2',wartość2,...) id=uimenu('Własność1',wartość1,'Własność2',wartość2,...) id=uimenu(idf,'Własność1',wartość1,'Własność2',wartość2,...)	tworzy dodatkowy element menu głównego lub podmenu; argumentami funkcji są pary: nazwa własności obiektu graficznego i jej wartość, opcjonalny parametr id określa identyfikator tworzonego obiektu, parametr idf może określać nazwę menu głównego lub podmenu wewnątrz którego zostanie utworzony dany element menu

Właściwości obiektów w graficznym systemie komunikacji z użytkownikiem:

Elementy utworzone poleceniem uicontrol:

	Style	określa typ elementu; wartość własności określa jeden z ciągów znaków: pushbutton - przycisk radiobuton - przełącznik checkbox - wyłącznik slider - suwak edit - pole edycyjne text - pole tekstowe frame - ramka popupmenu - lista rozwijana
	CallBack	określa czynność wykonywaną po uaktywnieniu elementu poprzez kliknięcie myszką, może to być: ciąg znaków odpowiadający dowolnemu poleceniu lub kilku poleceniom Matlaba ciąg znaków będący nazwą m-skryptu, zawierającego polecenia Matlaba
	Position	określa położenie i rozmiary elementu przy pomocy czteroelementowego wektora postaci: [lewy dolny szerokość wysokość] wektor ten określa położenie lewego dolnego i prawego górnego rogu elementu, rozmiary są domyślnie wyrażone w punktach (1 punkt to 1/72 cala)
	String	zawiera ciąg znaków określających: etykietę wyświetlaną na obiekcie (dla przycisków, przełączników i wyłączników) elementy listy oddzielone pionową kreską (dla list rozwijanych) edytowany tekst (dla pól edycyjnych)
	Value	zawiera liczbę określającą aktualny stan elementu np.: dla suwaków jest to liczba z przedziału od Min do Max, dla list rozwijanych jest to numer pozycji na liście (1 dla pierwszej, itd...)
	Min, Max	określają granice, w jakich zmienia się wartość własności Value dla przycisków, przełączników, wyłączników i suwaków

Elementy utworzone poleceniem uimenu:

	Label	ciąg znaków określający nazwę elementów menu; jeśli przed jedną z liter zostanie umieszczony znak & (ang. ampersand) spowoduje to wyróżnienie danej litery w nazwie (podkreślone), dany element menu będzie można uruchomić szybko przez jednoczesne naciśnięcie klawisza ALT i wybranej litery
	Separator	oddziela parametry podmenu poziomą kreską; może przybierać wartości on/off (włączenie/wyłączenie separatora)
	CallBack	określa czynność wykonywaną po uaktywnieniu elementu menu (jak dla obiektów tworzonych poleceniem uicontrol)

Przykład 2

Dla danych a, b, c wykonać wykres funkcji: f(x) = sin(ax³ + x + 1). Ponadto należy:

1. ustawić nazwę rysunku w pasku tytułowym okna (obiekt gcf, własność Name) na "Wykresy funkcji",

2. dodać element menu głównego (polecenie uimenu) o nazwie "Wykres" (wyróżniona ma być litera k), do elementu menu dodać rozwijane podmenu o postaci pokazanej poniżej:

Wykres

Funkcja

Czyść

3. na dole rysunku dodać: suwak, pole edycyjne i listę rozwijaną; wszystkie te parametry będą miały za zadanie zmianę wartości parametru a; ponadto ustawić:
   - wartość minimalną suwaka: 0, wartość maksymalną: 10,
   - etykietę w polu edycji "a =" oraz wartość parametru a (polecenie num2str),
   - etykietę menu rozwijanego zawierającą trzy pozycje: "0,1", "1", "10".

Wartość parametru a przyjmowana do obliczeń oraz wyświetlana w polu edycji, obliczana będzie ze wzoru: a₁*skala (a₁ - wartość wybrana na suwaku, skala - wybrana pozycja z listy rozwijanej).

Rozwiązanie umieszczone jest w kilku plikach:

plik główny: obiekty.m:

clear all;
global a b c skala;
a = 0.1; b = 1;
skala = 0.1;
set(gcf,'Name','Wykresy funkcji');

Przel = uicontrol(gcf,'Style','popupmenu',...
'String','0.1|1|10',...
'Position',[320 3 70 12],...
'CallBack','przelicz');
set(Przel,'Value',0.1);

Suwak = uicontrol('Style','slider');
set(Suwak,'Position',[50 5 100 15]);
set(Suwak,'CallBack','ustaw');
set(Suwak,'Min',0,'Max',1);
set(Suwak,'Value',b);

etyk=uicontrol('Style','text',...
'String','a=',...
'Position',[170 5 15 15]);

Edit1 = uicontrol('Style','edit');
set(Edit1,'Position',[185 5 100 15]);
set(Edit1,'String',num2str(a));

guzik=uicontrol('Style','pushbutton',...
'String','RYSUJ',...
'Position',[420 5 70,19],...
'CallBack','wykres_f');

idm = uimenu('Label','Wy&kres');
uimenu(idm,'Label','&Funkcja','CallBack','wykres_f');
uimenu(idm,'Label','&Czyść','CallBack','clg,o','Separator','on');

 

plik przelicz.m:

global a skala;
val1 = get(Przel,'Value');
if (val1==1)
skala=0.1;
elseif (val1==2)
skala=1;
elseif(val1==3)
skala=10;
end;
a1=get(Suwak,'Value');
a=a1.*skala;
set(Edit1,'String',num2str(a));

 

plik ustaw.m:

global a skala;
a1 = get(Suwak,'Value');
val1 = get(Przel,'Value');
if (val1==1)
skala=0.1;
elseif (val1==2)
skala=1;
elseif(val1==3)
skala=10;
end;

a = a1.*skala;
set(Edit1,'String',num2str(a));

 

plik wykres_f.m: - rysowanie wykresu funkcji

global a skala;
a=get(Edit1,'String');
a=str2num(a);
fplot('fsin3',[-2 2]);
title(['y=sin(',num2str(a),'*x^3+x+1)']);

 

plik fsin3.m: - obliczenie wartości funkcji f(x)

function y = fsin3(x)
global a;
y = sin(a*x.*x.*x+x+1);

 

Sumaryczny efekt działania powyższych skryptów:




Obliczenie numeryczne w pakiecie Matlab

 Miejsca zerowe i minima funkcji, pierwiastki wielomianów:

fzero	znajduje miejsca zerowe funkcji jednej zmiennej, np.: x = fzero('nazwa_funkcji',x0) x = fzero('nazwa_funkcji',x0,tol,tr) gdzie: x0 - początkowe przybliżenie wartości szukanego miejsca zerowego, nazwa_funkcji - nazwa funkcji Matlab'a lub nazwa pliku, w którym zapisana jest definicja funkcji, tol - parametr opcjonalny, określający żądaną dokładność obliczeń, tr - parametr opcjonalny, jeśli tr jest różne od 0, wyświetlane są pośrednie wyniki obliczeń (kolejne przybliżenia)
fmin('nazwa funkcji',x1,x2)	znajduje minimum funkcji jednej zmiennej w przedziale [x1; x2], nazwa_funkcji - nazwa pliku (m-skryptu) w którym zapisana jest definicja funkcji
a = poly(r)	wyznacza współczynniki a1, a2, ..., an+1 wielomianu o pierwiastkach podanych w postaci wektora r = [r1, r2, ..., rn], współczynniki te podane są według malejących potęg zmiennej x
p = polyval(a, x0)	oblicza wartość wielomianu W(x,a) w punkcie x0; współczynniki wielomianu określa wektor a, przy czym muszą one być uszeregowane w kolejności od najbardziej znaczącego a1 do najmniej znaczącego an+1, gdy x0 jest macierzą lub wektorem wartości wielomianu obliczane są dla wszystkich elementów wektora x0
r = roots(a)	oblicza pierwiastki wielomianu W(x,a) o postaci podanej w opisie funkcji poly, a - wektor współczynników wielomianu a1, a2, ..., an+1

Przykład

Zdefiniować funkcję:


oraz narysować jej wykres w przedziale [-20; 20], obliczyć wektor wartości funkcji w punktach -2, -1, 2, znaleźć minimum funkcji w przedziale [3, 4] oraz znaleźć miejsca zerowe funkcji w otoczeniu punktów 3 i 4.

Rozwiązanie:

Na początku definiujemy funkcję fx i zapisujemy ją w pliku fx.m:

function y = fx(x)
y = 1./((x-0.3).^2+0.01)+1./((x-0.9).^2+0.04)-6;

Natomiast m-skrypt wyznaczający powyższe wartości będzie miał postać:

x = -20:0.1:20;
plot(x,fx(x));    %narysowanie wykresu funkcji
x = [-2 -1 2];
y = fx(x);    %obliczenie wartości funkcji
fmin('fx' 3, 4);    %znalezienie minimum funkcji
fzero('fx',3);    %znalezienie miejsc zerowych funkcji
fzero('fx',4);

 

Aby wyznaczyć miejsca zerowe wielomianu: W(x) = x³ + 3x - 4 należy wydać polecenie:
roots([1 0 3 -4]);

  Metody liniowej algebry numerycznej:
Własności macierzy:

rank(A)	oblicza rząd macierzy A
det(A)	oblicza wyznacznik macierzy A
norm(A)	oblicza normę macierzy A
cond(A)	oblicza liczbę warunkową macierzy A

Układy równań liniowych:

[L,U] = lu(A)	dokonuje rozkładu LU macierzy A tak że A = L*U, gdzie L - macierz trójkątna dolna, U - macierz trójkątna górna
x = inv(A)*b lub x = A\b	rozwiązanie układu równań Ax=b (b musi być wektorem kolumnowym)
x = b/A	rozwiązanie układu równań xA=b (b musi być wektorem wierszowym)

Przykład 1


Napisać m-skrypt rozwiązujący układ równań:



Rozwiązanie:

A = [1 1 1; 1 2 3; 1 -1 1];    %definicja macierzy A
b = [3 2 1]';    %transpozycja wektora na kolumny
x = A\b;
disp('Rozwiązanie:');
disp(x);

Przykład 2

Napisać m-skrypt rozwiązujący układ równań liniowych dla danych wczytywanych z klawiatury:

Rozwiązanie:

clear all;
disp('Rozwiązanie układu równań postaci Ax=b')
disp('gdzie A jest macierzą mxn, a x szukanym rozwiązaniem')
disp('b - wektorem wyrazów wolnych')
disp(' ')
disp('Podaj wymiary macierzy A:')
m = input('Podaj ilość wierszy macierzy A: m = ')
n = input('Podaj ilość kolumn macierzy A: n = ')
disp('Podaj elementy macierzy A wprowadzając je kolejnymi wierszami od 1 do m')
for i=1:m
   for j=1:n
        disp('Podaj element o indeksach)
        disp(i); disp(' , '); disp(j);
        a(i,j) = input('')
    end
end
disp('Podaj elementy wektora b:')
for j=1:m
    disp(Podaj element o indeksie: '); disp(j)
    b(j)=input('')
end
x = a\b'   %wektor b jest wierszowy, więc konieczna jest jego transpozycja

Interpolacja i aproksymacja:

Standardowe procedury Matlaba realizują interpolację za pomocą wielomianów pierwszego i trzeciego stopnia oraz za pomocą funkcji sklejanych:
yi = interp1(x,y,xi,'metoda') - interpolacja funkcji jednej zmiennej w punktach określonych wektorem xi i węzłach interpolacji określonych wektorami x, y.
Dostępne metody:

'linear'	interpolacja funkcją liniową (elementy wektora x muszą tworzyć ciąg rosnący)
'spline'	interpolacja funkcjami sklejanymi trzeciego stopnia (elementy wektora x muszą tworzyć ciąg rosnący)
'cubic'	interpolacja wielomianami trzeciego stopnia (odległości między elementami wektora x muszą być równe)

Najczęściej stosowaną metodą aproksymacji w Matlabie jest aproksymacja za pomocą wielomianów:
a = polyfit(x,y,r) - znajduje współczynniki wielomianu stopnia r najlepiej (w sensie średniokwadratowym) aproksymującego ciąg punktów x, y. Wartość wielomianu aproksymującego w punkcie x0 można wyznaczyć korzystając z polecenia polyval(a,x0).

Przykład 1


Utworzyć tablicę wartości funkcji sin(x) w przedziale [0; 2] (z krokiem 0,25), a następnie dla tak otrzymanej tablicy danych zastosować interpolację wielomianową i funkcjami sklejanymi wyświetlając wyniki na jednym rysunku.

Rozwiązanie:

x = 0:0.25:2;
y = sin(x);    %tablicowanie wartości funkcji sinus dla wektora wartości x
xi = 0:0.0625:2;    %wektor wartości dla których należy wyznaczyć wartości funkcji interpolującej
ywiel = interp1(x,y,xi,'cubic');   %interpolacja wielomianem
yspline = interp1(x,y,xi,'spline');    %interpolacja funkcjami sklejanymi
plot(x,y,'o',xi,ywiel,':',xi,yspline,'--')    %wykres efektów interpolacji

Przykład 2

Znaleźć współczynniki wielomianu aproksymującego stopnia 2 i 6 dla funkcji sin(x) w przedziale [0; 2]

Rozwiązanie:

x = 0:0.25:2;
y = sin(x);   %tablicowanie wartości funkcji sinus dla wektora wartości x
a2 = polyfit(x,y,2);    %obliczenie współczynników wielomianu aproksymującego stopnia 2
a6 = polyfit(x,y,6);     %obliczenie współczynników wielomianu aproksymującego stopnia 6
y2 = polyval(a2,x);     %obliczenie wartości wielomianu stopnia 2 w punktach wektora x
y6 = polyval(a6,x);    %obliczenie wartości wielomianu stopnia 6 w punktach wektora x
plot(x,y,'o',x,y2,'-',x,y6,'--')    %wykres efektów aproksymacji

Całkowanie numeryczne:
Matlab udostępnia dwie funkcje realizujące numeryczne całkowanie oparte o dwie różne metody:

Q = quad('nazwa_funkcji',a,b,tol,tr)	obliczenie metodą Simpsona
Q = quad8('nazwa_funkcji',a,b,tol,tr)	obliczenie złożoną kwadraturą Newtona-Cotesa (rzędu 8)

Parametry metod:

nazwa_funkcji	nazwa funkcji Matlaba lub nazwa pliku (m-skryptu), w którym zapisana jest definicja funkcji całkowalnej
a, b	granice całkowania
tol	wymagana względna tolerancja błędu (domyślnie przy braku parametru: 10^-3)
tr	jeśli parametr jest różny od 0, to kreślony jest wykres przedstawiający wszystkie węzły kwadratury

Przykład

Obliczyć całki:




Rozwiązanie: quad('sin',1,10)




Rozwiązanie:

Funkcja podcałkowa została zdefiniowana w pliku fx.m więc: quad('fx',3,4)

 Układy równań różniczkowych:

Rozwiązanie układu równań różniczkowych zwyczajnych postaci:


realizują w Matlabie funkcje oparte na metodach Rungego-Kutty rzędu 2-3 (ode23) lub 4-5 (ode45):

	[T,X] = ode23('nazwa_funkcji(t,x)',t0,tk,x0,tol,tr)
	[T,X] = ode45('nazwa_funkcji(t,x)',t0,tk,x0,tol,tr)

Parametry wejściowe:

nazwa_funkcji(t,x)	nazwa pliku (m-skryptu), w którym zdefiniowany został układ równań różniczkowych
t0, tk	granice przedziału czsu
x0	wektor kolumnowy określający warunki początkowe
tol	wymagana dokładność (domyślnie przy braku parametru: 10^-3)
tr	parametr opcjonalny, jeśli parametr jest różny od 0, to na ekranie wypisywane są kolejne kroki działania metody

Parametry wyjściowe:

T	czas (wektor kolumnowy)
X	macierz rozwiązań (każda kolumna macierzy jest wektorem reprezentującym wartości jednej ze zmiennych stanu w punktach określonych wektorem T)

W Matlabie możliwe jest również rozwiązywanie równań różniczkowych rzędu wyższego niż 1 poprzez sprowadzenie go do układu równań różniczkowych zwyczajnych rzędu pierwszego. Należy do tego użyć zmiennych stanu.
np.

Sprowadzić równanie różniczkowe rzędu 3 do układu równań różniczkowych zwyczajnych rzędu pierwszego:

   


wprowadzamy następujące zmienne stanu:

   




zatem nasze równanie można sprowadzić do następującego układu równań różniczkowych zwyczajnych rzędu pierwszego:

   


co w postaci wektorowej (wykorzystywanej przez Matlaba) można zapisać jako:

   


Przykład 1

Rozwiązać równanie Van der Pola:



Rozwiązanie:

Wprowadzamy następujące zmienne stanu:



więc nasze równanie można zapisać w postaci:



Równanie Van der Pola można zdefiniować za pomocą funkcji (m-skryptu o nazwie  vdpol.m):

function y = vdpol(t,x)
%równanie Van der Pola
y = [x(2); -(x(1).^2-1).*x(2)-x(1)];    %wektor kolumnowy

Rozwiązanie równania przy użyciu powyższej funkcji można uzyskać za pomocą poleceń:

t0 = 0; tk = 20;    %rozwiązanie w przedziale t0=0, tk=20
x0 = [0; 0.25];    %z warunkami początkowymi w chwili t0=0: x(0)=0; x'(0)=0,25
[t, x] = ode23('vdpol', t0, tk, x0)
plot(t,x)    %wykres rozwiązania w chwili określonej przez elementy wektora t i macierzy x
                %w której kolumny odpowiadają rozwiązaniom x₁(t) i x₂(t)
                %gdyby na wykresie miałoby znaleźć się tylko rozwiązanie równania tzn x₁(t) wtedy
                %ostatnie polecenia miałoby postać: plot(t,x(:,1));


Przykład 2

Napisać m-skrypt do rozwiązania układu równań różniczkowych w wybranym przedziale i dla wybranych warunków początkowych (brzegowych) wprowadzanych z klawiatury. Efektem działania m-skryptu ma być również wykres rozwiązania.

Rozwiązanie:

%Rozwiązanie układu równań różniczkowych w zadanym przedziale
echo off
clear    %wymazanie wartości zmiennych
clc    %wyczyszczenie okna komend
t0 = input('Podaj początek przedziału: ');    %początek przedziału czasowego
tk = input('Podaj koniec przedziału: ');    %koniec przedziału czasowego
n = input('Podaj liczbę warunków początkowych: ');
for i=1:n,
    y0(i)=input('Podaj warunek początkowy: ');    %definicja warunków początkowych
end
y0=y0';    %transpozycja wektora y0 na kolumnowy
funkcja = input('Podaj nazwę funkcji - plik z definicją funkcji: ','s');
[t, y] = ode23(funkcja,t0, tk, y0);    %rozwiązanie równania różniczkowego
pause;    %wciśnij dowolny klawisz
for i=1:n,
    figure(i);    %otwarcie kolejnego okna
    plot(t,y(:,i);    %wykres i-tego rozwiązania (i-tej kolumny macierzy y)
end
%koniec m-skryptu

Aby wykorzystać powyższy m-skrypt do rozwiązania układów równań należy zdefiniować funkcję i zapisać ją w pliku o odpowiedniej nazwie np:

Lp.	Układ równań do rozwiązania:	Definicja funkcji w m-skrypcie:
1.		Nazwa pliku: fa.m function yp = fa(t,y) yp = [y(2); -1001.*y(2)-1000.*y(1)]
2.	y'''(t)+8y''(t)+17y'(t)+10y(t)=0	Nazwa pliku: fb.m function yprim = fb(t,y) yprim(1) = y(2); yprim(2) = y(3); yprim(3) =-8.*y(3)-17.*y(2)-10.*y(1); yprim = yprim';

---