Элементы языка программирования в MatLab

невозможно описывать сложные данные, такие как случайный сигнал, поступающий на

вход фильтра или хранить кадр изображения и т.п. Поэтому в языках высокого уровня предусмотрена возможность описывать, выполнять преобразования и хранить значения в виде массивов.
В MatLab эту роль выполняют векторы и матрицы.
Пример задания вектора с именем a содержащего значения 1, 2, 3, 4:
a = [1 2 3 4]; % вектор-строка
a = [1;2;3;4]; % вектор-столбец
Для доступа к тому или иному элементу вектора используется следующая конструкция языка:
disp(a(1)); % отображение значения 1-го элемента вектора а
disp(a(4)); % отображение значения 4-го элемента вектора а
a(2) = 10; % изменение значения 2-го элемента на 10
Часто возникает необходимость определения общего числа элементов в векторе, т.е. определения его размера. Это можно сделать, воспользовавшись функцией length() следующим образом:
N = length(a); % (N=4) число элементов массива а

не только из отдельных чисел или переменных, но и из

векторов.
» a = [1 2 3 4]; % начальный вектор a = [1 2 3 4]
» b = [a 5 6]; % второй вектор b = [1 2 3 4 5 6]
Используя этот прием, можно осуществлять увеличение размера векторов в процессе работы программы:
» a = [a 5]; % увеличение вектора а на один элемент
Чтобы решить задачу определения векторов больших размеров, в MatLab существуют функции инициализации векторов нулями, единицами или случайными значениями:

» a1=zeros(1,100); % вектор-строка, 100 элементов с нулевыми значениями
» a2=zeros(100,1); % вектор-столбец, 100 элементов с нулевыми значениями
» a3=ones(1,10); % вектор-строка, 10 элементов с единичными значениями
» a4=ones(10,1); % вектор-столбец, 10 элементов с единичными значениями
» a5=rand(10,1); % вектор-столбец, 10 элементов со случайными значениями

с той лишь разницей, что указываются обе размерности.
Пример инициализации

единичной матрицы размером 3х3:
» E = [1 0 0; 0 1 0; 0 0 1]; % единичная матрица 3х3
E = [1 0 0
0 1 0
0 0 1];
Аналогичным образом можно задавать любые другие матрицы, а также использовать приведенные выше функции zeros(), ones() и rand(), например:
» A1 = zeros(10,10); % нулевая матрица 10х10 элементов
» A2 = zeros(10); % нулевая матрица 10х10 элементов
» A3 = ones(5); % матрица 5х5, состоящая из единиц
» A4 = rand(100); % матрица 100х100, из случайных чисел

такой же синтаксис как и для векторов, но с указанием

строки и столбца где находится требуемый элемент:
» A = [1 2 3;4 5 6;7 8 9]; % инициализация матрицы размерностью 3х3
» disp(A(2,1)) % вывод на экран элемента (вторая строка первый столбец)
4
Также возможны операции выделения указанной части матрицы, например:
» B1 = A(:,1) % B1 = [1; 4; 7] – выделение первого столбца
В1= 1 4 7
» B2 = A(2,:); % B2 = [1 2 3] – выделение первой строки
» B3 = A(1:2,2:3); % B3 = [2 3; 5 6] – выделение первых двух строк и 2-го и 3-го столбцов матрицы А.
Размерность матрицы или вектора в MatLab можно определить с помощью функции size(), которая возвращает число строк и столбцов переменной, указанной в качестве аргумента:

