Wykład_1

Przykłady prezentowane w trakcie Wykładu 1 dla przedmiotów:

Rok akad. 2017/18. Semestr zimowy Prowadzący: dr inż. Beata Leśniak-Plewińska

Contents

Tworzenie zmiennych

Tworzenie zmiennych na przykładzie zmiennych skalarnych i wektorów.

Tworzenie zmiennych skalarnych

a = 1
a =
     1
y = 3
y =
     3

Casesentivity

A = 1.1
A-a
A =
    1.1000
ans =
    0.1000

Tworzenie zmiennych na podstawie innych zmiennych z użyciem operatorów arytmetycznych

c = a + y
c =
     4
d = a ^ y
d =
     1
e = y / 2 - a * 4
e =
   -2.5000

Więcej informacji o operatorach arytmetycznych

help arith
doc arith
 Arithmetic operators.
  +   Plus.
      X + Y adds matrices X and Y.  X and Y must have the same
      dimensions unless one is a scalar (a 1-by-1 matrix).
      A scalar can be added to anything.  
 
  -   Minus.
      X - Y subtracts matrix X from Y.  X and Y must have the same
      dimensions unless one is a scalar.  A scalar can be subtracted
      from anything.  
 
  *   Matrix multiplication.
      X*Y is the matrix product of X and Y.  Any scalar (a 1-by-1 matrix)
      may multiply anything.  Otherwise, the number of columns of X must
      equal the number of rows of Y.
 
  .*  Array multiplication
      X.*Y denotes element-by-element multiplication.  X and Y
      must have the same dimensions unless one is a scalar.
      A scalar can be multiplied into anything.
 
  ^   Matrix power.
      Z = X^y is X to the y power if y is a scalar and X is square. If y is an
      integer greater than one, the power is computed by repeated
      multiplication. For other values of y the calculation
      involves eigenvalues and eigenvectors.
      Z = x^Y is x to the Y power, if Y is a square matrix and x is a scalar,
      computed using eigenvalues and eigenvectors.
      Z = X^Y, where both X and Y are matrices, is an error.
 
  .^  Array power.
      Z = X.^Y denotes element-by-element powers.  X and Y
      must have the same dimensions unless one is a scalar. 
      A scalar can operate into anything.

Tworzenie zmiennych na podstawie innych zmiennych z użyciem funkcji

sin(pi/4)
z = tan(a)
ans =
    0.7071
z =
    1.5574

Tworzenie wektorów - konstruktor tablicy []

d = [1 2 3 4 5]
d =
     1     2     3     4     5
d = [1, 2, 3, 4, 5]
d =
     1     2     3     4     5

Tworzenie wektorów na podstawie innych wektorów - wektoryzacja operatorów

d2p3 = d.^3
d2p3 =
     1     8    27    64   125

Tworzenie wektorów z użyciem operatora ':' i funkcji tworzących wektory o określonym przebiegu wartości (liniowym lub logarytmicznym)

x = 0:0.25:3
x =
  Columns 1 through 7
         0    0.2500    0.5000    0.7500    1.0000    1.2500    1.5000
  Columns 8 through 13
    1.7500    2.0000    2.2500    2.5000    2.7500    3.0000
X = linspace(0,3,13)
X =
  Columns 1 through 7
         0    0.2500    0.5000    0.7500    1.0000    1.2500    1.5000
  Columns 8 through 13
    1.7500    2.0000    2.2500    2.5000    2.7500    3.0000
Xlog = logspace(0,3,13)
Xlog =
   1.0e+03 *
  Columns 1 through 7
    0.0010    0.0018    0.0032    0.0056    0.0100    0.0178    0.0316
  Columns 8 through 13
    0.0562    0.1000    0.1778    0.3162    0.5623    1.0000

Dostęp do elementów wektora. Pobranie i modyfikacja wartości elementu wektora.

Użycie indeksowania wektora w celu pobrania oraz zmiany wartości jego elementów.

a = x(3)
a =
    0.5000
x(3) = 10
x(7:end) = 100
x =
  Columns 1 through 7
         0    0.2500   10.0000    0.7500    1.0000    1.2500    1.5000
  Columns 8 through 13
    1.7500    2.0000    2.2500    2.5000    2.7500    3.0000
x =
  Columns 1 through 7
         0    0.2500   10.0000    0.7500    1.0000    1.2500  100.0000
  Columns 8 through 13
  100.0000  100.0000  100.0000  100.0000  100.0000  100.0000

Wybrane podstawowe funkcje matematyczne

Użycie wybranych funkcji matematycznych z argumentami wejściowymi w postaci wektorów.

u = [10 3 2 7 9 12]
u =
    10     3     2     7     9    12
sqrt(u)
ans =
    3.1623    1.7321    1.4142    2.6458    3.0000    3.4641
v = [-23 12 0 1 -1 43 -105]
v =
   -23    12     0     1    -1    43  -105
abs(v)
ans =
    23    12     0     1     1    43   105

Wybrane funkcje zwracające podstwowe informacje o wartościach elementów tablicy z argumentami wejściowymi w postaci wektorów.

