Contents

Wektoryzacja

vec = [3 7 2 1]
for i = 1:length(vec)
    vec(i) = vec(i)*3;
end
vec
vec =
     3     7     2     1
vec =
     9    21     6     3
vec = vec*3
vec =
    27    63    18     9

Wektory logiczne

vec = [5 9 3 4 6 11]
vec =
     5     9     3     4     6    11
isg = vec > 5
isg =
     0     1     0     0     1     1
vecg5 = isg * 5
vecg5 =
     0     5     0     0     5     5
sum(isg)
ans =
     3
vec(isg)
ans =
     9     6    11
type testvecgtn
function outvec = testvecgtn(vec,n)
% Compare each element in vec to see whether it
% is greater than n or not

outvec = logical(zeros(size(vec)));
for i = 1:length(vec)
    % Each element in the output vector stores 1 or 0
    if vec(i) > n
        outvec(i) = 1;
    else
        outvec(i) = 0;
    end
end
isg1 = testvecgtn(vec,5)
isg1 =
     0     1     0     0     1     1

Wbudowane funkcje logiczne

vec1 = [5 9 3 4 6 11]
vec1 =
     5     9     3     4     6    11
jakikolwiek = any(vec1)
wszystkie = all(vec1)
jakikolwiek =
     1
wszystkie =
     1
vec2 = [5 0 3 0 6 1]
vec2 =
     5     0     3     0     6     1
jakikolwiek = any(vec2)
wszystkie = all(vec2)
jakikolwiek =
     1
wszystkie =
     0
type myall
function logresult = myall(vec)
% Simulates the built-in function "all"
 
% count how many values are true
count = 0;
for i = 1:length(vec)
    if vec(i) ~= 0
        count = count + 1;
    end
end
 
% if all were true, return 1 else return 0
if count == length(vec)
    logresult = logical(1);
else
    logresult = logical(0);
end
myall(vec1)
myall(vec2)
ans =
     1
ans =
     0
type myany
function logresult = myany(vec)
% Simulates the built-in function "any"

% Assume 0 for the result
logresult = logical(0);

for i = 1:length(vec)
    % if any value is not false, the result will be 1
    if vec(i) ~= 0
        logresult = logical(1);
    end
end
myany(vec1)
myany(vec2)
ans =
     1
ans =
     1
mat1 = [4:6; 3:-1:1]
mat2 = [1:3; 3:-1:1]
mat1 =
     4     5     6
     3     2     1
mat2 =
     1     2     3
     3     2     1
mat1 == mat2
sum(all(mat1 == mat2))
ans =
     0     0     0
     1     1     1
ans =
     0
isequal(mat1, mat2)
ans =
     0
vec1 = [3 0 5 1];
vec2 = [0 0 2 0];
vec1 & vec2
vec1 | vec2
ans =
     0     0     1     0
ans =
     1     0     1     1

Pętla while

cumprod(1:5)
factgthigh(8)
ans =
     1     2     6    24   120
ans =
    24
type myanywhile
function logresult = myanywhile(vec)
% Simulates the built-in function "any"
% Uses a while loop so that the action halts
% as soon as any "true" value is found

logresult = logical(0);
i = 1;
vec = vec(:);
while i <= length(vec) && logresult == 0
    if vec(i) ~= 0
        logresult = logical(1);
    end
    i = i + 1;
end
myanywhile(vec1)
myanywhile(vec2)
ans =
     1
ans =
     1

Funkcja find

type findvalwhile
% Reads data from a file, but only plots the numbers
% up to a flag of -99.  Uses a while loop.

load experd.dat
 
i = 1;
newvec = zeros(size(experd));
while experd(i) ~= -99
    newvec(i) = experd(i);
    i = i + 1;
end
newvec(i:end) = []; 
plot(newvec,'k-o')
findvalwhile
type findval
% Reads data from a file, but only plots the numbers
% up to a flag of -99.  Uses find and the colon operator.

load experd.dat

where = find(experd == -99);
newvec = experd(1:where-1);

plot(newvec,'k-o')
findval

Input i while

