Laboratorium EEG/Wprowadzenie do Matlaba: Różnice pomiędzy wersjami

Z Brain-wiki
Linia 609: Linia 609:
  
  
Plik [[brain.fuw.edu.pl/edu/images/4/4a/Book.tar.gz]] ([[Plik:Book.tar.gz]]) zawiera strukturę, która opisuje dekompozycję pewnego sygnału na struktury składowe — „atomy” za pomocą algorytmu MP. Pobierz ten plik, rozpakuj go, a jego zawartość wczytaj do Matlaba i narysuj wynik dekompozycji (wraz ze źródłowymi sygnałami) zawarty w tym pliku. Napisz funkcję rysującą wyniki dla danego kanału i wybranego atomu uwzględniającą informacje zawarte we wczytanej strukturze.
+
Plik ([[Plik:Book.tar.gz]]) zawiera strukturę, która opisuje dekompozycję pewnego sygnału na struktury składowe — „atomy” za pomocą algorytmu MP. Pobierz ten plik, rozpakuj go, a jego zawartość wczytaj do Matlaba i narysuj wynik dekompozycji (wraz ze źródłowymi sygnałami) zawarty w tym pliku. Napisz funkcję rysującą wyniki dla danego kanału i wybranego atomu uwzględniającą informacje zawarte we wczytanej strukturze.
  
 
{{clear}}
 
{{clear}}

Wersja z 12:47, 1 mar 2016

Laboratorium_EEG/Wprowadzenie_do_Matlaba


Wprowadzenie

Okno powitalne Matlaba

Najkrócej można określić Matlab jako pakiet oprogramowania do obliczeń matematycznych wyprodukowany w firmie MathWorks. Jest to w istocie zintegrowane środowisko obliczeniowe, w którym mamy do dyspozycji:

  • własny język programowania wysokiego poziomu, dający możliwość interaktywnego programowania;
  • środowisko zaprojektowane do pracy z macierzami numerycznymi;
  • specjalistyczne zestawy procedur obliczeniowych z różnych dziedzin, możliwość zmiany i dodawania własnych funkcji;
  • bogate możliwości graficznej prezentacji wyników 2D/3D oraz projektowania własnych interfejsów graficznych (GUI);
  • możliwość włączania programów napisanych w innych językach (C, C++, Fortran, Java);
  • okienkowo-zorientowane środowiska graficzne do uruchamiania algorytmów na podstawie ich schematów blokowych (np. Simulink);
  • wygodne operacje wejścia/wyjścia dla wielu typów danych (np. wav, avi, DICOM)
  • zintegrowane interaktywne narzędzia programistyczne: edytor i debugger.

Dzięki tym możliwościom pakiet Matlab (mimo swej relatywnie wysokiej ceny) stał się bardzo popularnym narzędziem obliczeniowym, szczególnie w dziedzinie analizy danych biomedycznych. Pozwala on na dość szybkie pisanie złożonych programów obliczeniowych, pozwalając skupić się na rozwiązywaniu problemu, a nie na samym kodowaniu programu. Warto więc się z nim zapoznać, gdyż jest duża szansa natrafienia na Matlaba w trakcie kariery zawodowej absolwentów naszej specjalności.

Warto również dodać, że osoby nie dysponujące dostępem do Matlaba, chcące zapoznać się z programowaniem w tym języku lub używać posiadane gotowe programy mogą skorzystać z darmowego pakietu GNU Octave. Język Octave jest bardzo podobny do Matlabowego i większość programów może być bez zmian przenoszona między nimi.

Matlab a Python

Ponieważ nasz kurs programowania jest oparty zasadniczo o język Python, właściwe będzie porównanie Pythona i Matlaba. W trakcie nauki programowania w Pythonie, wykorzystywaliśmy interfejs użytkownika, pozwalający nie tylko na uruchamianie programów, ale też na pracę interaktywną. Takim interfejsem jest np. stosowany przez nas idle. W Matlabie podobny interfejs jest wbudowany w program — po uruchomieniu programu dostajemy otwarte okno poleceń.

