echo on
more on
format compact
clc
%======================================================================
% 4.1. ZAKLADNI MATICOVE OPERATORY A FUNKCE
%----------------------------------------------------------------------
% secitani (+), odecitani (-)
% X=A+B <=> X(r,s)=A(r,s)+B(r,s)
% X=a+B <=> X(r,s)=a+B(r,s), a skalar
% X=A+b <=> X(r,s)=A(r,s)+b, b skalar
% Podobne pro odcitani
% sum(v) = v(1)+v(2)+...+v(n), kde v je vektor
% sum(A) = [sum(A(:,1)),...,sum(A(:,n))] ... radkovy vektor sloupcovych
%                                            souctu
  a=1000; b=100; A=[-2 0 2;-1 1 3], B=[-1 0 1;0 1 2], u=5:-1:1; v=1:5;
  A+B
  A-B
pause;
%----------------------------------------------------------------------
  a+B
  A+b
pause;
%----------------------------------------------------------------------
 sum(v)
 sum(A)
pause;
clc;
%----------------------------------------------------------------------
% transpozice (.')  a hermitovsky operator (')
% X=A.' <=> X(r,s)=A(s,r)
% X=A.' <=> X(r,s)=conj(A(s,r)), kde conj() zanci komplexne sdruzene cislo
  Bt=B.'
  C=A+i*B
  C'
  C.'
pause;
clc;
%----------------------------------------------------------------------
% maticove nasobeni (*), Kroneckeruv (tensorovy) soucin (kron)
% skalarni soucin (dot), vektorovy soucin (cross)
% X=A*B <=> X(r,s)=suma{k}A(r,k)*B(k,s)
% X=a*B <=> X(r,s)=a*B(r,s), a skalar
% X=A*b <=> X(r,s)=A(r,s)*b, b skalar
% X=kron(A,B) <=> X=[A(r,s)*B]
% dot(u,v) = suma{k}conj(u(k))*v(k), kde u, v jsou vektory
% dot(A,B) = [dot(A(:,1),B(:,1)),...,dot(A(:,n),B(:,n))]
% cross(u,v)=w=[u(2)*v(3)-u(3)*v(2),u(3)*v(1)-u(1)*v(3),u(1)*v(2)-u(2)*v(1)],
%              kde u, v jsou 3-prvkove vektory (w je kolmy na u i v)
% cross(A,B) = [cross(A(:,1),B(:,1)),...,cross(A(:,n),B(:,n))]
% prod(v)  = v(1)*v(2)*...*v(n), kde v je vektor
% prod(A)  = [prod(A(:,1)),...,prod(A(:,n)) ... radkovy vektor sloupcovych
%                                               soucinu
  M=A*Bt
  a*B
  A*b
  kron(A,B)
keyboard;
clc;
%----------------------------------------------------------------------
  dot(u,v)
% je totez jako:
  u*v.', v*u.'
  dot(A,B)
pause;
%----------------------------------------------------------------------
  uu=u(1:3), vv=v(1:3), uv=[uu;vv]
  w=cross(uu,vv)
% je totez jako:
  [det(uv(:,[2,3])),-det(uv(:,[1,3])),det(uv(:,[1,2]))]
% kontrola kolmosti:
  dot(w,uu), dot(w,vv)
  cross(A.',B.')
keyboard;
clc;
%----------------------------------------------------------------------
  prod(v)    % =5! ... obecne prod(1:n)=n! (n faktorial), pricemz
  prod(1:0)  %         prod(1:0)=prod([])=1
  prod(A)
pause;
%----------------------------------------------------------------------
% Hodnost, inverze a determinant matice
% rank(A) ... hodnost matice A
% inv(A)  ... inverze ctvercove matice A
% det(A)  ... determinant matice A
% trace(A)... stopa matice (soucet prvku v hlavni diagonale)
  M
  rank(M)
  inv(M)
  inv(M)*M
  det(M)
  trace(M)
keyboard;
clc;
%======================================================================
% 4.2. OPERACE PO SLOZKACH
%----------------------------------------------------------------------
% nasobeni (.*), prave deleni (./), leve deleni(.\), umocnovani(.^)
% X=A.*B <=> X(r,s)=A(r,s)*B(r,s)
% X=a.*B <=> X(r,s)=a*B(r,s), a skalar
% X=A.*b <=> X(r,s)=A(r,s)*b, b skalar
% X=A./B=B.\A <=> X(r,s)=A(r,s):B(r,s)
% X=a./B=B.\a <=> X(r,s)=a:B(r,s), a skalar
% X=A./b=b.\A <=> X(r,s)=A(r,s):b, b skalar
% X=A.^B <=> X(r,s)=A(r,s)^B(r,s)
% X=a.^B <=> X(r,s)=a^B(r,s), a skalar
% X=A.^b <=> X(r,s)=A(r,s)^b, b skalar
  A.*B
  a.*B
  A.*b
pause;
%----------------------------------------------------------------------
  D=A./B, B.\A
pause;
%----------------------------------------------------------------------
  a./B, B.\a
pause;
%----------------------------------------------------------------------
  A./b, b.\A
pause;
%----------------------------------------------------------------------
  A.^B
  2.^B
  A.^2
keyboard;
clc;
%======================================================================
% 4.3. PRAVE (/) A LEVE (\) MATICOVE DELENI
%----------------------------------------------------------------------
% X=A\B <=> X je reseni maticove rovnice  A*X=B
%           POZOR! 2. \A=2\A neni totez jako 2.\A=2 .\A
% X=B/A <=> X je reseni maticove rovnice  X*A=B
%           POZOR! 2. /A=2/A neni totez jako 2./A=2 ./A
% B/A=(A.'\B.').' , nebot X*A=B <=> A.'*X.'=B.'
% ALGORITMUS PRO \:
% (1) A ctvercova => X=inv(A)*B (Gaussova eliminace)
%     A (skoro) singularni=> chybove varovani (reseni bez zaruky)
% (2) A nectvercova => X je (nejake) reseni ve smyslu metody nejmensich
%                      ctvercu (MNC), tj. minimalizujici euklidovskou
%                      normu ||A*X(:,s)-B(:,s)|| pro kazde s.
%     reseni vzdy existuje.
  X=A\B
  A*X-B
pause;
%----------------------------------------------------------------------
  v=v.'
  60./v,  60 ./v
% je ruzne od
  60. /v, 60/v
pause;
%----------------------------------------------------------------------
% A nectvercova
  X=B/A  %
  X*A-B
  (A.'\B.').'
pause;
%----------------------------------------------------------------------
% doplnime A na singularni ctvercovou
  A=[A;sum(A)]
  B=[B.',A(:,1)+A(:,2)]
  A\B
pause;
%----------------------------------------------------------------------
% algoritmus (1) selhal, doplnime proto radek nul na ekvivalentni
% system s nectvercovou matici soustavy, abychom mohli pouzit
% MNC algoritmus (2):
  A=[A;zeros(1,3)]
  B=[B;zeros(1,3)]
  X=A\B
  A*X-B
keyboard;   %  Vyzkousejte prave deleni
clc;
%======================================================================
% 4.4. MATICOVE UMOCNOVANI (^)
%----------------------------------------------------------------------
% (1) X = A^p, A ctvercova n x n, p skalar
% a) p>0 cele => A^p=A*A*...*A  (p-ta maticova mocnina)
  A=M
  A^2
  A^2-A*A
pause;
%----------------------------------------------------------------------
% b) p=0 => A^p=eye(n)  (jednotkova matice)
  A^0