Utworzenie wektora liczb losowych o wartościach całkowitych

w = randi([-10 10],[1,10])
w =
    -1    -2     6     6    -7     0    -1     3     4     5

Wyznaczenie sumy wartości elementów wektora

sum_w = sum(w)
sum_w =
    13

Wyznaczenie maksymalnej/minimalnej wartości w wektorze oraz jej indeksu

max_w = max(w)
max_w =
     6
[maxW indMaxW] = max(w)
maxW =
     6
indMaxW =
     3
min_w = min(w)
min_w =
    -7

Tworzenie wektorów kolumnowych

Transpozycja wektroa wierszowego

k = (1:5)'
k = [1:5]'
k =
     1
     2
     3
     4
     5
k =
     1
     2
     3
     4
     5

Tworzenie za pomoca kreatora tablicy ([])

K = [1; 10; -5; 7]
K =
     1
    10
    -5
     7

Typy danych. Whos. Konwersja typu danych

Podstawowe proste typy danych oraz użycie polecenia 'whos'.

Usunięcie wszystkich zimennych z przestrzeni roboczej

clear all;

Zmienna skalarna typu double

a = 1
a =
     1
%Zmienna skalarna typu char
b = 'x'
b =
    'x'

Zmienna skalarna typu logical

c = false
c =
  logical
   0

Wyświetlenie informacji o wszystkich zmiennych w przestrzeni roboczej

whos
  Name      Size            Bytes  Class      Attributes

  a         1x1                 8  double               
  b         1x1                 2  char                 
  c         1x1                 1  logical              

Wektor elementów typu double

d = [1 2 3 4]
d =
     1     2     3     4

Wektor elementów typu char - łańcuch znakowy

e = ['a' 'b' 'c' 'd']
e =
    'abcd'
f = ['abcd']
f =
    'abcd'

Wyświetlenie informacji o zmiennych d, e, f

whos d e f
  Name      Size            Bytes  Class     Attributes

  d         1x4                32  double              
  e         1x4                 8  char                
  f         1x4                 8  char                

whos('d','e','f')
  Name      Size            Bytes  Class     Attributes

  d         1x4                32  double              
  e         1x4                 8  char                
  f         1x4                 8  char                

Utworzneie zmiennej strukturalnej infoD zawierającej informacje o zmiennej d

infoD = whos('d')
infoD = 
  struct with fields:

          name: 'd'
          size: [1 4]
         bytes: 32
         class: 'double'
        global: 0
        sparse: 0
       complex: 0
       nesting: [1×1 struct]
    persistent: 0

Przykład konwersji typu danych. Użycie funkcji 'disp' i 'num2str' do wyświetlenia wartości dwóch zmiennych: zmiennej liczbowej 'systolic' oraz zmiennej znakowej 'opis'

systolic = 100;
opis = ['Ciśnienie skurczowe krwi']
opis =
    'Ciśnienie skurczowe krwi'
str = [opis ' = ' num2str(systolic)]
str =
    'Ciśnienie skurczowe krwi = 100'
disp(str)
Ciśnienie skurczowe krwi = 100

Obsługa plików danych

Zapis danych do pliku tekstowego z użyciem funkcji 'dlmwrite'

f = [1 2 3 4 9 8 7 6 5]
dlmwrite('test.txt',f,'\t')
f =
     1     2     3     4     9     8     7     6     5

Zapis i ładowanie danych za pomoca funckji 'save' i 'load'

dane = load('test.txt')
dane =
     1     2     3     4     9     8     7     6     5
e = dane/2;
save('nowe_dane.mat','dane','e')
save('nowe_dane.txt','dane','e','-ascii')
nowe_dane = load('nowe_dane.txt')
nowe_dane =
  Columns 1 through 7
    1.0000    2.0000    3.0000    4.0000    9.0000    8.0000    7.0000
    0.5000    1.0000    1.5000    2.0000    4.5000    4.0000    3.5000
  Columns 8 through 9
    6.0000    5.0000
    3.0000    2.5000

Wizualizacja danych.

Użycie funkcji 'plot' do utworzenia pojedynczego wykresu liniowego dla zmiennych 'x' i 'y'

Utworzenie zmiennych definiujących współrzedne punktów węzłowych wykresu w układzie współrzędnych xy

x = 0:0.1:2*pi;
y = sin(x);
plot(x,y,'-b');

Modyfikacje wykresu (tytuł, etykiety osi, ...)

title('Wykres liniowy funkcji sinus dla wartości od 0 do 2\pi');
xlabel('Kąt w radianach')
ylabel('Sinus')

Użycie funkcji 'plot' do utworzenia dwóch wykresów liniowych w jednym układzie osi dla zmiennych 'x', 'y' i 'x','y2'. Dodanie legendy

y2 = cos(x);
plot(x,y,'-b',x,y2,'-r')
legend('Sinus','Cosinus')

Aproksymnacja funkcji. Dopasowanie wielomianu

Dopasowanie wielomianu 3-ciego stopnia do funkcji przemieszczeń promieniowych segmentu lewej komory serca w czesie