type whileposnum
% whileposnum % wywołanie skrypu zakomentowane z powodu funkcji input
% Prompts the user and echo prints the numbers entered
% until the user enters a negative number

inputnum=input('Enter a positive number: ');
while inputnum >= 0
    fprintf('You entered a %d.\n\n',inputnum)
    inputnum = input('Enter a positive number: ');
end
fprintf('OK!\n')


Zliczanie z while

type countposnum
% Prompts the user for positive numbers and echo prints as
% long as the user enters positive numbers

% Counts the positive numbers entered by the user
counter=0;
inputnum=input('Enter a positive number: ');
while inputnum >= 0
    fprintf('You entered a %d.\n\n',inputnum)
    counter = counter + 1;
    inputnum = input('Enter a positive number: ');
end
fprintf('Thanks, you entered %d positive numbers\n',counter)

countposnum % wywołanie skrypu zakomentowane z powodu funkcji input

Kontrola błędów z while

type readonenum
% Loop until the user enters a positive number

inputnum=input('Enter a positive number: ');
while inputnum < 0
    inputnum = input('Invalid! Enter a positive number: ');
end
fprintf('Thanks, you entered a %.1f \n',inputnum)

readonenum % wywołanie skrypu zakomentowane z powodu funkcji input

type readoneint
% Error-check until the user enters an integer
inputnum = input('Enter an integer: ');
num2 = int32(inputnum);
while num2 ~= inputnum
    inputnum = input('Invalid! Enter an integer: ');
    num2 = int32(inputnum);
end
fprintf('Thanks, you entered a %d \n',inputnum)

readoneint % wywołanie skrypu zakomentowane z powodu funkcji input

type readoneposint
% Error checks until the user enters a positive integer
inputnum = input('Enter a positive integer: ');
num2 = int32(inputnum);
while num2 ~= inputnum || num2 < 0
    inputnum = input('Invalid! Enter a positive integer: ');
    num2 = int32(inputnum);
end
fprintf('Thanks, you entered a %d \n',inputnum)

readoneposint % wywołanie skrypu zakomentowane z powodu funkcji input

Struktury. Tworzenie. Modyfikacja. Wyświetlanie zawartości

clear all
pakiet.numer = 123
pakiet.koszt = 19.99
pakiet.cena = 39.95
pakiet.kod = 'g'
pakiet = 
    numer: 123
pakiet = 
    numer: 123
    koszt: 19.9900
pakiet = 
    numer: 123
    koszt: 19.9900
     cena: 39.9500
pakiet = 
    numer: 123
    koszt: 19.9900
     cena: 39.9500
      kod: 'g'
PAKIET = struct('numer',123,'koszt',19.99,'cena',39.95,'kod','g')
PAKIET = 
    numer: 123
    koszt: 19.9900
     cena: 39.9500
      kod: 'g'
nowy_pakiet = pakiet
nowy_pakiet.numer = 111
nowy_pakiet.cena = 34.95
nowy_pakiet
nowy_pakiet = 
    numer: 123
    koszt: 19.9900
     cena: 39.9500
      kod: 'g'
nowy_pakiet = 
    numer: 111
    koszt: 19.9900
     cena: 39.9500
      kod: 'g'
nowy_pakiet = 
    numer: 111
    koszt: 19.9900
     cena: 34.9500
      kod: 'g'
nowy_pakiet = 
    numer: 111
    koszt: 19.9900
     cena: 34.9500
      kod: 'g'
disp(pakiet)
    numer: 123
    koszt: 19.9900
     cena: 39.9500
      kod: 'g'
disp(pakiet.koszt)
   19.9900
fprintf('%d %c \n', pakiet.numer, pakiet.kod)
123 g 
rmfield(nowy_pakiet,'kod')
disp(nowy_pakiet)
ans = 
    numer: 111
    koszt: 19.9900
     cena: 34.9500
    numer: 111
    koszt: 19.9900
     cena: 34.9500
      kod: 'g'
nowy_pakiet = rmfield(nowy_pakiet,'kod')
nowy_pakiet = 
    numer: 111
    koszt: 19.9900
     cena: 34.9500