Okna poleceń: po lewej Pythona (Idle), po prawej Matlaba

Jak widać, w obu przypadkach sytuacja jest podobna. Możemy zacząć pracę w sesji interaktywnej wpisując na bieżąco polecenia, które są od razu interpretowane i wykonywane. Wyniki są natychmiast prezentowane na ekranie. Każdy z pakietów daje nam również możliwość napisania programu w osobnym edytorze tekstu, zapisania go na dysku i uruchomienia w dogodnym dla nas momencie.

Podobieństw między Matlabem a Pythonem jest dużo więcej. Oba języki są językami wysokiego poziomu, co oznacza, że dużą część szczegółów implementacji naszego kodu możemy pozostawić w gestii stosowanego pakietu, pisząc programy w sposób bardziej przypominający ogólny algorytm opisany w sposób zrozumiały dla człowieka, a nie dopasowany do konkretnego komputera czy systemu operacyjnego.

Python został zaprojektowany jako język ogólnego stosowania, podczas gdy Matlab był projektowany zasadniczo jako język do obliczeń naukowych. W bardziej zaawansowaną funkcjonalność numeryczną Python został wyposażony dopiero dzięki powstaniu modułów NumPy/SciPy i Matplotlib. Pakiety te wprowadzają do Pythona m. in. wielowymiarowe macierze (numpy.array), operacje na wszystkich elementach macierzy oraz szereg procedur graficznych do prezentacji wyników, używających składni parametrów niezwykle podobnej do tych z Matlaba. Wydaje się więc, że nie powinno być trudności, aby „przesiąść“ się z jednego języka na drugi i sprawnie pisać programy. Tak w dużej mierze jest, są jednak między tymi językami subtelne różnice, które (szczególnie dla początkujących) mogą stanowić pułapkę. Najistotniejsze z tych różnic postaramy się tutaj zaprezentować.

Porównanie cech języków Matlab i Python
Matlab Python (2.x)
Podczas pracy interaktywnej Matlab, w odróżnieniu od Pythona, zwraca wartość każdego wyrażenia, które zlecimy mu do wykonania. Wypisywanie wyniku możemy zablokować kończąc wiersz polecenia średnikiem. Python wykonuje polecenie, ale nie zwraca jego wyniku. Jeśli zależy nam na takim zachowaniu Pythona, możemy zastosować nakładkę IPython, dającą podobną funkcjonalność.
Zmienne nie mają konkretnego typu, dopiero po przypisaniu im wartości możemy określić typ zmiennej. Sytuacja jest podobna.
Domyślnym typem numerycznym są liczby zmiennoprzecinkowe podwójnej precyzji. Dodatkowo, każda zmienna jest tak naprawdę macierzą zmiennych danego typu, nawet jeśli zawiera tylko jedną wartość (jest wtedy macierzą rozmiaru 1×1).
>> a = 3
a =
     3
>> class(a)
ans =
double
>> size(a)
ans =
     1     1
Spośród typów zmiennych numerycznych mamy do dyspozycji liczby całkowite i zmiennoprzecinkowe (które zachowują się inaczej w pewnych operacjach matematycznych). Macierze wprowadzone są przy użyciu pakietu NumPy.
>>> a = 3
>>> type(a)
<type 'int'>
>>> a = 3.
>>> type(a)
<type 'float'>
Macierze definiujemy z użyciem nawiasów kwadratowych.
a = [1 4; 7 2];
Macierze definiujemy używając odpowiedniej funkcji
a = numpy.array([ [1,4], [7,2] ])
a = numpy.mat('[1 4; 7 2]')
Indeksy macierzy piszemy w nawiasach okrągłych.
a(1,3,5:7)
Indeksy macierzy piszemy w nawiasach kwadratowych.
a[1,3,5:7]
Pierwszy indeks macierzy na numer 1. Pierwszy indeks macierzy na numer 0.
Działanie wycinka: elementy liczone od 1, ostatni zawiera się w wycinku.
>> a = linspace(1,10,10)
a =
     1     2     3     4     5     6     7     8     9    10