%----------------------------------------------------------------------
% c) p<0 cele => A^p=inv(A)*inv(A)*...*inv(A)
%                 (p-ta inverzni maticova mocnina)
  A^(-2)
  A^(-2)-inv(A)*inv(A)
keyboard;
clc;
%======================================================================
% 5.1. RELACNI OPERATORY
%----------------------------------------------------------------------
% rovno (==), nerovno (~=)
% mensi (<) , mensi nebo rovno (<=)
% vetsi (>) , vetsi nebo rovno (>=)
% X=(A==B) <=> X(r,s)=1, jestlize A(r,s) rovno   B(r,s)
%              X(r,s)=0, jestlize A(r,s) nerovno B(r,s)
% X=(a==B) <=> X(r,s)=1, jestlize a rovno   B(r,s)
%              X(r,s)=0, jestlize a nerovno B(r,s)
% X=(A==b) <=> X(r,s)=1, jestlize A(r,s) rovno   b
%              X(r,s)=0, jestlize A(r,s) nerovno b
% Podobne pro ~=
% X=(A<B) <=> X(r,s)=1, jestlize real(A(r,s)) <  real(B(r,s))
%             X(r,s)=0, jestlize real(A(r,s)) >= real(B(r,s))
% X=(a<B) <=> X(r,s)=1, jestlize real(a) <  real(B(r,s))
%             X(r,s)=0, jestlize real(a) >= real(B(r,s))
% X=(A<b) <=> X(r,s)=1, jestlize real(A(r,s)) <  real(b)
%             X(r,s)=0, jestlize real(A(r,s)) >= real(b)
% kde real() znaci v MATLABu realnou cast
% Podobne pro operatory <=, > a >=
  A=[-2 0 2;-1 1 3], B=[-1 0 1;0 1 2]
  A==B
  A+i*B~=B-i*A
  A==1, 1==A