Przekazywanie struktury do funkcji

type calcprof
function profit = calcprof(packstruct)
% Calculates the profit for a software package
% The entire structure is passed to the function
profit = packstruct.cena - packstruct.koszt;
calcprof(pakiet)
ans =
   19.9600
type calcprof2
function profit = calcprof(cena,koszt)
% Calculates the profit for a software package
% The entire structure is passed to the function
profit = cena - koszt;
calcprof2(pakiet.cena, pakiet.koszt)
ans =
   19.9600

Funkcje powiązane z klasą struct

isstruct(pakiet)
ans =
     1
isfield(pakiet,'koszt')
ans =
     1
pola_pakiet = fieldnames(pakiet)
length(pola_pakiet{2})
pola_pakiet = 
    'numer'
    'koszt'
    'cena'
    'kod'
ans =
     5
type spr_nazwy_pola
input_pole = input('Podaj nazwę pola, którego wartosć wyświetlić: ','s');
if isfield(pakiet, input_pole)
    fprintf('Wartość pola %s wynosi: %.2f\n', ...
        input_pole, eval(['pakiet.' input_pole ';']));
else
    fprintf('Błąd: %s nie jest oprawną nazwa pola\n', input_pole)
end

spr_nazwy_pola % input

Wektory struktur. Tworzenie i wykorzystanie.

% Tworzenie przyrostowe - niekorzystne
pakiet(1) = struct('numer',123,'koszt',19.99,'cena',39.95,'kod','g')
pakiet(2) = struct('numer',124,'koszt',9.99,'cena',25.95,'kod','w')
pakiet(3) = struct('numer',125,'koszt',11.11,'cena',31.99,'kod','p')
pakiet = 
    numer: 123
    koszt: 19.9900
     cena: 39.9500
      kod: 'g'
pakiet = 
1x2 struct array with fields:
    numer
    koszt
    cena
    kod
pakiet = 
1x3 struct array with fields:
    numer
    koszt
    cena
    kod
% Tworzenie od ostatniego elementu - inicjalizacja z czesciową alokacją
pakiet(3) = struct('numer',125,'koszt',11.11,'cena',31.99,'kod','p')
pakiet(2) = struct('numer',124,'koszt',9.99,'cena',25.95,'kod','w')
pakiet(1) = struct('numer',123,'koszt',19.99,'cena',39.95,'kod','g')
pakiet = 
1x3 struct array with fields:
    numer
    koszt
    cena
    kod
pakiet = 
1x3 struct array with fields:
    numer
    koszt
    cena
    kod
pakiet = 
1x3 struct array with fields:
    numer
    koszt
    cena
    kod
% Inicjalizacja z pełną alokacją
pakiet = repmat(struct('numer',123,'koszt',19.99,'cena',39.95,'kod','g'),1,3)
pakiet(2) = struct('numer',124,'koszt',9.99,'cena',25.95,'kod','w')
pakiet(3) = struct('numer',125,'koszt',11.11,'cena',31.99,'kod','p')
pakiet = 
1x3 struct array with fields:
    numer
    koszt
    cena
    kod
pakiet = 
1x3 struct array with fields:
    numer
    koszt
    cena
    kod
pakiet = 
1x3 struct array with fields:
    numer
    koszt
    cena
    kod
% Odwoływanie się do pola danego elementu wektora struktur
pakiet(2)
 pakiet(1).kod
ans = 
    numer: 124
    koszt: 9.9900
     cena: 25.9500
      kod: 'w'
ans =
g
% Wyświetlanie zawartości elementów wektora struktur
for i = 1:length(pakiet)
    disp(pakiet(i))
end
    numer: 123
    koszt: 19.9900
     cena: 39.9500
      kod: 'g'
    numer: 124
    koszt: 9.9900
     cena: 25.9500
      kod: 'w'
    numer: 125
    koszt: 11.1100
     cena: 31.9900
      kod: 'p'
for i = 1:length(pakiet)
    fprintf('%f\n',pakiet(i).koszt)
