Курс лекций по "Программированию и компьютерам"

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

Приведем пример создания вектора ячеек хранения разных типов данных.

book = 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() можно передавать произвольное число двумерных векторов.

Глава 2. Условные операторы и циклы  в MatLab

Вторым шагом создания полноценных программ на языке MatLab является изучение операторов ветвления и циклов. С их помощью можно реализовывать логику выполнения математических алгоритмов и создавать повторяющиеся (итерационные, рекуррентные) вычисления.

2.1. Условный оператор if

Для того чтобы иметь  возможность реализовать логику в программе используются условные операторы. Умозрительно эти операторы  можно представить в виде узловых  пунктов, достигая которых программа  делает выбор по какому из возможных  направлений двигаться дальше. Например, требуется определить, содержит ли некоторая переменная arg положительное или отрицательное число и вывести соответствующее сообщение на экран. Для этого можно воспользоваться оператором if (если), который и выполняет подобные проверки.

В самом простом случае синтаксис данного оператора if имеет  вид:

if <выражение>  
<операторы>  
end

Если значение параметра  «выражение» соответствует значению «истинно», то выполняется оператор, иначе он пропускается программой. Следует отметить, что «выражение» является условным выражением, в котором выполняется проверка некоторого условия. В табл. 2.1 представлены варианты простых логических выражений оператора if.

Таблица 2.1. Простые логические выражения 

if a < b	Истинно, если переменная a меньше переменной b и ложно в противном случае.
if a > b	Истинно, если переменная a больше переменной b и ложно в противном случае.
if a == b	Истинно, если переменная a равна переменной b и ложно в противном случае.
if a <= b	Истинно, если переменная a меньше либо равна переменной b и ложно в противном случае.
if a >= b	Истинно, если переменная a больше либо равна переменной b и ложно в  противном случае.
if a ~= b	Истинно, если переменная a не равна переменной b и ложно в противном случае.

Ниже представлен пример реализации функции sign(), которая возвращает +1, если число больше нуля, -1 – если число меньше нуля и 0, если число равно нулю:

function my_sign  
x = 5;  
if x > 0  
disp(1);  
end  
if x < 0  
disp(-1);  
end  
if x == 0  
disp(0);  
end

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

if <выражение>  
<операторы1>       % выполняются, если истинно условие  
else  
<операторы2>       % выполняются, если условие ложно  
end

Тогда приведенный выше пример можно  записать следующим образом:

function my_sign  
x = 5;  
if x > 0  
disp(1);  
else  
if x < 0  
disp(-1);  
else  
disp(0);  
end  
end

В данной программе сначала  выполняется проверка на положительность  переменной x, и если это так, то на экран выводится значение 1, а  все другие условия игнорируются. Если же первое условие оказалось ложным, то выполнение программы переходит по else (иначе) на второе условие, где выполняется проверка переменной x на отрицательность, и в случае истинности условия, на экран выводится значение -1. Если оба условия оказались ложными, то выводится значение 0.

Приведенный выше пример можно записать в более простой форме, используя  еще одну конструкцию оператора if языка MatLab:

if <выражение1>  
<операторы1>       % выполняются, если истинно выражение1  
elseif <выражение2>  
<операторы2>       % выполняются, если истинно выражение2  
...  
elseif <выражениеN>  
<операторыN>       % выполняются, если истинно выражениеN  
end

и записывается следующим образом:

function my_sign  
x = 5;  
if x > 0  
     disp(1);       % выполняется, если x > 0  
elseif x < 0  
     disp(-1);      % выполняется, если x < 0  
else  
     disp(0);       % выполняется, если x = 0  
end

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

Для реализации составных условий  в MatLab используются логические операторы:

& - логическое И  
| - логическое ИЛИ  
~ - логическое НЕ

Рассмотрим пример использования  составных условий. Пусть требуется  проверить попадание переменной x в диапазон от 0 до 2. Программа запишется  следующим образом:

function my_if  
x = 1;  
if x >= 0 & x <= 2  
   disp('x принадлежит диапазону от 0 до 2');  
else  
   disp('x  не принадлежит диапазону от 0 до 2');  
end

Во втором примере выполним проверку на не принадлежность переменной x диапазону  от 0 до 2. Это достигается срабатыванием одного из двух условий: x < 0 или x > 2:

function my_if  
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. Очевидно, что такая проверка давала бы другой результат от ожидаемого.

Круглые скобки в программировании используются для изменения приоритетов выполнения операторов. Подобно арифметическим операторам, логические также могут быть изменены по желанию программиста. Благодаря использованию круглых скобок, сначала выполняется проверка внутри них, а, затем, за их пределами. Именно поэтому в приведенном выше примере они необходимы для достижения требуемого результата.

Приоритет логических операций следующий:

НЕ (~) – самый высокий приоритет;  
И (&) – средний приоритет;  
ИЛИ (|) – самый низкий приоритет.

2.2. Условный оператор switch

В некоторых задачах  программирования требуется выполнять  проверку на равенство некоторой  переменной константным значениям. Например, нужно преобразовать малые  буквы в заглавные. В этом случае необходимо произвести проверку текущего символа со всеми возможными буквами алфавита и при равенстве с одной из них, заменить ее на заглавную. Для решения таких задач удобнее пользоваться условным оператором switch, который имеет следующий синтаксис:

switch expr  
          case case_expr,  
            <операторы1>  
          case {case_expr1, case_expr2, case_expr3,...}  
            <операторы2>  
         ...  
          otherwise,  
            <операторы>  
end

Здесь expr – переменная, значение которой  проверяется на равенство тем  или иным константам; case_expr – константы, с которым сравнивается значение переменной; otherwise – ключевое слово, для выполнения операторов, при всех ложных условиях.

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

function upper_symbol  
ch='c';  
switch ch  
    case 'a', ch='A';  
    case 'b', ch='B';  
    case 'c', ch='C';  
    case 'd', ch='D';  
    case 'e', ch='E';  
   ...  
    case 'z', ch='Z';  
end  
 
disp(ch);

В данной программе задается символьная переменная ch со значением c. Затем, с помощью оператора switch проверяется ее значение со всеми возможными малыми буквами латинского алфавита от а до z. Как только одно из условий сработало, оператор switch завершает свою работу и выполнение программы переходит на функцию disp(), которая отображает значение переменной ch на экран.

2.3. Оператор цикла while

Язык программирования 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                     % конец цикла  
disp(S);                % отображение суммы 210 на экране

Теперь усложним задачу и будем  подсчитывать сумму ряда , пока . Здесь в операторе цикла получается два условия: либо счетчик по 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                     % конец цикла  
disp(S);                % отображение суммы 21 на экране

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

Работу любого оператора цикла, в том числе и 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.