pause;
%----------------------------------------------------------------------
  A<B
  A+i*B<B-i*A
%----------------------------------------------------------------------
keyboard;  % Vyzkousejte ostatni relace
clc;
%======================================================================
% 5.2. LOGICKE OPERATORY
%----------------------------------------------------------------------
% logicka spojka "a" (&),
% logicka spojka "nebo" (|), logicka spojka "bud a nebo" (xor)
% negace (~)
% X=(A&B) <=> X(r,s)=1, jestlize A(r,s)~=0 a    B(r,s)~=0
%             X(r,s)=0, jestlize A(r,s)==0 nebo B(r,s)==0
% X=(a&B) <=> X(r,s)=1, jestlize a~=0 a    B(r,s)~=0
%             X(r,s)=0, jestlize a==0 nebo B(r,s)==0
% X=(A&b) <=> X(r,s)=1, jestlize A(r,s)~=0 a    b~=0
%             X(r,s)=0, jestlize A(r,s)==0 nebo b==0
% Podobne pro | a xor                  
% X=~A <=> X(r,s)=1, jestlize A(r,s)==0
%          X(r,s)=0, jestlize A(r,s)~=0
% Misto   A&B  lze psat   and(A,B),                               %#
% misto   A|B  lze psat   or(A,B),                                %# 
% misto    ~A  lze psat   not(A),                                 %# 
% logickou spojku xor lze vsak pouzit pouze ve tvaru xor(A,B).    %# 
  a=[0 0 1 1]
  b=[0 1 0 1]
  a&b
  a|b
  xor(a,b)
  ~a
keyboard;
clc;
%======================================================================
% 5.3. SMISENE ARITMETICKO-LOGICKE VYRAZY
%----------------------------------------------------------------------
% Logicke matice (s prvky jen 0 a 1) ziskane jako vysledek relacnich a
% logickych operaci mohou vystupovat v aritmetickych vypoctech.
% Plati pritom nasledujici prirozena priorita operatoru
% 1. umocnovani: ^ .^                          (nejvyssi priorita)
% 2. nasobeni, deleni: *  .*  \  .\  /  ./
% 3. secitani, odcitani: + -
% 4. relacni operatory: == ~= < <= > >=
% 5. negace: ~
% 6. logicke spojky "a" a "nebo":  &  |        (nejnizsi priorita)
% Jinou prioritu vymezujeme vhodnym uzavorkovanim pomoci (  a  ).
% Vsimnete si, ze jsme nikam nezaradili logickou spojku xor. To proto,      %#
% ze tato spojka se vola jako funkce, coz ji zarucuje absolutne nejvyssi    %# 
% prioritu.                                                                 %#
% Smisene vyrazy umoznuji elegantne nahradit napr. rozhodovaci
% bloky typu if-then-else.
% Priklad: v matici A chceme nahradit
%            zaporne prvky cislem -10,
%            nuly cislem 100
%            kladna cisla cislem 1
%          a vysledek ulozit do matice X
% Pomoci smiseneho vyrazu se jednoduse provede takto:
  X=-10*(A<0)+100*(A==0)+(A>0)
keyboard;    % Vyzkousejte podobne ulohy
clc;
%======================================================================
% 5.4. LOGICKE FUNKCE
%----------------------------------------------------------------------
% all(v) = v(1) & v(2) & ... & v(n), kde v je vektor
% all(A) = [all(A(:,1)),...,all(A(:,n))]
% any(v) = v(1) | v(2) | ... | v(n), kde v je vektor
% any(A) = [any(A(:,1)),...,any(A(:,n))]
  all(A)
  all(all(A))
  any(A)
  any(any(A))
keyboard;
clc;
%----------------------------------------------------------------------
% X=isinf(A)  <=> X = (A==Inf | A==-Inf)
% X=isnan(A)  <=> X = (A==NaN)
% X=isfinite(A) <=> X = (A~=Inf & A~=-Inf & A~=NaN)
  v=[pi NaN Inf -Inf]
  isinf(v)
  isnan(v)
  isfinite(v)