>> a(1:5)
ans =
     1     2     3     4     5
>> a(5:end)
ans =
     5     6     7     8     9    10
Działanie wycinka: elementy liczone od 0, ostatni element wpisany liczbowo nie zawiera się w wycinku.
>>> a = numpy.linspace(1,10,10)
>>> a
array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.])
>>> a[1:5] # czyli od elementu 2 do 5 (element 6 o indeksie 5 wpisany liczbowo)
array([ 2.,  3.,  4.,  5.])
>>> a[5:]  # czyli od elementu 6 do ostatniego (nie określonego liczbowo)
array([  6.,   7.,   8.,   9.,  10.])
Łatwe tworzenie wektorów wartości z pewnego zakresu:
>> a = 1:5
a =
     1     2     3     4     5
>> a = linspace(1,5,5)
a =
     1     2     3     4     5
Łatwe tworzenie wektorów wartości z pewnego zakresu z użyciem pakietu NumPy:
>>> a = numpy.r_[1:6]
>>> a
array([1, 2, 3, 4, 5])
>>> a = numpy.linspace(1,5,5)
>>> a
array([ 1.,  2.,  3.,  4.,  5.])
Macierze zachowują wszystkie swoje wymiary. Macierze mogą zostac „spłaszczone” do wektorów posiadających tylko długość.
Wymiary macierzy liczą się od lewej do prawej.
>> c=1:8
c =
     1     2     3     4     5     6     7     8
>> cr=reshape(c,[2,2,2])
cr(:,:,1) =
     1     3
     2     4
cr(:,:,2) =
     5     7
     6     8
>> cr(:,:,1)
ans =
     1     3
     2     4
>> cr(1,:,:)
ans(:,:,1) =
     1     3
ans(:,:,2) =
     5     7
Wymiary macierzy liczą się od prawej do lewej.
>>> c=numpy.array(range(1,9))
>>> c
array([1, 2, 3, 4, 5, 6, 7, 8])
>>> cr=numpy.reshape(c,(2,2,2))
>>> cr
array([[[1, 2],
        [3, 4]],
 
       [[5, 6],
        [7, 8]]])
>>> cr[0]
array([[1, 2],
       [3, 4]])
>>> cr[:,:,0]
array([[1, 3],
       [5, 7]])
Niektóre operatory różnią się od Pythonowych. Niektóre przykłady:
  • Potęgowanie: ^
  • Nie równa się: ~=
  • Dzielenie modulo: mod(x,y)
  • Operatory logiczne „i”, „lub”, „nie”: & | ~
  • Komentarz: %
Niektóre operatory różnią się od Matlabowych. Niektóre przykłady:
  • Potęgowanie: **
  • Nie równa się: !=
  • Dzielenie modulo: x % y
  • Operatory logiczne „i”, „lub”, „nie”: and or not
  • Komentarz: #
Przypisanie zmiennych do siebie powoduje skopiowanie ich zawartości.
>> a = [1 2 3]
a =
     1     2     3
>> b = a
b =
     1     2     3
>> b(2) = 0
b =
     1     0     3
>> a
a =
     1     2     3
Przypisanie zmiennych do siebie powoduje wyłącznie powstanie drugiej nazwy tego samego obiektu. Zawartość nie jest kopiowana.
>>> a = [1,2,3]
>>> b = a
>>> b[1] = 0
>>> b
[1, 0, 3]
>>> a
[1, 0, 3]
Liczby zespolone są wbudowane w działanie pakietu
>> (-1)^0.5
ans =
   0.0000 + 1.0000i
Chcąc użyć liczb zespolonych musimy to explicite zaznaczyć.
>>> (-1)**0.5

Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    (-1)**0.5
ValueError: negative number cannot be raised to a fractional power

ale

>>> (-1+0j)**0.5