» size(А) % определение размерности матрицы A
ans = 3 3 (размерность матрицы А (3 х 3)
» size(B1) % определение размерности вектора В1
ans = 3 1 (размерность вектора В1 (3 х 1)

математические операции над матрицами и векторами. Пусть даны два вектора
»

a = [1 2 3 4 5]; % вектор-строка
» b = [1;1;1;1;1]; % вектор-столбец
тогда умножение этих двух векторов можно записать так
» c = a*b; % c = 1+2+3+4+5=16
» d = b*a; % d – матрица 5х5 элементов
Умножение вектор-строки на вектор-столбец дает число, а умножение вектор-столбца на вектор-строку дает двумерную матрицу.
В нашем примере:

a1 = [1 2 3 4 5];
» a2 =

[5 4 3 2 1];
» c = a1+a2; % c = [1+5, 2+4, 3+3, 4+2, 5+1];
» с = a2-a1; % c = [5-1, 4-2, 3-3, 2-4, 1-5];
Операции сложения и вычитания можно выполнять между двумя векторами-столбцами или двумя векторами-строками. Иначе MatLab выдаст сообщение об ошибке, т.к. разнотипные векторы складывать нельзя.
Аналогичным образом выполняются операции умножения и сложения между матрицами:
» A = [1 2 3; 4 5 6; 7 8 9]; % определение матрицы 3х3
» B = ones(3); % определение матрицы 3х3, состоящая из единиц
» C = A+B; % сложение двух матриц одинакового размера
» D = A+5; % сложение матрицы и числа
» E = A*B; % умножение матрицы А на В
» F = B*A; % умножение матрицы В на А
» G = 5*A; % умножение матрицы на число

и векторов
a = [2 2 2]; % вектор-строка
b

= a’ % вектор-столбец, полученный транспонированием вектора-строки а

A = [1 2 3; 4 5 6; 7 8 9]; % матрица 3х3 элемента
B = a*A; % B = [24 30 36] – вектор-строка
C = A*b; % C = [12; 30; 48] – вектор-столбец
D = a*A*a’; % D = 45 – число, сумма элементов матрицы А
E = A’; % E – транспонированная матрица А
F = inv(A); % F – обратная матрица матрицы А
G = A^-1; % G – обратная матрица матрицы А

умножить, разделить или возвести в степень элементы вектора или матрицы,

то для этого используются операторы:
.* - поэлементное умножение; ./ - поэлементное деление;
.^ - поэлементное возведение в степень.
Рассмотрим работу данных операторов на следующем примере.
» a = [1 2 3]; b = [3 2 1]; % инициация двух вектор-строки
» c = a.*b % поэлементное умножение векторов (результат
» A = ones(3) % инициация матрицы А 3х3, из единиц
» B = [1 2 3;4 5 6; 7 8 9] % инициация матрицы В 3х3» C = A.*B

» D = A./B

» E = A.\B

» F = В.^2

используется стандартная функция max(), которая возвращает найденное максимальное значение элемента

и его позицию (индекс), если это необходимо:
a = [1 6 3 4];
[v, i] = max(a); % v = 6, i = 2;
или
v = max(a); % v = 6;
В случае с матрицами, данная функция определяет максимальные значения, стоящие в столбцах, как показано ниже в примере:
A =[4 3 5; 6 7 2; 3 1 8];
[V,I] = max(A); % V=[6 7 8], I = [2 2 3]
V = max(A); % V=[6 7 8]

Полный синтаксис функции max() можно узнать, набрав в командном окне MatLab команду
help <название функции>
Аналогичным образом работает функция min(), которая определяет минимальное значение элемента вектора или матрицы и его индекс.

и векторами является функция sum(), которая вычисляет сумму значений элементов

вектора или столбцов матрицы:
a = [3 5 4 2 1];
A = [4 3 5; 6 7 2; 3 1 8];
s = sum(a); % s = 3+5+4+2+1=15
S1 = sum(A); % S1 = [13 11 15]
S2 = sum(sum(A)); % S2 = 39
При вычислении суммы S2 сначала вычисляется сумма значений элементов матрицы А по столбцам, а затем, по строкам. В результате, переменная S2 содержит сумму значений всех элементов матрицы А.
Для сортировки значений элементов вектора или матрицы по возрастанию или убыванию используется функция sort() следующим образом:
a = [3 5 4 2 1];
b1 = sort(a); % b1 = [1 2 3 4 5]
b2 = sort(a, ‘descend’); % b2 = [5 4 3 2 1]
b3 = sort(a, ‘ascend’); % b3 = [1 2 3 4 5]
для матриц
A = [4 3 5; 6 7 2; 3 1 8];
B1 = sort(A); % B1 = [3 1 2; 4 3 5; 6 7 8]
B2 = sort(A, ‘descend’); % B2 = [6 7 8; 4 3 5; 3 1 2]

найти определенный элемент в векторе или матрице. Это можно выполнить

с помощью стандартной функции find(), которая в качестве аргумента принимает условие, в соответствии с которым и находятся требуемые элементы, например:
a = [3 5 4 2 1];
b1 = find(a == 2); % b1 = 4 – индекс элемента 2
b2 = find(a ~= 2); % b2 = [1 2 3 5] – индексы без 2
b3 = find(a > 3); % b3 = [2 3]
В приведенном примере символ == означает проверку на равенство, а символ ~= выполняет проверку на неравенство значений элементов вектора а.
Еще одной полезной функцией работы с векторами и матрицами является функция mean() для вычисления среднего арифметического значения, которая работает следующим образом:
a = [3 5 4 2 1];
m = mean(a); % m = 3
A = [4 3 5; 6 7 2; 3 1 8];
M1 = mean(A); % M1 = [4.333 3.667 5.000]
M2 = mean(mean(A)); % M2 = 4.333

представления данных. Во многих случаях недостаточно объявить простую переменную или

массив, а нужна более гибкая форма представления данных. Таким элементом может быть структура, которая позволяет включать в себя разные типы данных и даже другие структуры.
S = struct('field1',VALUES1,'field2',VALUES2,...);

где field1 – имя первого поля структуры; VALUES1 – переменная первого поля структуры, и т.д.
Приведем пример, в котором использование структуры позволяет эффективно представить данные. Таким примером будет инвентарный перечень книг, в котором для каждой книги необходимо указывать ее наименование, автора и год издания. Причем количество книг может быть разным, но будем полгать, что не более 100. Для хранения информации об одной книге будем использовать структуру, которая задается в MatLab с помощью ключевого слова struct следующим образом:

S = struct('title','','author','','year',0);

В итоге задается структура с тремя полями: title, author и year. Каждое поле имеет свой тип данных и значение.

значения используется оператор ‘.’ (точка) для доступа к тому или

иному полю структуры:
S.title = 'Евгений Онегин';
S.author = 'Пушкин';
S.year = 2000;
Однако по условиям задачи необходимо осуществлять запись не по одной, а по 100 книгам. В этом случае целесообразно использовать вектор структур lib, который можно задать следующим образом:
lib(100,1) = struct('title','','author','','year',0);
и записывать информацию о книгах так:
lib(1).title = 'Евгений Онегин';
lib(1).author = 'Пушкин';
lib(1).year = 2000;
Данный пример показывает удобство хранения информации по книгам. Графически массив структур можно представить в виде таблицы, в которой роль столбцов играют поля, а роль строк элементы массива структур.

S ) – возвращает истину, если

аргумент структура
isfield( S, 'name') – возвращает истину, если имеется поле с именем ‘name’
fieldnames( S ) – возвращает массив строк с именами всех полей

которые позволяют программно определить всю необходимую информацию о той или иной структуре и корректно выполнять обработку ее полей.

типы данных, объединенные одной переменной, но в отличии от вектора

структур, вектор ячеек может менять тип данных в каждом элементе.
Таким образом, вектор ячеек является универсальным контейнером – его элементы могут содержать любые типы и структуры данных, с которыми работает MatLab – векторы чисел любой размерности, строки, векторы структур и другие (вложенные) векторы ячеек.
Методы создания вектора ячеек похожи на методы создания вектора структур. Как и в случае структур, векторы ячеек могут быть созданы либо путём последовательного присваивания значений отдельным элементам массива, либо созданы целиком при помощи специальной функции cell(). Однако в любом случае важно различать ячейку (элемент вектора ячеек) и её содержимое.
Ячейка – это содержимое плюс некоторая оболочка (служебная структура данных) вокруг этого содержимого, позволяющая хранить в ячейке произвольные типы данных любого размера.

= struct('title','Онегин','author','Пушкин','year',2000);
MyCell(1)={book};
MyCell(2)={'Пушкин'};
MyCell(3)={2000};
Здесь задан вектор ячеек с именем

MyCell с тремя элементами. Первый элемент соответствует структуре, второй – строке, а третий – числу. В этом и заключается особенность организации данных с помощью ячеек: у каждого элемента свой тип данных.

ячейки используются фигурные скобки, внутри которых ставится индекс элемента с

которым предполагается работа, например:
MyCell{1}
выведет на экран
title: 'Евгений Онегин'
author: 'Пушкин'
year: 2000
Если же используются круглые скобки, то будет возвращена структура данных вместо отдельных значений, например
MyCell(1)
выведет
[1x1 struct]
Для того чтобы задать вектор или матрицу ячеек с пустыми (неопределен-ными) значениями, используется функция cell() как показано ниже.
MyCellArray = cell(2, 2);
задается матрица размером 2х2. Данную инициализацию целесообразно выполнять когда нужно определить большой вектор или матрицу ячеек и в цикле задавать их значения. В этом случае MatLab сразу создает массивы нужных размеров, в результате чего повышается скорость выполнения программ.

аргументов благодаря использованию ячеек. Для этого в качестве аргумента функции

указывается ключевое слово varargin, которое интерпретируется внутри функции как вектор ячеек с переданными аргументами:

function len = SumSquare( varargin )
n= length( varargin );
len = 0;
for k = 1 : n
len = len + varargin{ k }(1)^2 +varargin{ k }(2)^2;
end

Данная функция вычисляет сумму квадратов чисел, которые передаются ей следующим образом:

SumSquare( [ 1 2], [3 4] ) % ответ 30
SumSquare( [ 1 2], [3 4], [ 5 6] ) % ответ 91

Таким образом, благодаря использованию ячеек функции SumSquare() можно передавать произвольное число двумерных векторов.

данных, создания полноценных программ на языке MatLab является изучение операторов

ветвления и циклов.
С их помощью можно реализовывать логику выполнения математических алгоритмов и создавать повторяющиеся (итерационные, рекуррентные) вычисления.
Условный оператор if
Умозрительно эти операторы можно представить в виде узловых пунктов, достигая которых программа делает выбор по какому из возможных направлений двигаться дальше. В самом простом случае синтаксис данного оператора if имеет вид:
if <выражение>
<операторы>
end
Если значение параметра «выражение» соответствует значению «истинно», то выполняется оператор, иначе он пропускается программой. Следует отметить, что «выражение» является условным выражением, в котором выполняется проверка некоторого условия

выражения

оператора if :
Три варианта функции пользователя my_sign(), возвращает +1,

если число больше нуля; -1 – если число меньше нуля и 0, если число равно нулю:
Вариант 1 Вариант 2 Вариант 3








Анализ приведенного примера показывает, что все эти три условия являются взаимоисключающими, т.е. при срабатывании одного из них нет необходимости проверять другие. Реализация именно такой логики позволит увеличить скорость выполнения программы (варианты 2 и 3).

условного оператора if можно выполнять проверку более сложных (составных) условий.

Например, необходимо определить: попадает ли переменная x в диапазон значений от 0 до 2?
Это можно реализовать одновременной проверкой сразу двух условий:
x>=0 и x<=2
Если эти оба условия истинны, то x попадает в диапазон от 0 до 2.
Для реализации составных условий в MatLab используются логические операторы:



Программа вышеуказанной задачи запишется следующим образом:
x = 1;
if x >= 0 & x <= 2
disp('x принадлежит диапазону от 0 до 2');
else
disp('x не принадлежит диапазону от 0 до 2');
end

операторы И, ИЛИ, НЕ, можно создавать разнообразные составные условия. Например,

можно сделать проверку, что переменная x попадает в диапазон от -5 до 5, но не принадлежит диапазону от 0 до 1. Очевидно, это можно реализовать следующим образом:
function my_if
x = 1;
if (x >= -5 & x <= 5) & (x < 0 | x > 1)
disp('x принадлежит [-5, 5], но не входит в [0, 1]');
else
disp('x или не входит в [-5, 5] или в [0, 1]');
end
Обратите внимание, что при сложном составном условии были использованы круглые скобки. Дело в том, что приоритет операции И выше приоритета операции ИЛИ, и если бы не было круглых скобок, то условие выглядело бы так: (x >= -5 и x <= 5 и x < 0) или x > 1. Очевидно, что такая проверка давала бы другой результат от ожидаемого.
Круглые скобки в программировании используются для изменения приоритетов выполнения операторов. Подобно арифметическим операторам, логические также могут быть изменены по желанию программиста. Благодаря использованию круглых скобок, сначала выполняется проверка внутри них, а, затем, за их пределами. Именно поэтому в приведенном выше примере они необходимы для достижения требуемого результата.


.

задачах программирования требуется выполнять проверку на равенство некоторой переменной константным

значениям. Для решения таких задач удобнее пользоваться условным оператором switch.
Пример работы данного оператора для преобразования малых букв латинского алфавита в заглавные.
function upper_symbol
ch='c';
switch ch
case 'a', ch='A';
case 'b', ch='B';
case 'c', ch='C';
case 'd', ch='D';
...
case 'z', ch='Z';
end
disp(ch);
В данной программе задается символьная переменная ch со значением c. Затем, с помощью оператора switch проверяется ее значение со всеми возможными малыми буквами латинского алфавита от а до z. Как только одно из условий сработало, оператор switch завершает свою работу и выполнение программы переходит на функцию disp(), которая отображает значение переменной ch на экран.

MatLab имеет два оператора цикла: while и for. С

их помощью, например, выполняется программирование рекуррентных алгоритмов, подсчета суммы ряда, перебора элементов массива и многое другое.
В самом простом случае цикл в программе организуется с помощью оператора while, который имеет следующий синтаксис:
while <условие>
<операторы>
end
Здесь <условие> означает условное выражение подобное тому, которое применяется в операторе if.
Цикл while работает до тех пор, пока это условие истинно.
Следует обратить внимание на то, что если условие будет ложным до начала выполнения цикла, то операторы, входящие в цикл, не будут выполнены ни разу.

работы цикла while для подсчета суммы ряда :
function sum_i
S

= 0; % начальное значение суммы
i=1; % счетчик суммы
while i <= 20 % цикл (работает пока i <= 20)
S=S+i; % подсчитывается сумма
i=i+1; % увеличение счетчика на 1
end % конец цикла
Теперь усложним задачу. Здесь в операторе цикла получается два условия: либо счетчик по i доходит до 20, либо значение суммы S превысит 20. Данную логику можно реализовать с помощью составного условного выражения в операторе цикла while:
function sum_i
S = 0; % начальное значение суммы
i=1; % счетчик суммы
while (i<=20)&(S<=20) % цикл (работает пока i<=10 и S<=20
S=S+i; % подсчитывается сумма
i=i+1; % увеличивается счетчик на 1
end % конец цикла

оператора цикла, в том числе и while, можно принудительно завершить

с помощью оператора break. Например, предыдущую программу можно переписать следующим образом с использованием оператора break:
function sum_i
S = 0; % начальное значение суммы
i=1; % счетчик суммы
while i <= 20 % цикл (работает пока i<=10
S=S+i; % подсчитывается сумма
i=i+1; % увеличивается счетчик на 1
if S > 20 % если S > 20,
break; % цикл завершается
end
end % конец цикла
disp(S); % отображение суммы 21 на экране
В данном примере второе условие завершения цикла, когда S будет больше 20, записано в самом цикле и с помощью оператора break осуществляется выход из цикла на функцию disp(), стоящую сразу после цикла while.

управления выполнением цикла - continue , позволяет пропускать выполнение фрагмента

программы, стоящий после него. Например, требуется подсчитать сумму элементов массива a = [1 2 3 4 5 6 7 8 9] ,исключая элемент с индексом 5.
function sum_array
S = 0; % начальное значение суммы
a = [1 2 3 4 5 6 7 8 9];
i=0; % счетчик индексов массива
while i < length(a) % цикл (работает пока i меньше длины массива а
i=i+1; % увеличивается счетчик индексов на 1
if i == 5 % если индекс равен 5
continue; % то его не подсчитываем
end
S=S+a(i); % подсчитывается сумма элементов
end % конец цикла
disp(S); % отображение суммы 40 на экране
Следует отметить, что в данной программе увеличение индекса массива i происходит до проверки условия. Это сделано для того, чтобы значение индекса увеличивалось на 1 на каждой итерации работы цикла. Если увеличение счетчика i записать как в предыдущих примерах, т.е. после подсчета суммы, то из-за оператора continue его значение остановилось бы на 5 и цикл while работал бы «вечно».

организации цикла требуется перебирать значение счетчика в заданном диапазоне значений

и с заданным шагом изменения.
Например, чтобы перебрать элементы вектора (массива), нужно организовать счетчик от 1 до N с шагом 1, где N – число элементов вектора.
Чтобы вычислить сумму ряда, также задается счетчик от a до b с требуемым шагом изменения step. И так далее.
В связи с тем, что подобные задачи часто встречаются в практике программирования, для их реализации был предложен свой оператор цикла for, который позволяет проще и нагляднее реализовывать цикл со счетчиком.
Синтаксис оператора цикла for имеет следующий вид:

for <счетчик> = <начальное значение>:<шаг>:<конечное значение>
<операторы цикла>
end

данного цикла на примере реализации алгоритма поиска максимального значения элемента

в векторе:
function search_max
a = [3 6 5 3 6 9 5 3 1 0];
m = a(1); % текущее максимальное значение
for i=1:length(a) % цикл от 1 до конца вектора, шаг 1 (по умолчанию)
if m < a(i) % если текущее значение элемента > m,
m = a(i); % тогда m п рисвоить это значение
end
end % конец цикла for
disp(m);
В данном примере цикл for задает счетчик i и меняет его значение от 1 до 10 с шагом 1 .
Обратите внимание, что если величина шага не указывается явно, то он берется по умолчанию равным 1.

алгоритма смещения элементов вектора вправо, т.е. предпоследний элемент ставится на

место последнего, следующий – на место предпоследнего, и т.д. до первого элемента:
function queue
a = [3 6 5 3 6 9 5 3 1 0];
disp(a); % вывод на экран значений элементов вектора
for i=length(a):-1:2 % цикл от 10 до 2 с шагом -1
a(i)=a(i-1); % смещаем элементы вектора а
end % конец цикла for
disp(a); % вывод на экран значений элементов вектора
Результат работы программы
3 6 5 3 6 9 5 3 1 0
3 3 6 5 3 6 9 5 3 1
Приведенный пример показывает, что для реализации цикла со счетчиком от большего значения к меньшему, нужно явно указывать шаг, в данном случае, -1. Если этого не сделать, то цикл сразу завершит свою работу и программа будет работать некорректно.