end
19.990000
9.990000
11.110000
fprintf('%f\n',pakiet.koszt)
19.990000
9.990000
11.110000
% Wektoryzacja

pakiet.koszt
ans =
   19.9900
ans =
    9.9900
ans =
   11.1100
pk = pakiet.koszt
pk =
   19.9900
pk = [pakiet.koszt]
pk =
   19.9900    9.9900   11.1100
sum([pakiet.koszt])
ans =
   41.0900
type printpakiet
function printpackages(packstruct)
% This function prints a table showing all
% values from a vector of packages structures

fprintf('\n  Numer Koszt  Cena   Kod\n\n')
no_packs = length(packstruct);
for i = 1:no_packs
    fprintf('%6d %6.2f %6.2f %3c\n', ...
        packstruct(i).numer, ...
        packstruct(i).koszt, ...
        packstruct(i).cena, ...
        packstruct(i).kod)
end
printpakiet(pakiet)
  Numer Koszt  Cena   Kod

   123  19.99  39.95   g
   124   9.99  25.95   w
   125  11.11  31.99   p
% Złożone wektory struktur
student(3) = struct('name','Kowalski, Jan','id_no',332,'quiz',[5 4.5 4 5 3.5 4 4.5]);
student(1) = struct('name','Nowak, Ewa','id_no',321,'quiz',[5 4 4.5 4.5 3.5 3.5]);
student(2) = struct('name','Banach, Karolina','id_no',327,'quiz',[5 4.5 4.5 5 3.5 4.5 4.5]);
student
student = 
1x3 struct array with fields:
    name
    id_no
    quiz
disp(student(1))
     name: 'Nowak, Ewa'
    id_no: 321
     quiz: [5 4 4.5000 4.5000 3.5000 3.5000]
type print_aves
function print_aves(student)
% This function prints the average quiz grade
% for each student in the vector of structs

fprintf('%-20s %-10s\n', 'Name', 'Average')
for i = 1:length(student)
    qsum = sum([student(i).quiz]);
    no_quizzes = length(student(i).quiz);
    ave = qsum / no_quizzes;
    fprintf('%-20s %.1f\n', student(i).name, ave);
end
        
print_aves(student)
Name                 Average   
Nowak, Ewa           4.2
Banach, Karolina     4.5
Kowalski, Jan        4.4

Struktury zagnieżdżone

% Tworzenie
linseg = struct('endpoint1',struct('x',2,'y',4),'endpoint2',struct('x',1,'y',6))
linseg = 
    endpoint1: [1x1 struct]
    endpoint2: [1x1 struct]
linseg
linseg = 
    endpoint1: [1x1 struct]
    endpoint2: [1x1 struct]
linseg.endpoint1
ans = 
    x: 2
    y: 4
linseg.endpoint1.x
ans =
     2
point1 = struct('x',5,'y',11);
point2 = struct('x',7,'y',9);
myline = struct('endpoint1',point1,'endpoint2', point2)
myline = 
    endpoint1: [1x1 struct]
    endpoint2: [1x1 struct]
myline.endpoint1
ans = 
    x: 5
    y: 11
myline.endpoint2.x
ans =
     7
cyls(3) = struct('code','c','dimensions',struct('rad',3,'height',6), 'weight',9);
cyls(1) = struct('code','x','dimensions',struct('rad',3,'height',6), 'weight',7);
cyls(2) = struct('code','a','dimensions',struct('rad',4,'height',2), 'weight',5);
type printcylvols
function printcylvols(cyls)
% This function prints the volumes of each cylinder
%  It calls a subfunction to calculate each volume
 
for i = 1:length(cyls)
    vol = cylvol(cyls(i).dimensions);
    fprintf('Cylinder %c has a volume of %.1f inches\n', ...
       cyls(i).code, vol);
end
 
function cvol = cylvol(dims)
% Calculates the volume of a cylinder
cvol = pi * dims.rad ^ 2 * dims.height;
printcylvols(cyls)
Cylinder x has a volume of 169.6 inches
Cylinder a has a volume of 100.5 inches
Cylinder c has a volume of 169.6 inches