(6.1230317691118863e-17+1j)
Niektóre sytuacje wyjątkowe nie powodują przerwania obliczeń, dając użytkownikowi informację o możliwym błędzie w postaci specjalnej wartości.
>> 1/0
ans =
   Inf

a także

>> a = ones(1,3)
a =
     1     1     1
>> b = [1 0 2]
b =
     1     0     2
>> a./b
ans =
    1.0000       Inf    0.5000
W „czystym” Pythonie użytkownik musi sam zadbać o obsługę wszystkich sytuacji wyjątkowych.
>>> 1/0

Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    1/0
ZeroDivisionError: integer division or modulo by zero

Macierze z modułu NumPy zachowują się podobnie do macierzy Matlaba:

>>> a = numpy.ones(3)
>>> a
array([ 1.,  1.,  1.])
>>> b = numpy.array([1.,0.,2.])
>>> b
array([ 1.,  0.,  2.])
>>> a/b
array([ 1. ,  inf,  0.5])
Ponieważ każda zmienna numeryczna jest macierzą, podstawowe operatory arytmetyczne opisują działania na macierzach. W szczególności operator mnożenia realizuje mnożenie macierzy:
>> a = [1 3]
a =
     1     3
>> b = [2;-1]
b =
     2
    -1
>> a * b
ans =
    -1
>> b * a
ans =
     2     6
    -1    -3

Aby zrealizować operację osobno dla każdej pary elementów macierzy/wektorów, stosujemy operatory arytmetyczne z kropką (wymiary macierzy muszą być zgodne):

>> a = [1 3]
a =
     1     3
>> b = [2 1]
b =
     2     1
>> a .* b
ans =
     2     3
>> b .* a
ans =
     2     3
Operatory arytmetyczne zastosowane do macierzy wykonują zadane operacje osobno dla wszystkich par elementów tych macierzy. Tak więc w szczególności operator mnożenia w Pythonie odpowiada operatorowi „mnożenia z kropką” w Matlabie i nie realizuje mnożenia macierzowego.
>>> a = numpy.array([1,3])
>>> a
array([1, 3])
>>> b = numpy.array([[2],[-1]])
>>> b
array([[ 2],
       [-1]])
>>> a * b
array([[ 2,  6],
       [-1, -3]])
>>> b * a
array([[ 2,  6],
       [-1, -3]])





>>> a = numpy.array([1,3])
>>> a
array([1, 3])
>>> b = numpy.array([2,1])
>>> b
array([2, 1])
>>> a*b
array([2, 3])
>>> b*a
array([2, 3])
Wywołanie pomocy dla obiektu nazwa:
help nazwa
Wywołanie pomocy dla obiektu nazwa:
help(nazwa)
Funkcje matematyczne są wbudowane.

Listę funkcji elementarnych można zobaczyć pisząc:

help elfun

Bardziej zaawansowane funkcje można zobaczyć pisząc:

help specfun
help elmat
Funkcje matematyczne są dostępne po załadowaniu modułu NumPy (lub innych,np. math).

Oczywiście powyższa tabela nie obejmuje wszystkich możliwych różnic, a tylko te najważniejsze, które mogą sprawić kłopot na początku pracy. Nie wydaje się jednak, aby miały one zasadnicze znaczenie dla sprawnego pisania programów w obu omawianych tu językach.

Piszemy program w Matlabie

Z tego co już zostało tutaj powiedziane widzimy, że osoba, która umie napisać program w Pythonie, nie powinna mieć większego kłopotu z napisaniem go również w Matlabie. Należy tylko pamiętać o pewnych różnicach języków i składni, które jednak zasadniczo, po nabyciu pewnej wprawy, nie sprawiają większych trudności.

Aby sprawdzić działanie obu języków w praktyce, napiszemy kilka programów realizujących te same założenia w Pythonie i w Matlabie.