clear all
load('radial.mat');
plot(t, radial, '-*r');
title('Przemieszczenie promieniowe ściany serca w czasie');
xlabel('Czas (ms)')
ylabel('Przemieszczenie promieniowe (mm)');

Dopasowanie wielomianu

p = polyfit(t, radial, 3);

Dodanie wykresu aproksymowanej funkcji do wykresu przemieszczeń promieniowych segmentu lewej komory serca

hold on
plot(t, polyval(p, t), '-k');
hold off

Aproksymacja wartości przemieszczenia segmentu lewej komowry serca w chwili czasowej t=100ms

t100 = 100
radial_100ms = polyval(p, t)
t100 =
   100
radial_100ms =
  Columns 1 through 7
   -0.6267    1.0760    2.3918    3.3573    4.0091    4.3835    4.5172
  Columns 8 through 14
    4.4465    4.2082    3.8385    3.3741    2.8515    2.3072    1.7776
  Columns 15 through 19
    1.2994    0.9089    0.6428    0.5374    0.6294

Macierze. Tworzenie. Indeksowanie. Operacje arytmetyczne

Tworzenie macierzy

a = [1 2; 3 4]
a =
     1     2
     3     4
b = [1, 2; 3, 4]
b =
     1     2
     3     4

Indeksowanie dwu-wskaźnikowe elementów macierzy

X = [4 2 4; 7 6 3]
Y = [1 2 3; 1 0 0]
Z = [2 0 9; 1 5 7]
X =
     4     2     4
     7     6     3
Y =
     1     2     3
     1     0     0
Z =
     2     0     9
     1     5     7
Z(2,2) = 1
Z =
     2     0     9
     1     1     7
X(1,:) = [2 2 2]
X =
     2     2     2
     7     6     3
Y(1,:) = Z(2,:)
Y =
     1     1     7
     1     0     0
X(1,2:end) = [-1 -1]
X =
     2    -1    -1
     7     6     3

Indeksowanie jedno-wskaźnikowe elementów macierzy - indeksowanie liniowe

mat = [11 12; 21 22]
mat =
    11    12
    21    22
mat(1)
mat(2)
mat(3)
mat(4)
ans =
    11
ans =
    21
ans =
    12
ans =
    22
matk = mat(:)
matk =
    11
    21
    12
    22

Opracje arytmetyczne

c = a + b
d = a * b
e = inv(a)
f1 = transpose(b)
f2 = b'
c =
     2     4
     6     8
d =
     7    10
    15    22
e =
   -2.0000    1.0000
    1.5000   -0.5000
f1 =
     1     3
     2     4
f2 =
     1     3
     2     4

Mnożenie macierzowe, a mnożenie tablicowe

dm = a * b
dm =
     7    10
    15    22
dt = a .* b
dt =
     1     4
     9    16

Zastosowanie macierzy do rozwiązywania układów równań liniowych

Aany jest ukłd dwóch rówań liniowych w postaci 5*x1 + x2 = 5 6*x1 + 3*x2 = 9 Układ ten macierzowo można zapisac w postaci M * X = B a jego rozwiązanie jako X = inv(M)*B gdzie inv(M) oznacza macierz odwrotną do M

M = [5 1; 6 3]
y = [5; 9]
x = inv(M)*y
M =
     5     1
     6     3
y =
     5
     9
x =
    0.6667
    1.6667

Funkcje pozwalających na ustalenie rozmiaru tablicy

Funkcja 'size' dla wektora

sizeY = size(y)
sizeY =
     2     1

Funkcja 'size' dla macierzy

sizeX = size(X)
sizeX =
     2     3
lwX = sizeX(1)
lkX = sizeX(2)
lwX =
     2
lkX =
     3
lwX = size(X,1)
lkX = size(X,2)
lwX =
     2
lkX =
     3
[lwX lkX] = size(X)
lwX =
     2
lkX =
     3

Funkcja 'length' dla wektora i macierzy

lY = length(y)
lX = length(X)
lY =
     2
lX =
     3

Funkcja 'numel'

nY = numel(y)
nX = numel(X)
nY =
     2
nX =
     6

Wybrane funkcje zwracające podstwowe informace o wartościach elementów tablicy z argumentami wejściowymi w postaci macierzy

Wyznaczenie sumy wartości elementów macierzy

sumaM = sum(M)
sumaM =
    11     4
sumaM = sum(sum(M))
sumaM =
    15
sumaM = sum(M(:))
sumaM =
    15

Wyznaczenie maksymalnej/minimalnej wartości elementów macierzy oraz jej indeksu

max_M = max(M)
max_M =
     6     3
max_M = max(max(M))
max_M =
     6
[max_M indMaxM] = max(M)
[max_M indMaxM] = max(max(M))
max_M =
     6     3
indMaxM =
     2     2
max_M =
     6
indMaxM =
     1
[max_M indMaxM] = max(M(:))
[Wind Kind] = ind2sub(size(M),indMaxM)
max_M =
     6
indMaxM =
     2
Wind =
     2
Kind =
     1
min_M = min(M)
min_M =
     5     1