keyboard;
clc;
%----------------------------------------------------------------------
% isempty(A) = 1  kdyz A je prazdna matice
%            = 0  jinak
% isreal(A) = all(all(real(A)==A))
%           = 1  kdyz A je realna
%           = 0  jinak
% issparse(A) = 1 kdyz A je ridka matice
%             = 0 jinak
% isnumeric(A) = 1 kdyz A je ciselna                      %#
%              = 0 jinak                                  %#
% islogical(A) = 1 kdyz A je logicka                      %#Ve
%              = 0 jinak                                  %#Ve

  isempty(A)
  isempty([])
  isreal(A)
  A(1,2)=1+i
  isreal(A)
  issparse(A)
  islogical(A)                                %#Ve
  islogical(A<0)                              %#Ve
pause;
%----------------------------------------------------------------------
% isstr(A)  = 1 kdyz A je textova matice
%           = 0 jinak
% X=isletter(A) <=> X(r,s)=1 jestlize A(r,s) je ASCII kod pismene
%                   X(r,s)=0 jinak
% X=isspace(A)  <=> X(r,s)=1 jestlize A(r,s) je ASCII kod bileho znaku %#Ve 
%                   X(r,s)=0 jinak                            %#Ve
% bile znaky jsou: mezera, novy radek (LF), navrat vozu (CR), %#Ve
%                  tabulatory (HT a VT), nova stranka (FF).   %#Ve
  t = [49 '. text']
  isstr(A)
  isstr(t)
  isnumeric(t)                       %#Ve
  isspace(t)                         %#Ve                       
  isletter(t)
%----------------------------------------------------------------------
keyboard;
clc;
%----------------------------------------------------------------------
% Vyhledavani nenulovych prvku v matici
% I = find(v) ... pro  vektor v,
%     I = [i_1,i_2,...,i_n] ... indexy nenulovych prvku ve v.
% [I,J]  = find(A)
% nebo
% [I,J,H]= find(A) ... pro matici
%          I=[i_1,i_2,...,i_n] ... radkove indexy nenulovych prvku v A.
%          J=[j_1,j_2,...,j_n] ... sloupcove indexy nenulovych prvku v A.
%          H=[h_1,h_2,...,h_n] ... hodnoty nenulovych prvku v A (nepovinny)
%          Tedy [i_k,j_k] jsou souradnice k-ho nenuloveho prvku v A
%          a h_k je jeho hodnota.
% I, J a H jsou prazdne matice, pokud v, resp. A je nulova matice
  a
  I = find(a)
pause;
%----------------------------------------------------------------------
  v
  I = find(v)
pause;
%----------------------------------------------------------------------
  t
  I = find(t=='t')
pause;
%----------------------------------------------------------------------
  A=[-2 0 2;-1 1 3]
  [I,J] = find(A)
pause;
  [I,J,H] = find(A)
pause;
  [I,J] = find(A<0)
pause;
%----------------------------------------------------------------------
  [I,J,H] = find(A<0)
  [I,J,H] = find(A>5)
  echo on                                 %#
%# I,J,H jsou prazdne matice. Pod WINDOWS to zpusobi prepnuti do rezimu
%# echo off, proto je umele zarazen prikaz echo on  
keyboard;
clc;
%----------------------------------------------------------------------
% test existence promennych a prikazu daneho jmena
% h=exist('jmeno')
%  = 0 ... neexistuje
%  = 1 ... promenna
%  = 2 ... m-soubor v beznem adresari nebo v MATLABPATH
%  = 3 ... MEX-soubor v beznem adresari nebo v MATLABPATH
%  = 4 ... kompilovana funkce v systemu SIMULINK
%  = 5 ... interni (predkompilovana) funkce MATLABu
%  = 6 ... predkompilovana m-funkce s nazvem jmeno.p. Soubor jmeno.p lze    %#
%          vytvorit pomoci prikazu pcode (viz. help pcode).                 %#
%  = 7 ... adresar                                                          %#
%  Priorita pri kolizi jmen (existuji ruzne objekty tehoz jmena):
%  1. promenna
%  2. interni funkce
%  3. funkce MEX (napred bezny adresar, pak MATLABPATH od zacatku)
%  4. prikaz jako p-soubor (napred bezny adresar, pak MATLABPATH od zacatku)   %#
%  5. prikaz jako m-soubor (napred bezny adresar, pak MATLABPATH od zacatku)   %#
   exist('A')
   exist('xxxxx')
   exist('rank')
   exist('type')
   pcode rank; exist('rank'), delete rank.p       %#
   h=cd; exist(h)                                 %#
keyboard;
clc;
%----------------------------------------------------------------------
% ishold ... viz prace s grafy
%================================= KONEC ==============================
more off
echo off