Drobne różnice składniowe

  • Pisząc w języku Matlab, warto jest używać wcięć, nie są jednak konieczne. Koniec bloku zaznacza się, pisząc end.
  • Nie używamy dwukropków na końcu instrukcji zaczynających blok np. for, czy if.
  • Wyrażenie warunkowe:
    • if
if a < 30
    disp('small')
elseif a < 80
    disp('medium')
else
    disp('large')
end
    • switch
[dayNum, dayString] = weekday(date, 'long', 'en_US');

switch dayString
   case 'Monday'
      disp('Start of the work week')
   case 'Tuesday'
      disp('Day 2')
   case 'Wednesday'
      disp('Day 3')
   case 'Thursday'
      disp('Day 4')
   case 'Friday'
      disp('Last day of the work week')
   otherwise
      disp('Weekend!')
end
  • Pętle
    • for
for i = 1:m
   for j = 1:n
      H(i,j) = 1/(i+j);
   end
end

Pętla for, tak samo jak w Pythonie, wymaga sekwencji. Sekwencja może być pewnym wektorem. Można też ją utworzyć w następujący sposób:

poczatek:krok:koniec

albo

poczatek:koniec

(wtedy krok = 1). Wynikiem jest wektor wartości od poczatek do koniec o kroku krok. Jest to analog range oraz numpy.arange.

    • while
n = 1;
nFactorial = 1;
while nFactorial < 1e100
    n = n + 1;
    nFactorial = nFactorial * n;
end
  • Funkcje
    • nagłówek rozpoczyna się słowem function, na przykład:
function [R,E,V]=R_po(t,t_rec,t_in,U_SE,t_mem,R_0,E_0,V_0,t_0,u,dt)
    • Zwykle zachowujemy w oddzielnych plikach o nazwie takiej samej, jak funkcja.

Rysujemy wykres funkcji (przykład)

Napiszmy program rysujący wykres funkcji kwadratowej na odcinku od −5 do 5.

Matlab        Python
 
 
x=linspace(-5,5,11);
y=x.^2;
plot(x,y,'r-');
import numpy
import pylab
x=numpy.linspace(-5,5,11)
y=x**2
pylab.plot(x,y,'r-')
pylab.show()

Zasadnicze różnice: operator potęgowania, użycie operatora z kropką, konieczność importowania modułów numerycznego i graficznego, osobna procedura do pokazania gotowego wykresu na ekranie.


Narysujmy bardziej dokładnie wykres funkcji sin(x)/x.

Matlab        Python
 
 
x=linspace(-5,5,101);
y=sin(x)./x;
plot(x,y);
import numpy as np
import pylab as p
x=np.linspace(-5,5,101)
y=np.sin(x)/x
p.plot(x,y)
p.show()

Zliczamy liczbę liter

Narysujmy histogram liczebności poszczególnych liter z pierwszej księgi „Pana Tadeusza” A. Mickiewicza. Tekst znajdziemy tu. Ściągamy plik i zapisujemy w swoim katalogu.

Matlab        Python
 
 
fid=fopen('PanTadeuszX1.txt','rb');
tekst=fread(fid,'uchar');
fclose(fid);
 
hist(tekst,min(tekst):max(tekst));
xlim([double('a')-1 double('z')+1]);
 
 
 
set(gca,'XTick',double('a'):double('z'));
set(gca,'XTickLabel',['a':'z']');
import numpy as np
import pylab as p
 
tekst=np.fromfile('PanTadeuszX1.txt','uint8')
 
 
p.hist(tekst,max(tekst)-min(tekst)+1)
p.xlim(ord('a')-1,ord('z')+1)
achars=[]
for code in range(ord('a'),ord('z')+1):
    achars.append(chr(code))
p.xticks(range(ord('a'),ord('z')+1),achars)
 
p.show()

Wykorzystaliśmy tutaj fakt, że litery alfabetu angielskiego są w kodzie ASCII ułożone bezpośrednio po sobie, alfabetycznie i w kolejności rosnącej. Gdybyśmy w naszym histogramie chcieli uwzględnić również polskie litery, należałoby kolejność słupków histogramu wybrać ręcznie, zgodnie z kolejnością w alfabecie polskim. Histogram musimy utworzyć z wybranych wartości (wysokości słupków) ustawionych w pożądanej kolejności. Dodatkową trudnością jest fakt, że stosowane są różne sposoby kodowania polskich liter (czyli zamiany liter na odpowiadające im wartości liczbowe). Plik tekstowy zastosowany w przykładzie wykorzystuje kodowanie „Windows-1250”, a Matlab domyślnie koduje napisy w standardzie Unicode. Nasz program powinien uwzględniać te fakty.

Ćwiczenia









Debugger w Matlabie

Środowisko programowania w Matlabie dostarcza bardzo użytecznego narzędzia pomagającego śledzić działanie programów i niezwykle ułatwiającego wyszukiwanie błędów. Narzędzie to nazywa się z angielska debuggerem (czyli „odrobaczaczem” lub „odpluskwiaczem”).

Zasada działania debuggera polega na tym, że możemy zatrzymać wykonujący się program w dowolnym miejscu, nie przerywając wykonania całkowicie, ale tylko chwilowo je wstrzymując. Robimy to przez wcześniejsze wstawienie w tekście programu (który musi być widoczny w oknie Edytora) specjalnych punktów zatrzymania (ang. breakpoints). Pokażemy to na przykładzie prostego programu. Na rysunku poniżej widzimy fragment okna Edytora Matlaba z widocznym interesującym nas fragmentem programu.

Matldeb1.gif

Załóżmy, że chcemy zobaczyć czy pętla w wierszach 3-5 programu prawidłowo sumuje wartości. W tym celu w wierszu 4 umieszczamy punkt zatrzymania, ustawiając kursor w edytorze na tym wierszu i używając guzika z paska poleceń:

Matldeb2.gif

Po naciśnięciu guzika „Set/clear breakpoint” („Ustaw/skasuj punkt zatrzymania”) po lewej stronie wiersza 4 pojawia się czerwona kropka oznaczająca, że w tym miejscu program zostanie wstrzymany.

Matldeb3.gif

Pozostaje nam teraz uruchomić nasz program. Można to zrobić wpisując odpowiednie polecenie w oknie Poleceń Matlaba (Command window) lub naciskając guzik na pasku poleceń:

Matldeb4.gif

Program wykona się aż do napotkania punktu zatrzymania. Wtedy wykonanie zostaje przerwane i w oknie Poleceń zauważymy, że znak zachęty ma dopisaną literę „K”. Zielona strzałka z lewej strony wiersza programu wskazuje jaka komenda programu oczekuje na wykonanie. W oknie Obszar roboczy (Workspace) widzimy wartości wszystkich zmiennych naszego programu, możemy też w oknie Poleceń wpisać dowolne wyrażenie (np. suma*3) i zobaczyć jego wynik. Od tej chwili możemy też wykonywać nasz program krok po kroku naciskając odpowiedni guzik z paska poleceń albo wykonać program do końca (lub następnego punktu zatrzymania).

Matldeb5.gif

Informacje dodatkowe

Matlab wyposażony jest w tzw. toolboxy czyli pakiety procedur powiązanych tematycznie do rozwiązywania problemów z jakiejś dziedziny. Pakiety takie można zakupić u producenta (The MathWorks Inc.); aby sprawdzić jakie są aktualnie zainstalowane, wywołujemy polecenie Matlaba ver. W rezultacie dostajemy listę podobną do prezentowanej poniżej.

>> ver
-------------------------------------------------------------------------------------
MATLAB Version 7.11.0.584 (R2010b)
MATLAB License Number: 123456
Operating System: Microsoft Windows 7 Version 6.1 (Build 7600)
Java VM Version: Java 1.6.0_17-b04 with Sun Microsystems Inc. Java HotSpot(TM) Client VM mixed mode
-------------------------------------------------------------------------------------
MATLAB                                                Version 7.11       (R2010b)
Simulink                                              Version 7.6        (R2010b)
Bioinformatics Toolbox                                Version 3.6        (R2010b)
Communications Blockset                               Version 5.0        (R2010b)
Communications Toolbox                                Version 4.6        (R2010b)
Control System Toolbox                                Version 9.0        (R2010b)
Curve Fitting Toolbox                                 Version 3.0        (R2010b)
Data Acquisition Toolbox                              Version 2.17       (R2010b)
Database Toolbox                                      Version 3.8        (R2010b)
Filter Design Toolbox                                 Version 4.7.1      (R2010b)
Financial Toolbox                                     Version 3.8        (R2010b)
Fixed-Point Toolbox                                   Version 3.2        (R2010b)
Global Optimization Toolbox                           Version 3.1        (R2010b)
Image Acquisition Toolbox                             Version 4.0        (R2010b)
Image Processing Toolbox                              Version 7.1        (R2010b)
Instrument Control Toolbox                            Version 2.11       (R2010b)
MATLAB Builder EX                                     Version 1.3        (R2010b)
MATLAB Builder NE                                     Version 3.2        (R2010b)
MATLAB Compiler                                       Version 4.14       (R2010b)
Mapping Toolbox                                       Version 3.2        (R2010b)
Neural Network Toolbox                                Version 7.0        (R2010b)
Optimization Toolbox                                  Version 5.1        (R2010b)
Parallel Computing Toolbox                            Version 5.0        (R2010b)
Parallel Computing Toolbox                            Version 5.0        (R2010b)
Partial Differential Equation Toolbox                 Version 1.0.17     (R2010b)
Real-Time Workshop                                    Version 7.6        (R2010b)
Robust Control Toolbox                                Version 3.5        (R2010b)
Signal Processing Blockset                            Version 7.1        (R2010b)
Signal Processing Toolbox                             Version 6.14       (R2010b)
Simulink Control Design                               Version 3.2        (R2010b)
Simulink Design Optimization                          Version 1.2        (R2010b)
Simulink Fixed Point                                  Version 6.4        (R2010b)
Statistics Toolbox                                    Version 7.4        (R2010b)
Symbolic Math Toolbox                                 Version 5.5        (R2010b)
System Identification Toolbox                         Version 7.4.1      (R2010b)
Wavelet Toolbox                                       Version 4.6        (R2010b)

Oczywiście możemy sami dopisywać własne procedury, a także korzystać z oprogramowania udostępnionego przez innych twórców. Jako przykład mogą tu posłużyć pakiety do analizy danych biomedycznych EEGLAB czy obrazów MRI SPM rozwijane przez niezależne grupy obejmujące badaczy i programistów. Również procedury Octave-Forge tworzone w ramach projektu GNU Octave mogą współpracować wymiennie z Matlabem.

Python również pozwala na korzystanie z pisanych dla niego pakietów oprogramowania. Musimy je jednak odszukać, ściągnąć i zainstalować sami. W wersji podstawowej będą to:

  • python — podstawowy interpreter/kompilator języka Python;
  • numpy — biblioteka funkcji matematycznych i obliczeniowych;
  • scipy — zestaw bardziej zaawansowanych procedur numerycznych;
  • matplotlib — procedury graficzne do sporządzania wykresów i wizualizacji wyników.
(Uwaga: Mając zainstalowane bilioteki numpy, scipy i matplotlib możemy w programie używać podstawowych funkcji wszystkich tych modułów jedną komendą: import pylab.)

Lista projektów programistycznych w Pythonie obejmuje różnorodne tematy i jest duża szansa znalezienia czegoś dla siebie.

Warto też zwrócić uwagę na pakiet mlabwrap, który pozwala korzystać z Matlaba (musi być zainstalowany w systemie) jakby był on biblioteką Pythona (z pewnymi ograniczeniami, ale wciąż rozwijany).


Laboratorium_EEG/Wprowadzenie_do_Matlaba